WORST_CASE(?,O(n^3))
* Step 1: MI WORST_CASE(?,O(n^3))
    + Considered Problem:
        - Strict TRS:
            f(.(.(x,y),z)) -> f(.(x,.(y,z)))
            f(.(nil(),y)) -> .(nil(),f(y))
            f(nil()) -> nil()
            g(.(x,.(y,z))) -> g(.(.(x,y),z))
            g(.(x,nil())) -> .(g(x),nil())
            g(nil()) -> nil()
        - Signature:
            {f/1,g/1} / {./2,nil/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {f,g} and constructors {.,nil}
    + Applied Processor:
        MI {miKind = Automaton Nothing, miDimension = 3, miUArgs = NoUArgs, miURules = NoURules, miSelector = Nothing}
    + Details:
        We apply a matrix interpretation of kind Automaton Nothing:
        
        
        Following symbols are considered usable:
          all
        TcT has computed the following interpretation:
            p(.) = [1 0 0]       [1 0 0]       [1]
                   [0 1 0] x_1 + [1 0 0] x_2 + [0]
                   [1 0 0]       [0 0 1]       [0]
            p(f) = [2 0 1]       [0]              
                   [2 0 1] x_1 + [0]              
                   [0 0 1]       [1]              
            p(g) = [2 1 0]       [1]              
                   [3 0 0] x_1 + [0]              
                   [0 2 2]       [0]              
          p(nil) = [1]                            
                   [2]                            
                   [1]                            
        
        Following rules are strictly oriented:
        f(.(.(x,y),z)) = [3 0 0]     [3 0 0]     [2 0 1]     [5]
                         [3 0 0] x + [3 0 0] y + [2 0 1] z + [5]
                         [1 0 0]     [1 0 0]     [0 0 1]     [2]
                       > [3 0 0]     [3 0 0]     [2 0 1]     [4]
                         [3 0 0] x + [3 0 0] y + [2 0 1] z + [4]
                         [1 0 0]     [1 0 0]     [0 0 1]     [1]
                       = f(.(x,.(y,z)))                         
        
         f(.(nil(),y)) = [2 0 1]     [5]                        
                         [2 0 1] y + [5]                        
                         [0 0 1]     [2]                        
                       > [2 0 1]     [2]                        
                         [2 0 1] y + [2]                        
                         [0 0 1]     [2]                        
                       = .(nil(),f(y))                          
        
              f(nil()) = [3]                                    
                         [3]                                    
                         [2]                                    
                       > [1]                                    
                         [2]                                    
                         [1]                                    
                       = nil()                                  
        
        g(.(x,.(y,z))) = [2 1 0]     [3 0 0]     [3 0 0]     [6]
                         [3 0 0] x + [3 0 0] y + [3 0 0] z + [6]
                         [2 2 0]     [4 0 0]     [2 0 2]     [2]
                       > [2 1 0]     [3 0 0]     [3 0 0]     [5]
                         [3 0 0] x + [3 0 0] y + [3 0 0] z + [6]
                         [2 2 0]     [4 0 0]     [2 0 2]     [2]
                       = g(.(.(x,y),z))                         
        
         g(.(x,nil())) = [2 1 0]     [6]                        
                         [3 0 0] x + [6]                        
                         [2 2 0]     [4]                        
                       > [2 1 0]     [3]                        
                         [3 0 0] x + [1]                        
                         [2 1 0]     [2]                        
                       = .(g(x),nil())                          
        
              g(nil()) = [5]                                    
                         [3]                                    
                         [6]                                    
                       > [1]                                    
                         [2]                                    
                         [1]                                    
                       = nil()                                  
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^3))