WORST_CASE(?,O(n^2))
* Step 1: NaturalMI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            append(@l1,@l2) -> append#1(@l1,@l2)
            append#1(::(@x,@xs),@l2) -> ::(@x,append(@xs,@l2))
            append#1(nil(),@l2) -> @l2
            subtrees(@t) -> subtrees#1(@t)
            subtrees#1(leaf()) -> nil()
            subtrees#1(node(@x,@t1,@t2)) -> subtrees#2(subtrees(@t1),@t1,@t2,@x)
            subtrees#2(@l1,@t1,@t2,@x) -> subtrees#3(subtrees(@t2),@l1,@t1,@t2,@x)
            subtrees#3(@l2,@l1,@t1,@t2,@x) -> ::(node(@x,@t1,@t2),append(@l1,@l2))
        - Signature:
            {append/2,append#1/2,subtrees/1,subtrees#1/1,subtrees#2/4,subtrees#3/5} / {::/2,leaf/0,nil/0,node/3}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {append,append#1,subtrees,subtrees#1,subtrees#2
            ,subtrees#3} and constructors {::,leaf,nil,node}
    + Applied Processor:
        NaturalMI {miDimension = 2, miDegree = 2, 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(::) = {2},
          uargs(subtrees#2) = {1},
          uargs(subtrees#3) = {1}
        
        Following symbols are considered usable:
          {append,append#1,subtrees,subtrees#1,subtrees#2,subtrees#3}
        TcT has computed the following interpretation:
                  p(::) = [1 0] x2 + [0]                      
                          [0 1]      [4]                      
              p(append) = [0 1] x1 + [1 0] x2 + [2]           
                          [0 1]      [0 1]      [0]           
            p(append#1) = [0 1] x1 + [1 0] x2 + [0]           
                          [0 1]      [0 1]      [0]           
                p(leaf) = [7]                                 
                          [4]                                 
                 p(nil) = [2]                                 
                          [2]                                 
                p(node) = [1 4] x1 + [1 4] x2 + [1 0] x3 + [7]
                          [0 0]      [0 1]      [0 1]      [2]
            p(subtrees) = [1 0] x1 + [1]                      
                          [0 2]      [0]                      
          p(subtrees#1) = [1 0] x1 + [0]                      
                          [0 2]      [0]                      
          p(subtrees#2) = [1 2] x1 + [1 0] x3 + [1 4] x4 + [5]
                          [0 1]      [0 2]      [0 0]      [4]
          p(subtrees#3) = [1 0] x1 + [1 1] x2 + [0 1] x5 + [3]
                          [0 1]      [0 1]      [0 0]      [4]
        
        Following rules are strictly oriented:
                       append(@l1,@l2) = [0 1] @l1 + [1 0] @l2 + [2]             
                                         [0 1]       [0 1]       [0]             
                                       > [0 1] @l1 + [1 0] @l2 + [0]             
                                         [0 1]       [0 1]       [0]             
                                       = append#1(@l1,@l2)                       
        
              append#1(::(@x,@xs),@l2) = [1 0] @l2 + [0 1] @xs + [4]             
                                         [0 1]       [0 1]       [4]             
                                       > [1 0] @l2 + [0 1] @xs + [2]             
                                         [0 1]       [0 1]       [4]             
                                       = ::(@x,append(@xs,@l2))                  
        
                   append#1(nil(),@l2) = [1 0] @l2 + [2]                         
                                         [0 1]       [2]                         
                                       > [1 0] @l2 + [0]                         
                                         [0 1]       [0]                         
                                       = @l2                                     
        
                          subtrees(@t) = [1 0] @t + [1]                          
                                         [0 2]      [0]                          
                                       > [1 0] @t + [0]                          
                                         [0 2]      [0]                          
                                       = subtrees#1(@t)                          
        
                    subtrees#1(leaf()) = [7]                                     
                                         [8]                                     
                                       > [2]                                     
                                         [2]                                     
                                       = nil()                                   
        
          subtrees#1(node(@x,@t1,@t2)) = [1 4] @t1 + [1 0] @t2 + [1 4] @x + [7]  
                                         [0 2]       [0 2]       [0 0]      [4]  
                                       > [1 4] @t1 + [1 0] @t2 + [1 4] @x + [6]  
                                         [0 2]       [0 2]       [0 0]      [4]  
                                       = subtrees#2(subtrees(@t1),@t1,@t2,@x)    
        
            subtrees#2(@l1,@t1,@t2,@x) = [1 2] @l1 + [1 0] @t2 + [1 4] @x + [5]  
                                         [0 1]       [0 2]       [0 0]      [4]  
                                       > [1 1] @l1 + [1 0] @t2 + [0 1] @x + [4]  
                                         [0 1]       [0 2]       [0 0]      [4]  
                                       = subtrees#3(subtrees(@t2),@l1,@t1,@t2,@x)
        
        subtrees#3(@l2,@l1,@t1,@t2,@x) = [1 1] @l1 + [1 0] @l2 + [0 1] @x + [3]  
                                         [0 1]       [0 1]       [0 0]      [4]  
                                       > [0 1] @l1 + [1 0] @l2 + [2]             
                                         [0 1]       [0 1]       [4]             
                                       = ::(node(@x,@t1,@t2),append(@l1,@l2))    
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^2))