WORST_CASE(?,O(n^2))
* Step 1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            app_xss#1(Cons(x7,x12),x14) -> Cons(x7,app_xss#1(x12,x14))
            app_xss#1(Nil(),x8) -> x8
            main(x12,x3) -> map#2(app_xss(x12),x3)
            map#2(app_xss(x2),Nil()) -> Nil()
            map#2(app_xss(x6),Cons(x4,x2)) -> Cons(app_xss#1(x6,x4),map#2(app_xss(x6),x2))
        - Signature:
            {app_xss#1/2,main/2,map#2/2} / {Cons/2,Nil/0,app_xss/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {app_xss#1,main,map#2} and constructors {Cons,Nil,app_xss}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(Cons) = {1,2}
        
        Following symbols are considered usable:
          {app_xss#1,main,map#2}
        TcT has computed the following interpretation:
               p(Cons) = 2 + x1 + x2                              
                p(Nil) = 0                                        
            p(app_xss) = x1                                       
          p(app_xss#1) = 2 + 5*x1 + x1*x2 + 4*x2                  
               p(main) = 5 + 5*x1 + 4*x1*x2 + 4*x1^2 + 2*x2 + x2^2
              p(map#2) = 1 + 5*x1 + 4*x1*x2 + 2*x1^2 + x2 + x2^2  
        
        Following rules are strictly oriented:
           app_xss#1(Cons(x7,x12),x14) = 12 + 5*x12 + x12*x14 + 6*x14 + x14*x7 + 5*x7                                
                                       > 4 + 5*x12 + x12*x14 + 4*x14 + x7                                            
                                       = Cons(x7,app_xss#1(x12,x14))                                                 
        
                   app_xss#1(Nil(),x8) = 2 + 4*x8                                                                    
                                       > x8                                                                          
                                       = x8                                                                          
        
                          main(x12,x3) = 5 + 5*x12 + 4*x12*x3 + 4*x12^2 + 2*x3 + x3^2                                
                                       > 1 + 5*x12 + 4*x12*x3 + 2*x12^2 + x3 + x3^2                                  
                                       = map#2(app_xss(x12),x3)                                                      
        
              map#2(app_xss(x2),Nil()) = 1 + 5*x2 + 2*x2^2                                                           
                                       > 0                                                                           
                                       = Nil()                                                                       
        
        map#2(app_xss(x6),Cons(x4,x2)) = 7 + 5*x2 + 2*x2*x4 + 4*x2*x6 + x2^2 + 5*x4 + 4*x4*x6 + x4^2 + 13*x6 + 2*x6^2
                                       > 5 + x2 + 4*x2*x6 + x2^2 + 4*x4 + x4*x6 + 10*x6 + 2*x6^2                     
                                       = Cons(app_xss#1(x6,x4),map#2(app_xss(x6),x2))                                
        
        
        Following rules are (at-least) weakly oriented:
        
* Step 2: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            app_xss#1(Cons(x7,x12),x14) -> Cons(x7,app_xss#1(x12,x14))
            app_xss#1(Nil(),x8) -> x8
            main(x12,x3) -> map#2(app_xss(x12),x3)
            map#2(app_xss(x2),Nil()) -> Nil()
            map#2(app_xss(x6),Cons(x4,x2)) -> Cons(app_xss#1(x6,x4),map#2(app_xss(x6),x2))
        - Signature:
            {app_xss#1/2,main/2,map#2/2} / {Cons/2,Nil/0,app_xss/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {app_xss#1,main,map#2} and constructors {Cons,Nil,app_xss}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^2))