WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            f(a,cons(x,k)) -> f(cons(x,a),k)
            f(a,empty()) -> g(a,empty())
            g(cons(x,k),d) -> g(k,cons(x,d))
            g(empty(),d) -> d
        - Signature:
            {f/2,g/2} / {cons/2,empty/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {f,g} and constructors {cons,empty}
    + 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:
          {f,g}
        TcT has computed the following interpretation:
           p(cons) = 1 + x2          
          p(empty) = 1               
              p(f) = 8 + 8*x1 + 12*x2
              p(g) = 11 + 8*x1 + x2  
        
        Following rules are strictly oriented:
        f(a,cons(x,k)) = 20 + 8*a + 12*k
                       > 16 + 8*a + 12*k
                       = f(cons(x,a),k) 
        
          f(a,empty()) = 20 + 8*a       
                       > 12 + 8*a       
                       = g(a,empty())   
        
        g(cons(x,k),d) = 19 + d + 8*k   
                       > 12 + d + 8*k   
                       = g(k,cons(x,d)) 
        
          g(empty(),d) = 19 + d         
                       > d              
                       = d              
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))