WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            f(x,h1(y,z)) -> h2(0(),x,h1(y,z))
            f(j(x,y),y) -> g(f(x,k(y)))
            g(h2(x,y,h1(z,u))) -> h2(s(x),y,h1(z,u))
            h2(x,j(y,h1(z,u)),h1(z,u)) -> h2(s(x),y,h1(s(z),u))
            i(f(x,h(y))) -> y
            i(h2(s(x),y,h1(x,z))) -> z
            k(h(x)) -> h1(0(),x)
            k(h1(x,y)) -> h1(s(x),y)
        - Signature:
            {f/2,g/1,h2/3,i/1,k/1} / {0/0,h/1,h1/2,j/2,s/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {f,g,h2,i,k} and constructors {0,h,h1,j,s}
    + 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(f) = {2},
          uargs(g) = {1}
        
        Following symbols are considered usable:
          {f,g,h2,i,k}
        TcT has computed the following interpretation:
           p(0) = [0]                           
           p(f) = [4] x1 + [1] x2 + [7]         
           p(g) = [1] x1 + [6]                  
           p(h) = [1] x1 + [0]                  
          p(h1) = [1] x2 + [0]                  
          p(h2) = [2] x1 + [1] x2 + [1] x3 + [0]
           p(i) = [1] x1 + [2]                  
           p(j) = [1] x1 + [6]                  
           p(k) = [1] x1 + [4]                  
           p(s) = [1] x1 + [1]                  
        
        Following rules are strictly oriented:
                      f(x,h1(y,z)) = [4] x + [1] z + [7]        
                                   > [1] x + [1] z + [0]        
                                   = h2(0(),x,h1(y,z))          
        
                       f(j(x,y),y) = [4] x + [1] y + [31]       
                                   > [4] x + [1] y + [17]       
                                   = g(f(x,k(y)))               
        
                g(h2(x,y,h1(z,u))) = [1] u + [2] x + [1] y + [6]
                                   > [1] u + [2] x + [1] y + [2]
                                   = h2(s(x),y,h1(z,u))         
        
        h2(x,j(y,h1(z,u)),h1(z,u)) = [1] u + [2] x + [1] y + [6]
                                   > [1] u + [2] x + [1] y + [2]
                                   = h2(s(x),y,h1(s(z),u))      
        
                      i(f(x,h(y))) = [4] x + [1] y + [9]        
                                   > [1] y + [0]                
                                   = y                          
        
             i(h2(s(x),y,h1(x,z))) = [2] x + [1] y + [1] z + [4]
                                   > [1] z + [0]                
                                   = z                          
        
                           k(h(x)) = [1] x + [4]                
                                   > [1] x + [0]                
                                   = h1(0(),x)                  
        
                        k(h1(x,y)) = [1] y + [4]                
                                   > [1] y + [0]                
                                   = h1(s(x),y)                 
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))