WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            foldr#3(Cons(x16,x6)) -> step_x_f(rev_l(),x16,foldr#3(x6))
            foldr#3(Nil()) -> fleft_op_e_xs_1()
            main(Cons(x8,x9)) -> step_x_f#1(rev_l(),x8,foldr#3(x9),Nil())
            main(Nil()) -> Nil()
            rev_l#2(x8,x10) -> Cons(x10,x8)
            step_x_f#1(rev_l(),x5,fleft_op_e_xs_1(),x3) -> rev_l#2(x3,x5)
            step_x_f#1(rev_l(),x5,step_x_f(x2,x3,x4),x1) -> step_x_f#1(x2,x3,x4,rev_l#2(x1,x5))
        - Signature:
            {foldr#3/1,main/1,rev_l#2/2,step_x_f#1/4} / {Cons/2,Nil/0,fleft_op_e_xs_1/0,rev_l/0,step_x_f/3}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {foldr#3,main,rev_l#2,step_x_f#1} and constructors {Cons
            ,Nil,fleft_op_e_xs_1,rev_l,step_x_f}
    + 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:
          uargs(step_x_f) = {3},
          uargs(step_x_f#1) = {3,4}
        
        Following symbols are considered usable:
          {foldr#3,main,rev_l#2,step_x_f#1}
        TcT has computed the following interpretation:
                     p(Cons) = 2 + x2     
                      p(Nil) = 4          
          p(fleft_op_e_xs_1) = 8          
                  p(foldr#3) = 4*x1       
                     p(main) = 7 + 4*x1   
                    p(rev_l) = 1          
                  p(rev_l#2) = 3 + x1     
                 p(step_x_f) = 4 + x1 + x3
               p(step_x_f#1) = x3 + x4    
        
        Following rules are strictly oriented:
                               foldr#3(Cons(x16,x6)) = 8 + 4*x6                                
                                                     > 5 + 4*x6                                
                                                     = step_x_f(rev_l(),x16,foldr#3(x6))       
        
                                      foldr#3(Nil()) = 16                                      
                                                     > 8                                       
                                                     = fleft_op_e_xs_1()                       
        
                                   main(Cons(x8,x9)) = 15 + 4*x9                               
                                                     > 4 + 4*x9                                
                                                     = step_x_f#1(rev_l(),x8,foldr#3(x9),Nil())
        
                                         main(Nil()) = 23                                      
                                                     > 4                                       
                                                     = Nil()                                   
        
                                     rev_l#2(x8,x10) = 3 + x8                                  
                                                     > 2 + x8                                  
                                                     = Cons(x10,x8)                            
        
         step_x_f#1(rev_l(),x5,fleft_op_e_xs_1(),x3) = 8 + x3                                  
                                                     > 3 + x3                                  
                                                     = rev_l#2(x3,x5)                          
        
        step_x_f#1(rev_l(),x5,step_x_f(x2,x3,x4),x1) = 4 + x1 + x2 + x4                        
                                                     > 3 + x1 + x4                             
                                                     = step_x_f#1(x2,x3,x4,rev_l#2(x1,x5))     
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))