WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            app(cons(X),YS) -> cons(X)
            app(nil(),YS) -> YS
            from(X) -> cons(X)
            prefix(L) -> cons(nil())
            zWadr(XS,nil()) -> nil()
            zWadr(cons(X),cons(Y)) -> cons(app(Y,cons(X)))
            zWadr(nil(),YS) -> nil()
        - Signature:
            {app/2,from/1,prefix/1,zWadr/2} / {cons/1,nil/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {app,from,prefix,zWadr} and constructors {cons,nil}
    + Applied Processor:
        NaturalPI {shape = StronglyLinear, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(stronglyLinear):
        The following argument positions are considered usable:
          uargs(cons) = {1}
        
        Following symbols are considered usable:
          {app,from,prefix,zWadr}
        TcT has computed the following interpretation:
             p(app) = 4 + x1 + x2
            p(cons) = x1         
            p(from) = 5 + x1     
             p(nil) = 0          
          p(prefix) = 10 + x1    
           p(zWadr) = 9 + x1 + x2
        
        Following rules are strictly oriented:
               app(cons(X),YS) = 4 + X + YS          
                               > X                   
                               = cons(X)             
        
                 app(nil(),YS) = 4 + YS              
                               > YS                  
                               = YS                  
        
                       from(X) = 5 + X               
                               > X                   
                               = cons(X)             
        
                     prefix(L) = 10 + L              
                               > 0                   
                               = cons(nil())         
        
               zWadr(XS,nil()) = 9 + XS              
                               > 0                   
                               = nil()               
        
        zWadr(cons(X),cons(Y)) = 9 + X + Y           
                               > 4 + X + Y           
                               = cons(app(Y,cons(X)))
        
               zWadr(nil(),YS) = 9 + YS              
                               > 0                   
                               = nil()               
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))