WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            evenodd(x,0()) -> not(evenodd(x,s(0())))
            evenodd(0(),s(0())) -> false()
            evenodd(s(x),s(0())) -> evenodd(x,0())
            not(false()) -> true()
            not(true()) -> false()
        - Signature:
            {evenodd/2,not/1} / {0/0,false/0,s/1,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {evenodd,not} and constructors {0,false,s,true}
    + Applied Processor:
        NaturalMI {miDimension = 2, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation (containing no more than 1 non-zero interpretation-entries in the diagonal of the component-wise maxima):
        The following argument positions are considered usable:
          uargs(not) = {1}
        
        Following symbols are considered usable:
          {evenodd,not}
        TcT has computed the following interpretation:
                p(0) = [4]                      
                       [8]                      
          p(evenodd) = [1 2] x1 + [0 2] x2 + [0]
                       [0 0]      [0 0]      [4]
            p(false) = [4]                      
                       [4]                      
              p(not) = [1 0] x1 + [2]           
                       [0 1]      [0]           
                p(s) = [1 2] x1 + [8]           
                       [0 0]      [4]           
             p(true) = [3]                      
                       [4]                      
        
        Following rules are strictly oriented:
              evenodd(x,0()) = [1 2] x + [16]        
                               [0 0]     [4]         
                             > [1 2] x + [10]        
                               [0 0]     [4]         
                             = not(evenodd(x,s(0())))
        
         evenodd(0(),s(0())) = [28]                  
                               [4]                   
                             > [4]                   
                               [4]                   
                             = false()               
        
        evenodd(s(x),s(0())) = [1 2] x + [24]        
                               [0 0]     [4]         
                             > [1 2] x + [16]        
                               [0 0]     [4]         
                             = evenodd(x,0())        
        
                not(false()) = [6]                   
                               [4]                   
                             > [3]                   
                               [4]                   
                             = true()                
        
                 not(true()) = [5]                   
                               [4]                   
                             > [4]                   
                               [4]                   
                             = false()               
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))