WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            goal(xs,ys) -> revapp(xs,ys)
            revapp(Cons(x,xs),rest) -> revapp(xs,Cons(x,rest))
            revapp(Nil(),rest) -> rest
        - Signature:
            {goal/2,revapp/2} / {Cons/2,Nil/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {goal,revapp} 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:
          {goal,revapp}
        TcT has computed the following interpretation:
            p(Cons) = 5 + x2          
             p(Nil) = 2               
            p(goal) = 13 + 8*x1 + 3*x2
          p(revapp) = 6*x1 + 2*x2     
        
        Following rules are strictly oriented:
                    goal(xs,ys) = 13 + 8*xs + 3*ys       
                                > 6*xs + 2*ys            
                                = revapp(xs,ys)          
        
        revapp(Cons(x,xs),rest) = 30 + 2*rest + 6*xs     
                                > 10 + 2*rest + 6*xs     
                                = revapp(xs,Cons(x,rest))
        
             revapp(Nil(),rest) = 12 + 2*rest            
                                > rest                   
                                = rest                   
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))