WORST_CASE(?,O(n^1))
* Step 1: NaturalMI 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:
        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(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) = [1] x2 + [2]                  
                      p(Nil) = [0]                           
          p(fleft_op_e_xs_1) = [0]                           
                  p(foldr#3) = [9] x1 + [8]                  
                     p(main) = [12] x1 + [7]                 
                    p(rev_l) = [4]                           
                  p(rev_l#2) = [1] x1 + [3]                  
                 p(step_x_f) = [1] x1 + [1] x3 + [10]        
               p(step_x_f#1) = [1] x1 + [1] x3 + [1] x4 + [2]
        
        Following rules are strictly oriented:
                               foldr#3(Cons(x16,x6)) = [9] x6 + [26]                           
                                                     > [9] x6 + [22]                           
                                                     = step_x_f(rev_l(),x16,foldr#3(x6))       
        
                                      foldr#3(Nil()) = [8]                                     
                                                     > [0]                                     
                                                     = fleft_op_e_xs_1()                       
        
                                   main(Cons(x8,x9)) = [12] x9 + [31]                          
                                                     > [9] x9 + [14]                           
                                                     = step_x_f#1(rev_l(),x8,foldr#3(x9),Nil())
        
                                         main(Nil()) = [7]                                     
                                                     > [0]                                     
                                                     = Nil()                                   
        
                                     rev_l#2(x8,x10) = [1] x8 + [3]                            
                                                     > [1] x8 + [2]                            
                                                     = Cons(x10,x8)                            
        
         step_x_f#1(rev_l(),x5,fleft_op_e_xs_1(),x3) = [1] x3 + [6]                            
                                                     > [1] x3 + [3]                            
                                                     = rev_l#2(x3,x5)                          
        
        step_x_f#1(rev_l(),x5,step_x_f(x2,x3,x4),x1) = [1] x1 + [1] x2 + [1] x4 + [16]         
                                                     > [1] x1 + [1] x2 + [1] x4 + [5]          
                                                     = step_x_f#1(x2,x3,x4,rev_l#2(x1,x5))     
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))