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) = x0,
       
       [plus](x0, x1) = -8x0 + 2x1 + 1,
       
       [half](x0) = -1x0 + 0,
       
       [even] = 1,
       
       [odd] = 0,
       
       [s](x0) = 2x0 + 3,
       
       [zero] = 0,
       
       [check](x0) = x0,
       
       [0] = 0
      orientation:
       if#(even(),x,y,z,u) = x + 1 >= -1x + 0 = 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 + 0 >= x = timesIter#(p(x),y,u)
       
       if#(even(),x,y,z,u) = x + 1 >= -1x + 0 = timesIter#(half(x),y,half(z))
       
       half(s(0())) = 2 >= 0 = 0()
       
       half(s(s(x))) = 3x + 4 >= 1x + 3 = s(half(x))
       
       half(0()) = 0 >= 0 = 0()
       
       plus(0(),y) = 2y + 1 >= y = y
       
       plus(s(x),y) = -6x + 2y + 1 >= -6x + 4y + 3 = s(plus(x,y))
       
       check(0()) = 0 >= 0 = zero()
       
       check(s(0())) = 3 >= 0 = odd()
       
       check(s(s(0()))) = 5 >= 1 = even()
       
       check(s(s(s(x)))) = 6x + 7 >= 2x + 3 = check(s(x))
       
       p(s(x)) = 2x + 3 >= x = x
       
       p(0()) = 0 >= 0 = 0()
      problem:
       DPs:
        timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
        if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u)
       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:
        timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
        if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u)
       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:
         timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
         if#(odd(),x,y,z,u) -> timesIter#(p(x),y,u)
        TRS:
         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:
          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) = 1x0 + x1,
          
          [timesIter#](x0, x1, x2) = 1x0 + -16,
          
          [p](x0) = -2x0 + 3,
          
          [plus](x0, x1) = 4x0 + x1 + 2,
          
          [even] = 2,
          
          [odd] = 5,
          
          [s](x0) = 2x0 + 2,
          
          [zero] = 3,
          
          [check](x0) = x0,
          
          [0] = 3
         orientation:
          timesIter#(x,y,z) = 1x + -16 >= 1x = if#(check(x),x,y,z,plus(z,y))
          
          if#(odd(),x,y,z,u) = x + 6 >= -1x + 4 = timesIter#(p(x),y,u)
          
          plus(0(),y) = y + 7 >= y = y
          
          plus(s(x),y) = 6x + y + 6 >= 6x + 2y + 4 = s(plus(x,y))
          
          check(0()) = 3 >= 3 = zero()
          
          check(s(0())) = 5 >= 5 = odd()
          
          check(s(s(0()))) = 7 >= 2 = even()
          
          check(s(s(s(x)))) = 6x + 6 >= 2x + 2 = check(s(x))
          
          p(s(x)) = x + 3 >= x = x
          
          p(0()) = 3 >= 3 = 0()
         problem:
          DPs:
           timesIter#(x,y,z) -> if#(check(x),x,y,z,plus(z,y))
          TRS:
           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:
           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