WORST_CASE(?,O(n^1))
* Step 1: NaturalMI 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:
        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(cons) = {1}
        
        Following symbols are considered usable:
          {app,from,prefix,zWadr}
        TcT has computed the following interpretation:
             p(app) = [4] x1 + [4] x2 + [4]
            p(cons) = [1] x1 + [0]         
            p(from) = [2] x1 + [1]         
             p(nil) = [3]                  
          p(prefix) = [15]                 
           p(zWadr) = [8] x1 + [7] x2 + [6]
        
        Following rules are strictly oriented:
               app(cons(X),YS) = [4] X + [4] YS + [4]
                               > [1] X + [0]         
                               = cons(X)             
        
                 app(nil(),YS) = [4] YS + [16]       
                               > [1] YS + [0]        
                               = YS                  
        
                       from(X) = [2] X + [1]         
                               > [1] X + [0]         
                               = cons(X)             
        
                     prefix(L) = [15]                
                               > [3]                 
                               = cons(nil())         
        
               zWadr(XS,nil()) = [8] XS + [27]       
                               > [3]                 
                               = nil()               
        
        zWadr(cons(X),cons(Y)) = [8] X + [7] Y + [6] 
                               > [4] X + [4] Y + [4] 
                               = cons(app(Y,cons(X)))
        
               zWadr(nil(),YS) = [7] YS + [30]       
                               > [3]                 
                               = nil()               
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))