WORST_CASE(?,O(n^2))
* Step 1: MI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            bits(0()) -> 0()
            bits(s(x)) -> s(bits(half(s(x))))
            half(0()) -> 0()
            half(s(0())) -> 0()
            half(s(s(x))) -> s(half(x))
        - Signature:
            {bits/1,half/1} / {0/0,s/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {bits,half} and constructors {0,s}
    + Applied Processor:
        MI {miKind = Automaton Nothing, miDimension = 2, miUArgs = NoUArgs, miURules = NoURules, miSelector = Nothing}
    + Details:
        We apply a matrix interpretation of kind Automaton Nothing:
        
        
        Following symbols are considered usable:
          all
        TcT has computed the following interpretation:
             p(0) = [7]            
                    [2]            
          p(bits) = [1 4] x_1 + [0]
                    [1 4]       [0]
          p(half) = [1 0] x_1 + [1]
                    [1 0]       [0]
             p(s) = [1 0] x_1 + [2]
                    [1 0]       [3]
        
        Following rules are strictly oriented:
            bits(0()) = [15]               
                        [15]               
                      > [7]                
                        [2]                
                      = 0()                
        
           bits(s(x)) = [5 0] x + [14]     
                        [5 0]     [14]     
                      > [5 0] x + [13]     
                        [5 0]     [14]     
                      = s(bits(half(s(x))))
        
            half(0()) = [8]                
                        [7]                
                      > [7]                
                        [2]                
                      = 0()                
        
         half(s(0())) = [10]               
                        [9]                
                      > [7]                
                        [2]                
                      = 0()                
        
        half(s(s(x))) = [1 0] x + [5]      
                        [1 0]     [4]      
                      > [1 0] x + [3]      
                        [1 0]     [4]      
                      = s(half(x))         
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^2))