WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            compS_f#1(compS_f(x2),x1) -> compS_f#1(x2,S(x1))
            compS_f#1(id(),x3) -> S(x3)
            iter#3(0()) -> id()
            iter#3(S(x6)) -> compS_f(iter#3(x6))
            main(0()) -> 0()
            main(S(x9)) -> compS_f#1(iter#3(x9),0())
        - Signature:
            {compS_f#1/2,iter#3/1,main/1} / {0/0,S/1,compS_f/1,id/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {compS_f#1,iter#3,main} and constructors {0,S,compS_f,id}
    + 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(compS_f) = {1},
          uargs(compS_f#1) = {1}
        
        Following symbols are considered usable:
          {compS_f#1,iter#3,main}
        TcT has computed the following interpretation:
                  p(0) = 1               
                  p(S) = 3 + x1          
            p(compS_f) = 8 + x1          
          p(compS_f#1) = 11 + 2*x1 + 3*x2
                 p(id) = 6               
             p(iter#3) = 7 + 3*x1        
               p(main) = 7 + 8*x1        
        
        Following rules are strictly oriented:
        compS_f#1(compS_f(x2),x1) = 27 + 3*x1 + 2*x2         
                                  > 20 + 3*x1 + 2*x2         
                                  = compS_f#1(x2,S(x1))      
        
               compS_f#1(id(),x3) = 23 + 3*x3                
                                  > 3 + x3                   
                                  = S(x3)                    
        
                      iter#3(0()) = 10                       
                                  > 6                        
                                  = id()                     
        
                    iter#3(S(x6)) = 16 + 3*x6                
                                  > 15 + 3*x6                
                                  = compS_f(iter#3(x6))      
        
                        main(0()) = 15                       
                                  > 1                        
                                  = 0()                      
        
                      main(S(x9)) = 31 + 8*x9                
                                  > 28 + 6*x9                
                                  = compS_f#1(iter#3(x9),0())
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))