WORST_CASE(?,O(n^1))
* Step 1: NaturalMI 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:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        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) = [1] x1 + [2]          
            p(compS_f) = [1] x1 + [6]          
          p(compS_f#1) = [1] x1 + [2] x2 + [12]
                 p(id) = [3]                   
             p(iter#3) = [4] x1 + [0]          
               p(main) = [4] x1 + [14]         
        
        Following rules are strictly oriented:
        compS_f#1(compS_f(x2),x1) = [2] x1 + [1] x2 + [18]   
                                  > [2] x1 + [1] x2 + [16]   
                                  = compS_f#1(x2,S(x1))      
        
               compS_f#1(id(),x3) = [2] x3 + [15]            
                                  > [1] x3 + [2]             
                                  = S(x3)                    
        
                      iter#3(0()) = [4]                      
                                  > [3]                      
                                  = id()                     
        
                    iter#3(S(x6)) = [4] x6 + [8]             
                                  > [4] x6 + [6]             
                                  = compS_f(iter#3(x6))      
        
                        main(0()) = [18]                     
                                  > [1]                      
                                  = 0()                      
        
                      main(S(x9)) = [4] x9 + [22]            
                                  > [4] x9 + [14]            
                                  = compS_f#1(iter#3(x9),0())
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))