WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            fold#3(Cons(x4,x2)) -> plus#2(x4,fold#3(x2))
            fold#3(Nil()) -> 0()
            main(x1) -> fold#3(x1)
            plus#2(0(),x12) -> x12
            plus#2(S(x4),x2) -> S(plus#2(x4,x2))
        - Signature:
            {fold#3/1,main/1,plus#2/2} / {0/0,Cons/2,Nil/0,S/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {fold#3,main,plus#2} and constructors {0,Cons,Nil,S}
    + 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(S) = {1},
          uargs(plus#2) = {2}
        
        Following symbols are considered usable:
          {fold#3,main,plus#2}
        TcT has computed the following interpretation:
               p(0) = [4]                  
            p(Cons) = [1] x1 + [1] x2 + [1]
             p(Nil) = [3]                  
               p(S) = [1] x1 + [1]         
          p(fold#3) = [8] x1 + [0]         
            p(main) = [8] x1 + [3]         
          p(plus#2) = [2] x1 + [1] x2 + [0]
        
        Following rules are strictly oriented:
        fold#3(Cons(x4,x2)) = [8] x2 + [8] x4 + [8]
                            > [8] x2 + [2] x4 + [0]
                            = plus#2(x4,fold#3(x2))
        
              fold#3(Nil()) = [24]                 
                            > [4]                  
                            = 0()                  
        
                   main(x1) = [8] x1 + [3]         
                            > [8] x1 + [0]         
                            = fold#3(x1)           
        
            plus#2(0(),x12) = [1] x12 + [8]        
                            > [1] x12 + [0]        
                            = x12                  
        
           plus#2(S(x4),x2) = [1] x2 + [2] x4 + [2]
                            > [1] x2 + [2] x4 + [1]
                            = S(plus#2(x4,x2))     
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))