WORST_CASE(?,O(n^2))
* Step 1: NaturalMI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            div(0(),s(Y)) -> 0()
            div(s(X),s(Y)) -> if(geq(X,Y),s(div(minus(X,Y),s(Y))),0())
            geq(X,0()) -> true()
            geq(0(),s(Y)) -> false()
            geq(s(X),s(Y)) -> geq(X,Y)
            if(false(),X,Y) -> Y
            if(true(),X,Y) -> X
            minus(0(),Y) -> 0()
            minus(s(X),s(Y)) -> minus(X,Y)
        - Signature:
            {div/2,geq/2,if/3,minus/2} / {0/0,false/0,s/1,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {div,geq,if,minus} and constructors {0,false,s,true}
    + Applied Processor:
        NaturalMI {miDimension = 2, miDegree = 2, 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(div) = {1},
          uargs(if) = {1,2},
          uargs(s) = {1}
        
        Following symbols are considered usable:
          {div,geq,if,minus}
        TcT has computed the following interpretation:
              p(0) = [0]                                 
                     [0]                                 
            p(div) = [2 7] x1 + [1]                      
                     [0 4]      [0]                      
          p(false) = [1]                                 
                     [0]                                 
            p(geq) = [0 2] x1 + [2]                      
                     [1 0]      [0]                      
             p(if) = [1 2] x1 + [4 0] x2 + [2 1] x3 + [0]
                     [0 0]      [0 4]      [0 1]      [0]
          p(minus) = [0 1] x1 + [1]                      
                     [0 0]      [0]                      
              p(s) = [1 2] x1 + [0]                      
                     [0 1]      [2]                      
           p(true) = [1]                                 
                     [0]                                 
        
        Following rules are strictly oriented:
           div(0(),s(Y)) = [1]                                     
                           [0]                                     
                         > [0]                                     
                           [0]                                     
                         = 0()                                     
        
          div(s(X),s(Y)) = [2 11] X + [15]                         
                           [0  4]     [8]                          
                         > [2 10] X + [14]                         
                           [0  0]     [8]                          
                         = if(geq(X,Y),s(div(minus(X,Y),s(Y))),0())
        
              geq(X,0()) = [0 2] X + [2]                           
                           [1 0]     [0]                           
                         > [1]                                     
                           [0]                                     
                         = true()                                  
        
           geq(0(),s(Y)) = [2]                                     
                           [0]                                     
                         > [1]                                     
                           [0]                                     
                         = false()                                 
        
          geq(s(X),s(Y)) = [0 2] X + [6]                           
                           [1 2]     [0]                           
                         > [0 2] X + [2]                           
                           [1 0]     [0]                           
                         = geq(X,Y)                                
        
         if(false(),X,Y) = [4 0] X + [2 1] Y + [1]                 
                           [0 4]     [0 1]     [0]                 
                         > [1 0] Y + [0]                           
                           [0 1]     [0]                           
                         = Y                                       
        
          if(true(),X,Y) = [4 0] X + [2 1] Y + [1]                 
                           [0 4]     [0 1]     [0]                 
                         > [1 0] X + [0]                           
                           [0 1]     [0]                           
                         = X                                       
        
            minus(0(),Y) = [1]                                     
                           [0]                                     
                         > [0]                                     
                           [0]                                     
                         = 0()                                     
        
        minus(s(X),s(Y)) = [0 1] X + [3]                           
                           [0 0]     [0]                           
                         > [0 1] X + [1]                           
                           [0 0]     [0]                           
                         = minus(X,Y)                              
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^2))