WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6)
            foldl#3(x2,Nil()) -> x2
            main(x1) -> foldl#3(Nil(),x1)
        - Signature:
            {foldl#3/2,main/1} / {Cons/2,Nil/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,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:
          none
        
        Following symbols are considered usable:
          {foldl#3,main}
        TcT has computed the following interpretation:
             p(Cons) = [1] x2 + [1]          
              p(Nil) = [0]                   
          p(foldl#3) = [1] x1 + [2] x2 + [13]
             p(main) = [2] x1 + [14]         
        
        Following rules are strictly oriented:
        foldl#3(x16,Cons(x24,x6)) = [1] x16 + [2] x6 + [15]  
                                  > [1] x16 + [2] x6 + [14]  
                                  = foldl#3(Cons(x24,x16),x6)
        
                foldl#3(x2,Nil()) = [1] x2 + [13]            
                                  > [1] x2 + [0]             
                                  = x2                       
        
                         main(x1) = [2] x1 + [14]            
                                  > [2] x1 + [13]            
                                  = foldl#3(Nil(),x1)        
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))