WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + 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
            appendAll(@l) -> appendAll#1(@l)
            appendAll#1(::(@l1,@ls)) -> append(@l1,appendAll(@ls))
            appendAll#1(nil()) -> nil()
            appendAll2(@l) -> appendAll2#1(@l)
            appendAll2#1(::(@l1,@ls)) -> append(appendAll(@l1),appendAll2(@ls))
            appendAll2#1(nil()) -> nil()
            appendAll3(@l) -> appendAll3#1(@l)
            appendAll3#1(::(@l1,@ls)) -> append(appendAll2(@l1),appendAll3(@ls))
            appendAll3#1(nil()) -> nil()
        - Signature:
            {append/2,append#1/2,appendAll/1,appendAll#1/1,appendAll2/1,appendAll2#1/1,appendAll3/1
            ,appendAll3#1/1} / {::/2,nil/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {append,append#1,appendAll,appendAll#1,appendAll2
            ,appendAll2#1,appendAll3,appendAll3#1} and constructors {::,nil}
    + 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(::) = {2},
          uargs(append) = {1,2}
        
        Following symbols are considered usable:
          {append,append#1,appendAll,appendAll#1,appendAll2,appendAll2#1,appendAll3,appendAll3#1}
        TcT has computed the following interpretation:
                    p(::) = [1] x1 + [1] x2 + [2]
                p(append) = [2] x1 + [1] x2 + [1]
              p(append#1) = [2] x1 + [1] x2 + [0]
             p(appendAll) = [2] x1 + [2]         
           p(appendAll#1) = [2] x1 + [0]         
            p(appendAll2) = [4] x1 + [2]         
          p(appendAll2#1) = [4] x1 + [0]         
            p(appendAll3) = [8] x1 + [8]         
          p(appendAll3#1) = [8] x1 + [4]         
                   p(nil) = [2]                  
        
        Following rules are strictly oriented:
                  append(@l1,@l2) = [2] @l1 + [1] @l2 + [1]                
                                  > [2] @l1 + [1] @l2 + [0]                
                                  = append#1(@l1,@l2)                      
        
         append#1(::(@x,@xs),@l2) = [1] @l2 + [2] @x + [2] @xs + [4]       
                                  > [1] @l2 + [1] @x + [2] @xs + [3]       
                                  = ::(@x,append(@xs,@l2))                 
        
              append#1(nil(),@l2) = [1] @l2 + [4]                          
                                  > [1] @l2 + [0]                          
                                  = @l2                                    
        
                    appendAll(@l) = [2] @l + [2]                           
                                  > [2] @l + [0]                           
                                  = appendAll#1(@l)                        
        
         appendAll#1(::(@l1,@ls)) = [2] @l1 + [2] @ls + [4]                
                                  > [2] @l1 + [2] @ls + [3]                
                                  = append(@l1,appendAll(@ls))             
        
               appendAll#1(nil()) = [4]                                    
                                  > [2]                                    
                                  = nil()                                  
        
                   appendAll2(@l) = [4] @l + [2]                           
                                  > [4] @l + [0]                           
                                  = appendAll2#1(@l)                       
        
        appendAll2#1(::(@l1,@ls)) = [4] @l1 + [4] @ls + [8]                
                                  > [4] @l1 + [4] @ls + [7]                
                                  = append(appendAll(@l1),appendAll2(@ls)) 
        
              appendAll2#1(nil()) = [8]                                    
                                  > [2]                                    
                                  = nil()                                  
        
                   appendAll3(@l) = [8] @l + [8]                           
                                  > [8] @l + [4]                           
                                  = appendAll3#1(@l)                       
        
        appendAll3#1(::(@l1,@ls)) = [8] @l1 + [8] @ls + [20]               
                                  > [8] @l1 + [8] @ls + [13]               
                                  = append(appendAll2(@l1),appendAll3(@ls))
        
              appendAll3#1(nil()) = [20]                                   
                                  > [2]                                    
                                  = nil()                                  
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))