WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            divp(x,y) -> =(rem(x,y),0())
            prime(0()) -> false()
            prime(s(0())) -> false()
            prime(s(s(x))) -> prime1(s(s(x)),s(x))
            prime1(x,0()) -> false()
            prime1(x,s(0())) -> true()
            prime1(x,s(s(y))) -> and(not(divp(s(s(y)),x)),prime1(x,s(y)))
        - Signature:
            {divp/2,prime/1,prime1/2} / {0/0,=/2,and/2,false/0,not/1,rem/2,s/1,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {divp,prime,prime1} and constructors {0,=,and,false,not
            ,rem,s,true}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(and) = {1,2},
          uargs(not) = {1}
        
        Following symbols are considered usable:
          {divp,prime,prime1}
        TcT has computed the following interpretation:
               p(0) = 0      
               p(=) = 0      
             p(and) = x1 + x2
            p(divp) = 7      
           p(false) = 3      
             p(not) = 1 + x1 
           p(prime) = 9 + x1 
          p(prime1) = 6 + x2 
             p(rem) = 0      
               p(s) = 9 + x1 
            p(true) = 0      
        
        Following rules are strictly oriented:
                divp(x,y) = 7                                       
                          > 0                                       
                          = =(rem(x,y),0())                         
        
               prime(0()) = 9                                       
                          > 3                                       
                          = false()                                 
        
            prime(s(0())) = 18                                      
                          > 3                                       
                          = false()                                 
        
           prime(s(s(x))) = 27 + x                                  
                          > 15 + x                                  
                          = prime1(s(s(x)),s(x))                    
        
            prime1(x,0()) = 6                                       
                          > 3                                       
                          = false()                                 
        
         prime1(x,s(0())) = 15                                      
                          > 0                                       
                          = true()                                  
        
        prime1(x,s(s(y))) = 24 + y                                  
                          > 23 + y                                  
                          = and(not(divp(s(s(y)),x)),prime1(x,s(y)))
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))