WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            flip#1(E()) -> E()
            flip#1(O(x4)) -> Z(flip#1(x4))
            flip#1(Z(x4)) -> O(flip#1(x4))
            main(x0) -> flip#1(x0)
        - Signature:
            {flip#1/1,main/1} / {E/0,O/1,Z/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {flip#1,main} and constructors {E,O,Z}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(O) = {1},
          uargs(Z) = {1}
        
        Following symbols are considered usable:
          {flip#1,main}
        TcT has computed the following interpretation:
               p(E) = 2        
               p(O) = x1       
               p(Z) = x1       
          p(flip#1) = 10 + 3*x1
            p(main) = 10 + 3*x1
        
        Following rules are strictly oriented:
        flip#1(E()) = 16 
                    > 2  
                    = E()
        
        
        Following rules are (at-least) weakly oriented:
        flip#1(O(x4)) =  10 + 3*x4    
                      >= 10 + 3*x4    
                      =  Z(flip#1(x4))
        
        flip#1(Z(x4)) =  10 + 3*x4    
                      >= 10 + 3*x4    
                      =  O(flip#1(x4))
        
             main(x0) =  10 + 3*x0    
                      >= 10 + 3*x0    
                      =  flip#1(x0)   
        
* Step 2: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            flip#1(O(x4)) -> Z(flip#1(x4))
            flip#1(Z(x4)) -> O(flip#1(x4))
            main(x0) -> flip#1(x0)
        - Weak TRS:
            flip#1(E()) -> E()
        - Signature:
            {flip#1/1,main/1} / {E/0,O/1,Z/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {flip#1,main} and constructors {E,O,Z}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(O) = {1},
          uargs(Z) = {1}
        
        Following symbols are considered usable:
          {flip#1,main}
        TcT has computed the following interpretation:
               p(E) = 0        
               p(O) = 2 + x1   
               p(Z) = 2 + x1   
          p(flip#1) = 8 + 8*x1 
            p(main) = 11 + 9*x1
        
        Following rules are strictly oriented:
        flip#1(O(x4)) = 24 + 8*x4    
                      > 10 + 8*x4    
                      = Z(flip#1(x4))
        
        flip#1(Z(x4)) = 24 + 8*x4    
                      > 10 + 8*x4    
                      = O(flip#1(x4))
        
             main(x0) = 11 + 9*x0    
                      > 8 + 8*x0     
                      = flip#1(x0)   
        
        
        Following rules are (at-least) weakly oriented:
        flip#1(E()) =  8  
                    >= 0  
                    =  E()
        
* Step 3: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            flip#1(E()) -> E()
            flip#1(O(x4)) -> Z(flip#1(x4))
            flip#1(Z(x4)) -> O(flip#1(x4))
            main(x0) -> flip#1(x0)
        - Signature:
            {flip#1/1,main/1} / {E/0,O/1,Z/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {flip#1,main} and constructors {E,O,Z}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^1))