WORST_CASE(?,O(n^1))
* Step 1: NaturalPI 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:
        NaturalPI {shape = Linear, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        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      
              p(Nil) = 2           
          p(foldl#3) = 4*x1 + 12*x2
             p(main) = 12 + 15*x1  
        
        Following rules are strictly oriented:
        foldl#3(x16,Cons(x24,x6)) = 12 + 4*x16 + 12*x6       
                                  > 4 + 4*x16 + 12*x6        
                                  = foldl#3(Cons(x24,x16),x6)
        
                foldl#3(x2,Nil()) = 24 + 4*x2                
                                  > x2                       
                                  = x2                       
        
                         main(x1) = 12 + 15*x1               
                                  > 8 + 12*x1                
                                  = foldl#3(Nil(),x1)        
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))