WORST_CASE(?,O(n^2))
* Step 1: Ara WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            loop(Cons(x,xs),Nil(),pp,ss) -> False()
            loop(Cons(x',xs'),Cons(x,xs),pp,ss) -> loop[Ite](!EQ(x',x),Cons(x',xs'),Cons(x,xs),pp,ss)
            loop(Nil(),s,pp,ss) -> True()
            match1(p,s) -> loop(p,s,p,s)
        - Weak TRS:
            !EQ(0(),0()) -> True()
            !EQ(0(),S(y)) -> False()
            !EQ(S(x),0()) -> False()
            !EQ(S(x),S(y)) -> !EQ(x,y)
            loop[Ite](False(),p,s,pp,Cons(x,xs)) -> loop(pp,xs,pp,xs)
            loop[Ite](True(),Cons(x',xs'),Cons(x,xs),pp,ss) -> loop(xs',xs,pp,ss)
        - Signature:
            {!EQ/2,loop/4,loop[Ite]/5,match1/2} / {0/0,Cons/2,False/0,Nil/0,S/1,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {!EQ,loop,loop[Ite],match1} and constructors {0,Cons,False
            ,Nil,S,True}
    + Applied Processor:
        Ara {araHeuristics = NoHeuristics, minDegree = 1, maxDegree = 2, araTimeout = 5, araRuleShifting = Nothing}
    + Details:
        Signatures used:
        ----------------
          !EQ :: ["A"(0, 0) x "A"(0, 0)] -(0)-> "A"(14, 14)
          0 :: [] -(0)-> "A"(0, 0)
          Cons :: ["A"(0, 0) x "A"(0, 0)] -(0)-> "A"(0, 0)
          Cons :: ["A"(9, 0) x "A"(9, 0)] -(9)-> "A"(9, 0)
          Cons :: ["A"(0, 0) x "A"(13, 13)] -(13)-> "A"(0, 13)
          False :: [] -(0)-> "A"(7, 7)
          False :: [] -(0)-> "A"(15, 11)
          False :: [] -(0)-> "A"(15, 15)
          Nil :: [] -(0)-> "A"(9, 0)
          Nil :: [] -(0)-> "A"(0, 0)
          S :: ["A"(0, 0)] -(0)-> "A"(0, 0)
          True :: [] -(0)-> "A"(7, 7)
          True :: [] -(0)-> "A"(15, 11)
          True :: [] -(0)-> "A"(15, 15)
          loop :: ["A"(0, 0) x "A"(9, 0) x "A"(8, 8) x "A"(0, 13)] -(14)-> "A"(13, 5)
          loop[Ite] :: ["A"(7, 7) x "A"(0, 0) x "A"(9, 0) x "A"(8, 8) x "A"(0, 13)] -(5)-> "A"(13, 5)
          match1 :: ["A"(15, 15) x "A"(15, 14)] -(16)-> "A"(2, 2)
        
        
        Cost-free Signatures used:
        --------------------------
        
        
        
        Base Constructor Signatures used:
        ---------------------------------
          "0_A" :: [] -(0)-> "A"(1, 0)
          "0_A" :: [] -(0)-> "A"(0, 1)
          "Cons_A" :: ["A"(1, 0) x "A"(1, 0)] -(1)-> "A"(1, 0)
          "Cons_A" :: ["A"(0, 0) x "A"(1, 1)] -(1)-> "A"(0, 1)
          "False_A" :: [] -(0)-> "A"(1, 0)
          "False_A" :: [] -(0)-> "A"(0, 1)
          "Nil_A" :: [] -(0)-> "A"(1, 0)
          "Nil_A" :: [] -(0)-> "A"(0, 1)
          "S_A" :: ["A"(1, 0)] -(1)-> "A"(1, 0)
          "S_A" :: ["A"(1, 1)] -(1)-> "A"(0, 1)
          "True_A" :: [] -(0)-> "A"(1, 0)
          "True_A" :: [] -(0)-> "A"(0, 1)
        

WORST_CASE(?,O(n^2))