WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            even(Cons(x,xs)) -> odd(xs)
            even(Nil()) -> True()
            evenodd(x) -> even(x)
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
            odd(Cons(x,xs)) -> even(xs)
            odd(Nil()) -> False()
        - Signature:
            {even/1,evenodd/1,notEmpty/1,odd/1} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {even,evenodd,notEmpty,odd} and constructors {Cons,False
            ,Nil,True}
    + 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:
          none
        
        Following symbols are considered usable:
          {even,evenodd,notEmpty,odd}
        TcT has computed the following interpretation:
              p(Cons) = [1] x1 + [1] x2 + [1]
             p(False) = [2]                  
               p(Nil) = [6]                  
              p(True) = [4]                  
              p(even) = [1] x1 + [0]         
           p(evenodd) = [1] x1 + [8]         
          p(notEmpty) = [2] x1 + [9]         
               p(odd) = [1] x1 + [0]         
        
        Following rules are strictly oriented:
            even(Cons(x,xs)) = [1] x + [1] xs + [1] 
                             > [1] xs + [0]         
                             = odd(xs)              
        
                 even(Nil()) = [6]                  
                             > [4]                  
                             = True()               
        
                  evenodd(x) = [1] x + [8]          
                             > [1] x + [0]          
                             = even(x)              
        
        notEmpty(Cons(x,xs)) = [2] x + [2] xs + [11]
                             > [4]                  
                             = True()               
        
             notEmpty(Nil()) = [21]                 
                             > [2]                  
                             = False()              
        
             odd(Cons(x,xs)) = [1] x + [1] xs + [1] 
                             > [1] xs + [0]         
                             = even(xs)             
        
                  odd(Nil()) = [6]                  
                             > [2]                  
                             = False()              
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))