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:
       [odd] = 6,
       
       [check](x0) = x0,
       
       [s](x0) = 1x0 + 0,
       
       [timesIter#](x0, x1, x2) = x0 + -16,
       
       [if#](x0, x1, x2, x3, x4) = x0 + x1 + -16,
       
       [even] = 0,
       
       [0] = 5,
       
       [plus](x0, x1) = x1 + 0,
       
       [p](x0) = -1x0 + 5,
       
       [half](x0) = x0,
       
       [zero] = 2
      orientation:
       if#(even(),x,y,z,u) = x + 0 >= x + -16 = timesIter#(half(x),y,half(s(z)))
       
       timesIter#(x,y,z) = x + -16 >= x + -16 = if#(check(x),x,y,z,plus(z,y))
       
       if#(odd(),x,y,z,u) = x + 6 >= -1x + 5 = timesIter#(p(x),y,u)
       
       if#(even(),x,y,z,u) = x + 0 >= x + -16 = timesIter#(half(x),y,half(z))
       
       half(s(0())) = 6 >= 5 = 0()
       
       half(s(s(x))) = 2x + 1 >= 1x + 0 = s(half(x))
       
       half(0()) = 5 >= 5 = 0()
       
       plus(0(),y) = y + 0 >= y = y
       
       plus(s(x),y) = y + 0 >= 1y + 1 = s(plus(x,y))
       
       check(0()) = 5 >= 2 = zero()
       
       check(s(0())) = 6 >= 6 = odd()
       
       check(s(s(0()))) = 7 >= 0 = even()
       
       check(s(s(s(x)))) = 3x + 2 >= 1x + 0 = check(s(x))
       
       p(s(x)) = x + 5 >= x = x
       
       p(0()) = 5 >= 5 = 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))
        Matrix Interpretation Processor: dim=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:
          [odd] = 0,
          
          [check](x0) = 2x0,
          
          [s](x0) = 3x0 + 2,
          
          [timesIter#](x0, x1, x2) = 2x0 + x1 + 3/2,
          
          [if#](x0, x1, x2, x3, x4) = 1/2x0 + x1 + x2 + 1,
          
          [even] = 1,
          
          [0] = 0,
          
          [plus](x0, x1) = 1/2,
          
          [half](x0) = 1/2x0,
          
          [zero] = 0
         orientation:
          if#(even(),x,y,z,u) = x + y + 3/2 >= x + y + 3/2 = timesIter#(half(x),y,half(s(z)))
          
          timesIter#(x,y,z) = 2x + y + 3/2 >= 2x + y + 1 = if#(check(x),x,y,z,plus(z,y))
          
          if#(even(),x,y,z,u) = x + y + 3/2 >= x + y + 3/2 = timesIter#(half(x),y,half(z))
          
          half(s(0())) = 1 >= 0 = 0()
          
          half(s(s(x))) = 9/2x + 4 >= 3/2x + 2 = s(half(x))
          
          half(0()) = 0 >= 0 = 0()
          
          plus(0(),y) = 1/2 >= y = y
          
          plus(s(x),y) = 1/2 >= 7/2 = s(plus(x,y))
          
          check(0()) = 0 >= 0 = zero()
          
          check(s(0())) = 4 >= 0 = odd()
          
          check(s(s(0()))) = 16 >= 1 = even()
          
          check(s(s(s(x)))) = 54x + 52 >= 6x + 4 = check(s(x))
         problem:
          DPs:
           if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
           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))
         Restore Modifier:
          DPs:
           if#(even(),x,y,z,u) -> timesIter#(half(x),y,half(s(z)))
           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))))
          SCC Processor:
           #sccs: 0
           #rules: 0
           #arcs: 6/4
           
    
    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