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


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


YES

Problem:
 check(0()) -> zero()
 check(s(0())) -> odd()
 check(s(s(0()))) -> even()
 check(s(s(s(x)))) -> check(s(x))
 half(0()) -> 0()
 half(s(0())) -> 0()
 half(s(s(x))) -> s(half(x))
 plus(0(),y) -> y
 plus(s(x),y) -> s(plus(x,y))
 times(x,y) -> timesIter(x,y,0())
 timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
 p(s(x)) -> x
 p(0()) -> 0()
 if(zero(),x,y,z,u) -> z
 if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
 if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))

Proof:
 DP Processor:
  DPs:
   check#(s(s(s(x)))) -> check#(s(x))
   half#(s(s(x))) -> half#(x)
   plus#(s(x),y) -> plus#(x,y)
   times#(x,y) -> timesIter#(x,y,0())
   timesIter#(x,y,z) -> plus#(z,y)
   timesIter#(x,y,z) -> check#(x)
   timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
   if#(odd(),x,y,z,u) -> p#(x)
   if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u)
   if#(even(),x,y,z,u) -> half#(s(z))
   if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
   if#(even(),x,y,z,u) -> half#(z)
   if#(even(),x,y,z,u) -> half#(x)
   if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z))
   if#(even(),x,y,z,u) -> plus#(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
  TRS:
   check(0()) -> zero()
   check(s(0())) -> odd()
   check(s(s(0()))) -> even()
   check(s(s(s(x)))) -> check(s(x))
   half(0()) -> 0()
   half(s(0())) -> 0()
   half(s(s(x))) -> s(half(x))
   plus(0(),y) -> y
   plus(s(x),y) -> s(plus(x,y))
   times(x,y) -> timesIter(x,y,0())
   timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
   p(s(x)) -> x
   p(0()) -> 0()
   if(zero(),x,y,z,u) -> z
   if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
   if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
  TDG Processor:
   DPs:
    check#(s(s(s(x)))) -> check#(s(x))
    half#(s(s(x))) -> half#(x)
    plus#(s(x),y) -> plus#(x,y)
    times#(x,y) -> timesIter#(x,y,0())
    timesIter#(x,y,z) -> plus#(z,y)
    timesIter#(x,y,z) -> check#(x)
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
    if#(odd(),x,y,z,u) -> p#(x)
    if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u)
    if#(even(),x,y,z,u) -> half#(s(z))
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
    if#(even(),x,y,z,u) -> half#(z)
    if#(even(),x,y,z,u) -> half#(x)
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z))
    if#(even(),x,y,z,u) -> plus#(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
   TRS:
    check(0()) -> zero()
    check(s(0())) -> odd()
    check(s(s(0()))) -> even()
    check(s(s(s(x)))) -> check(s(x))
    half(0()) -> 0()
    half(s(0())) -> 0()
    half(s(s(x))) -> s(half(x))
    plus(0(),y) -> y
    plus(s(x),y) -> s(plus(x,y))
    times(x,y) -> timesIter(x,y,0())
    timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
    p(s(x)) -> x
    p(0()) -> 0()
    if(zero(),x,y,z,u) -> z
    if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
    if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
   graph:
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z))) ->
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z))) ->
    timesIter#(x,y,z) -> check#(x)
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z))) ->
    timesIter#(x,y,z) -> plus#(z,y)
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z)) ->
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z)) ->
    timesIter#(x,y,z) -> check#(x)
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z)) ->
    timesIter#(x,y,z) -> plus#(z,y)
    if#(even(),x,y,z,u) -> plus#(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z)))) ->
    plus#(s(x),y) -> plus#(x,y)
    if#(even(),x,y,z,u) -> half#(s(z)) -> half#(s(s(x))) -> half#(x)
    if#(even(),x,y,z,u) -> half#(z) -> half#(s(s(x))) -> half#(x)
    if#(even(),x,y,z,u) -> half#(x) ->
    half#(s(s(x))) -> half#(x)
    if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u) ->
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
    if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u) ->
    timesIter#(x,y,z) -> check#(x)
    if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u) ->
    timesIter#(x,y,z) -> plus#(z,y)
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y)) ->
    if#(even(),x,y,z,u) -> plus#(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y)) ->
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z))
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y)) ->
    if#(even(),x,y,z,u) -> half#(x)
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y)) ->
    if#(even(),x,y,z,u) -> half#(z)
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y)) ->
    if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y)) ->
    if#(even(),x,y,z,u) -> half#(s(z))
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y)) ->
    if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u)
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y)) ->
    if#(odd(),x,y,z,u) -> p#(x)
    timesIter#(x,y,z) -> plus#(z,y) -> plus#(s(x),y) -> plus#(x,y)
    timesIter#(x,y,z) -> check#(x) ->
    check#(s(s(s(x)))) -> check#(s(x))
    times#(x,y) -> timesIter#(x,y,0()) ->
    timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
    times#(x,y) -> timesIter#(x,y,0()) ->
    timesIter#(x,y,z) -> check#(x)
    times#(x,y) -> timesIter#(x,y,0()) ->
    timesIter#(x,y,z) -> plus#(z,y)
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),y) -> plus#(x,y)
    half#(s(s(x))) -> half#(x) -> half#(s(s(x))) -> half#(x)
    check#(s(s(s(x)))) -> check#(s(x)) -> check#(s(s(s(x)))) -> check#(s(x))
   SCC Processor:
    #sccs: 4
    #rules: 7
    #arcs: 29/225
    DPs:
     if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
     timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
     if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u)
     if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z))
    TRS:
     check(0()) -> zero()
     check(s(0())) -> odd()
     check(s(s(0()))) -> even()
     check(s(s(s(x)))) -> check(s(x))
     half(0()) -> 0()
     half(s(0())) -> 0()
     half(s(s(x))) -> s(half(x))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     times(x,y) -> timesIter(x,y,0())
     timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
     p(s(x)) -> x
     p(0()) -> 0()
     if(zero(),x,y,z,u) -> z
     if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
     if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
    Usable Rule Processor:
     DPs:
      if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
      timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
      if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u)
      if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z))
     TRS:
      half(s(0())) -> 0()
      half(s(s(x))) -> s(half(x))
      half(0()) -> 0()
      plus(0(),y) -> y
      plus(s(x),y) -> s(plus(x,y))
      check(0()) -> zero()
      check(s(0())) -> odd()
      check(s(s(0()))) -> even()
      check(s(s(s(x)))) -> check(s(x))
      p(s(x)) -> x
      p(0()) -> 0()
     Arctic Interpretation Processor:
      dimension: 1
      usable rules:
       half(s(0())) -> 0()
       half(s(s(x))) -> s(half(x))
       half(0()) -> 0()
       check(0()) -> zero()
       check(s(0())) -> odd()
       check(s(s(0()))) -> even()
       check(s(s(s(x)))) -> check(s(x))
       p(s(x)) -> x
       p(0()) -> 0()
      interpretation:
       [if#](x0, x1, x2, x3, x4) = x0 + x1,
       
       [timesIter#](x0, x1, x2) = x0,
       
       [p](x0) = -1x0 + 0,
       
       [plus](x0, x1) = 5x0 + -9x1 + 5,
       
       [half](x0) = x0,
       
       [even] = 0,
       
       [odd] = 1,
       
       [s](x0) = 1x0,
       
       [zero] = 0,
       
       [check](x0) = x0,
       
       [0] = 0
      orientation:
       if#(even(),x,y,z,u) = x + 0 >= x = timesIter#(half(x),y,half(s(z)))
       
       timesIter#(x,y,z) = x >= x = if#(check(x),x,y,z,plus(z,y))
       
       if#(odd(),x,y,z,u) = x + 1 >= -1x + 0 = timesIter#(p(x),y,u)
       
       if#(even(),x,y,z,u) = x + 0 >= x = timesIter#(half(x),y,half(z))
       
       half(s(0())) = 1 >= 0 = 0()
       
       half(s(s(x))) = 2x >= 1x = s(half(x))
       
       half(0()) = 0 >= 0 = 0()
       
       plus(0(),y) = -9y + 5 >= y = y
       
       plus(s(x),y) = 6x + -9y + 5 >= 6x + -8y + 6 = s(plus(x,y))
       
       check(0()) = 0 >= 0 = zero()
       
       check(s(0())) = 1 >= 1 = odd()
       
       check(s(s(0()))) = 2 >= 0 = even()
       
       check(s(s(s(x)))) = 3x >= 1x = check(s(x))
       
       p(s(x)) = x + 0 >= x = x
       
       p(0()) = 0 >= 0 = 0()
      problem:
       DPs:
        if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
        timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
        if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z))
       TRS:
        half(s(0())) -> 0()
        half(s(s(x))) -> s(half(x))
        half(0()) -> 0()
        plus(0(),y) -> y
        plus(s(x),y) -> s(plus(x,y))
        check(0()) -> zero()
        check(s(0())) -> odd()
        check(s(s(0()))) -> even()
        check(s(s(s(x)))) -> check(s(x))
        p(s(x)) -> x
        p(0()) -> 0()
      Restore Modifier:
       DPs:
        if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
        timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
        if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z))
       TRS:
        check(0()) -> zero()
        check(s(0())) -> odd()
        check(s(s(0()))) -> even()
        check(s(s(s(x)))) -> check(s(x))
        half(0()) -> 0()
        half(s(0())) -> 0()
        half(s(s(x))) -> s(half(x))
        plus(0(),y) -> y
        plus(s(x),y) -> s(plus(x,y))
        times(x,y) -> timesIter(x,y,0())
        timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
        p(s(x)) -> x
        p(0()) -> 0()
        if(zero(),x,y,z,u) -> z
        if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
        if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
       Usable Rule Processor:
        DPs:
         if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
         timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
         if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(z))
        TRS:
         half(s(0())) -> 0()
         half(s(s(x))) -> s(half(x))
         half(0()) -> 0()
         plus(0(),y) -> y
         plus(s(x),y) -> s(plus(x,y))
         check(0()) -> zero()
         check(s(0())) -> odd()
         check(s(s(0()))) -> even()
         check(s(s(s(x)))) -> check(s(x))
        Arctic Interpretation Processor:
         dimension: 1
         usable rules:
          half(s(0())) -> 0()
          half(s(s(x))) -> s(half(x))
          half(0()) -> 0()
          check(0()) -> zero()
          check(s(0())) -> odd()
          check(s(s(0()))) -> even()
          check(s(s(s(x)))) -> check(s(x))
         interpretation:
          [if#](x0, x1, x2, x3, x4) = -1x0 + -1x1 + x3,
          
          [timesIter#](x0, x1, x2) = -1x0 + x2 + 0,
          
          [plus](x0, x1) = -7x0 + 2x1 + 2,
          
          [half](x0) = -1x0 + 1,
          
          [even] = 3,
          
          [odd] = 1,
          
          [s](x0) = 1x0 + 3,
          
          [zero] = 0,
          
          [check](x0) = -1x0 + 0,
          
          [0] = 1
         orientation:
          if#(even(),x,y,z,u) = -1x + z + 2 >= -2x + z + 2 = timesIter#(half(x),y,half(s(z)))
          
          timesIter#(x,y,z) = -1x + z + 0 >= -1x + z + -1 = if#(check(x),x,y,z,plus(z,y))
          
          if#(even(),x,y,z,u) = -1x + z + 2 >= -2x + -1z + 1 = timesIter#(half(x),y,half(z))
          
          half(s(0())) = 2 >= 1 = 0()
          
          half(s(s(x))) = 1x + 3 >= x + 3 = s(half(x))
          
          half(0()) = 1 >= 1 = 0()
          
          plus(0(),y) = 2y + 2 >= y = y
          
          plus(s(x),y) = -6x + 2y + 2 >= -6x + 3y + 3 = s(plus(x,y))
          
          check(0()) = 0 >= 0 = zero()
          
          check(s(0())) = 2 >= 1 = odd()
          
          check(s(s(0()))) = 3 >= 3 = even()
          
          check(s(s(s(x)))) = 2x + 4 >= x + 2 = check(s(x))
         problem:
          DPs:
           if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
           timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
          TRS:
           half(s(0())) -> 0()
           half(s(s(x))) -> s(half(x))
           half(0()) -> 0()
           plus(0(),y) -> y
           plus(s(x),y) -> s(plus(x,y))
           check(0()) -> zero()
           check(s(0())) -> odd()
           check(s(s(0()))) -> even()
           check(s(s(s(x)))) -> check(s(x))
         Restore Modifier:
          DPs:
           if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
           timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
          TRS:
           check(0()) -> zero()
           check(s(0())) -> odd()
           check(s(s(0()))) -> even()
           check(s(s(s(x)))) -> check(s(x))
           half(0()) -> 0()
           half(s(0())) -> 0()
           half(s(s(x))) -> s(half(x))
           plus(0(),y) -> y
           plus(s(x),y) -> s(plus(x,y))
           times(x,y) -> timesIter(x,y,0())
           timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
           p(s(x)) -> x
           p(0()) -> 0()
           if(zero(),x,y,z,u) -> z
           if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
           if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
          Usable Rule Processor:
           DPs:
            if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
            timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
           TRS:
            half(s(0())) -> 0()
            half(s(s(x))) -> s(half(x))
            half(0()) -> 0()
            plus(0(),y) -> y
            plus(s(x),y) -> s(plus(x,y))
            check(0()) -> zero()
            check(s(0())) -> odd()
            check(s(s(0()))) -> even()
            check(s(s(s(x)))) -> check(s(x))
           Arctic Interpretation Processor:
            dimension: 1
            usable rules:
             half(s(0())) -> 0()
             half(s(s(x))) -> s(half(x))
             half(0()) -> 0()
             check(0()) -> zero()
             check(s(0())) -> odd()
             check(s(s(0()))) -> even()
             check(s(s(s(x)))) -> check(s(x))
            interpretation:
             [if#](x0, x1, x2, x3, x4) = x0 + x1 + 0,
             
             [timesIter#](x0, x1, x2) = x0 + 0,
             
             [plus](x0, x1) = x0 + -6x1,
             
             [half](x0) = -1x0 + 0,
             
             [even] = 2,
             
             [odd] = 0,
             
             [s](x0) = 1x0 + 1,
             
             [zero] = 0,
             
             [check](x0) = x0 + 0,
             
             [0] = 0
            orientation:
             if#(even(),x,y,z,u) = x + 2 >= -1x + 0 = timesIter#(half(x),y,half(s(z)))
             
             timesIter#(x,y,z) = x + 0 >= x + 0 = if#(check(x),x,y,z,plus(z,y))
             
             half(s(0())) = 0 >= 0 = 0()
             
             half(s(s(x))) = 1x + 1 >= x + 1 = s(half(x))
             
             half(0()) = 0 >= 0 = 0()
             
             plus(0(),y) = -6y + 0 >= y = y
             
             plus(s(x),y) = 1x + -6y + 1 >= 1x + -5y + 1 = s(plus(x,y))
             
             check(0()) = 0 >= 0 = zero()
             
             check(s(0())) = 1 >= 0 = odd()
             
             check(s(s(0()))) = 2 >= 2 = even()
             
             check(s(s(s(x)))) = 3x + 3 >= 1x + 1 = check(s(x))
            problem:
             DPs:
              timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
             TRS:
              half(s(0())) -> 0()
              half(s(s(x))) -> s(half(x))
              half(0()) -> 0()
              plus(0(),y) -> y
              plus(s(x),y) -> s(plus(x,y))
              check(0()) -> zero()
              check(s(0())) -> odd()
              check(s(s(0()))) -> even()
              check(s(s(s(x)))) -> check(s(x))
            Restore Modifier:
             DPs:
              timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
             TRS:
              check(0()) -> zero()
              check(s(0())) -> odd()
              check(s(s(0()))) -> even()
              check(s(s(s(x)))) -> check(s(x))
              half(0()) -> 0()
              half(s(0())) -> 0()
              half(s(s(x))) -> s(half(x))
              plus(0(),y) -> y
              plus(s(x),y) -> s(plus(x,y))
              times(x,y) -> timesIter(x,y,0())
              timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
              p(s(x)) -> x
              p(0()) -> 0()
              if(zero(),x,y,z,u) -> z
              if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
              if(even(),x,y,z,u) ->
              plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
             SCC Processor:
              #sccs: 0
              #rules: 0
              #arcs: 6/1
              
    
    DPs:
     half#(s(s(x))) -> half#(x)
    TRS:
     check(0()) -> zero()
     check(s(0())) -> odd()
     check(s(s(0()))) -> even()
     check(s(s(s(x)))) -> check(s(x))
     half(0()) -> 0()
     half(s(0())) -> 0()
     half(s(s(x))) -> s(half(x))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     times(x,y) -> timesIter(x,y,0())
     timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
     p(s(x)) -> x
     p(0()) -> 0()
     if(zero(),x,y,z,u) -> z
     if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
     if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
    Subterm Criterion Processor:
     simple projection:
      pi(half#) = 0
     problem:
      DPs:
       
      TRS:
       check(0()) -> zero()
       check(s(0())) -> odd()
       check(s(s(0()))) -> even()
       check(s(s(s(x)))) -> check(s(x))
       half(0()) -> 0()
       half(s(0())) -> 0()
       half(s(s(x))) -> s(half(x))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       times(x,y) -> timesIter(x,y,0())
       timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
       p(s(x)) -> x
       p(0()) -> 0()
       if(zero(),x,y,z,u) -> z
       if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
       if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
     Qed
    
    DPs:
     check#(s(s(s(x)))) -> check#(s(x))
    TRS:
     check(0()) -> zero()
     check(s(0())) -> odd()
     check(s(s(0()))) -> even()
     check(s(s(s(x)))) -> check(s(x))
     half(0()) -> 0()
     half(s(0())) -> 0()
     half(s(s(x))) -> s(half(x))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     times(x,y) -> timesIter(x,y,0())
     timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
     p(s(x)) -> x
     p(0()) -> 0()
     if(zero(),x,y,z,u) -> z
     if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
     if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
    Subterm Criterion Processor:
     simple projection:
      pi(check#) = 0
     problem:
      DPs:
       
      TRS:
       check(0()) -> zero()
       check(s(0())) -> odd()
       check(s(s(0()))) -> even()
       check(s(s(s(x)))) -> check(s(x))
       half(0()) -> 0()
       half(s(0())) -> 0()
       half(s(s(x))) -> s(half(x))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       times(x,y) -> timesIter(x,y,0())
       timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
       p(s(x)) -> x
       p(0()) -> 0()
       if(zero(),x,y,z,u) -> z
       if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
       if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
     Qed
    
    DPs:
     plus#(s(x),y) -> plus#(x,y)
    TRS:
     check(0()) -> zero()
     check(s(0())) -> odd()
     check(s(s(0()))) -> even()
     check(s(s(s(x)))) -> check(s(x))
     half(0()) -> 0()
     half(s(0())) -> 0()
     half(s(s(x))) -> s(half(x))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     times(x,y) -> timesIter(x,y,0())
     timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
     p(s(x)) -> x
     p(0()) -> 0()
     if(zero(),x,y,z,u) -> z
     if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
     if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
    Subterm Criterion Processor:
     simple projection:
      pi(plus#) = 0
     problem:
      DPs:
       
      TRS:
       check(0()) -> zero()
       check(s(0())) -> odd()
       check(s(s(0()))) -> even()
       check(s(s(s(x)))) -> check(s(x))
       half(0()) -> 0()
       half(s(0())) -> 0()
       half(s(s(x))) -> s(half(x))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       times(x,y) -> timesIter(x,y,0())
       timesIter(x,y,z) -> if(check(x),x,y,z,plus(z,y))
       p(s(x)) -> x
       p(0()) -> 0()
       if(zero(),x,y,z,u) -> z
       if(odd(),x,y,z,u) -> timesIter(p(x),y,u)
       if(even(),x,y,z,u) -> plus(timesIter(half(x),y,half(z)),timesIter(half(x),y,half(s(z))))
     Qed