WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            @(Cons(x,xs),ys) -> Cons(x,@(xs,ys))
            @(Nil(),ys) -> ys
            equal(Capture(),Capture()) -> True()
            equal(Capture(),Swap()) -> False()
            equal(Swap(),Capture()) -> False()
            equal(Swap(),Swap()) -> True()
            game(p1,p2,Cons(Swap(),xs)) -> game(p2,p1,xs)
            game(p1,p2,Nil()) -> @(p1,p2)
            game(p1,Cons(x',xs'),Cons(Capture(),xs)) -> game(Cons(x',p1),xs',xs)
            goal(p1,p2,moves) -> game(p1,p2,moves)
        - Signature:
            {@/2,equal/2,game/3,goal/3} / {Capture/0,Cons/2,False/0,Nil/0,Swap/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {@,equal,game,goal} and constructors {Capture,Cons,False
            ,Nil,Swap,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:
          uargs(Cons) = {2}
        
        Following symbols are considered usable:
          {@,equal,game,goal}
        TcT has computed the following interpretation:
                p(@) = [8] x1 + [1] x2 + [1]         
          p(Capture) = [2]                           
             p(Cons) = [1] x2 + [2]                  
            p(False) = [4]                           
              p(Nil) = [3]                           
             p(Swap) = [4]                           
             p(True) = [8]                           
            p(equal) = [1] x1 + [2] x2 + [4]         
             p(game) = [8] x1 + [8] x2 + [4] x3 + [5]
             p(goal) = [8] x1 + [8] x2 + [4] x3 + [9]
        
        Following rules are strictly oriented:
                                @(Cons(x,xs),ys) = [8] xs + [1] ys + [17]           
                                                 > [8] xs + [1] ys + [3]            
                                                 = Cons(x,@(xs,ys))                 
        
                                     @(Nil(),ys) = [1] ys + [25]                    
                                                 > [1] ys + [0]                     
                                                 = ys                               
        
                      equal(Capture(),Capture()) = [10]                             
                                                 > [8]                              
                                                 = True()                           
        
                         equal(Capture(),Swap()) = [14]                             
                                                 > [4]                              
                                                 = False()                          
        
                         equal(Swap(),Capture()) = [12]                             
                                                 > [4]                              
                                                 = False()                          
        
                            equal(Swap(),Swap()) = [16]                             
                                                 > [8]                              
                                                 = True()                           
        
                     game(p1,p2,Cons(Swap(),xs)) = [8] p1 + [8] p2 + [4] xs + [13]  
                                                 > [8] p1 + [8] p2 + [4] xs + [5]   
                                                 = game(p2,p1,xs)                   
        
                               game(p1,p2,Nil()) = [8] p1 + [8] p2 + [17]           
                                                 > [8] p1 + [1] p2 + [1]            
                                                 = @(p1,p2)                         
        
        game(p1,Cons(x',xs'),Cons(Capture(),xs)) = [8] p1 + [4] xs + [8] xs' + [29] 
                                                 > [8] p1 + [4] xs + [8] xs' + [21] 
                                                 = game(Cons(x',p1),xs',xs)         
        
                               goal(p1,p2,moves) = [4] moves + [8] p1 + [8] p2 + [9]
                                                 > [4] moves + [8] p1 + [8] p2 + [5]
                                                 = game(p1,p2,moves)                
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))