WORST_CASE(?,O(n^1))
* Step 1: Ara WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            cond_partition_pivot_heap_1(False(),x3,E(),x2,x1) -> Pair(E(),T(E(),x2,x1))
            cond_partition_pivot_heap_1(False(),x6,T(x5,x4,x3),x2,x1) -> cond_partition_pivot_heap_7(leqElem#2(x4,x6)
                                                                                                    ,x6
                                                                                                    ,x2
                                                                                                    ,x1
                                                                                                    ,x5
                                                                                                    ,x4
                                                                                                    ,x3)
            cond_partition_pivot_heap_1(True(),x3,x2,x1,E()) -> Pair(T(x2,x1,E()),E())
            cond_partition_pivot_heap_1(True(),x6,x5,x4,T(x3,x2,x1)) -> cond_partition_pivot_heap_3(leqElem#2(x2,x6)
                                                                                                   ,x6
                                                                                                   ,x5
                                                                                                   ,x4
                                                                                                   ,x3
                                                                                                   ,x2
                                                                                                   ,x1)
            cond_partition_pivot_heap_3(False(),x6,x5,x4,x3,x2,x1) -> cond_partition_pivot_heap_5(partition#2(x6,x3)
                                                                                                 ,x5
                                                                                                 ,x4
                                                                                                 ,x2
                                                                                                 ,x1)
            cond_partition_pivot_heap_3(True(),x6,x5,x4,x3,x2,x1) -> cond_partition_pivot_heap_4(partition#2(x6,x1)
                                                                                                ,x5
                                                                                                ,x4
                                                                                                ,x3
                                                                                                ,x2)
            cond_partition_pivot_heap_4(Pair(x12,x13),x6,x7,x9,x10) -> Pair(T(T(x6,x7,x9),x10,x12),x13)
            cond_partition_pivot_heap_5(Pair(x12,x13),x6,x7,x10,x11) -> Pair(T(x6,x7,x12),T(x13,x10,x11))
            cond_partition_pivot_heap_7(False(),x6,x5,x4,x3,x2,x1) -> cond_partition_pivot_heap_9(partition#2(x6,x3)
                                                                                                 ,x5
                                                                                                 ,x4
                                                                                                 ,x2
                                                                                                 ,x1)
            cond_partition_pivot_heap_7(True(),x6,x5,x4,x3,x2,x1) -> cond_partition_pivot_heap_8(partition#2(x6,x1)
                                                                                                ,x5
                                                                                                ,x4
                                                                                                ,x3
                                                                                                ,x2)
            cond_partition_pivot_heap_8(Pair(x12,x13),x7,x8,x9,x10) -> Pair(T(x9,x10,x12),T(x13,x7,x8))
            cond_partition_pivot_heap_9(Pair(x12,x13),x7,x8,x10,x11) -> Pair(x12,T(x13,x10,T(x11,x7,x8)))
            leq#2(0(),x12) -> True()
            leq#2(S(x16),0()) -> False()
            leq#2(S(x4),S(x2)) -> leq#2(x4,x2)
            leqElem#2(Elem(x4),Elem(x2)) -> leq#2(x4,x2)
            main(x2,x1) -> partition#2(x1,x2)
            partition#2(x2,E()) -> Pair(E(),E())
            partition#2(x8,T(x6,x4,x2)) -> cond_partition_pivot_heap_1(leqElem#2(x4,x8),x8,x6,x4,x2)
        - Signature:
            {cond_partition_pivot_heap_1/5,cond_partition_pivot_heap_3/7,cond_partition_pivot_heap_4/5
            ,cond_partition_pivot_heap_5/5,cond_partition_pivot_heap_7/7,cond_partition_pivot_heap_8/5
            ,cond_partition_pivot_heap_9/5,leq#2/2,leqElem#2/2,main/2,partition#2/2} / {0/0,E/0,Elem/1,False/0,Pair/2
            ,S/1,T/3,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {cond_partition_pivot_heap_1,cond_partition_pivot_heap_3
            ,cond_partition_pivot_heap_4,cond_partition_pivot_heap_5,cond_partition_pivot_heap_7
            ,cond_partition_pivot_heap_8,cond_partition_pivot_heap_9,leq#2,leqElem#2,main
            ,partition#2} and constructors {0,E,Elem,False,Pair,S,T,True}
    + Applied Processor:
        Ara {minDegree = 1, maxDegree = 2, araTimeout = 5, araRuleShifting = Nothing}
    + Details:
        Signatures used:
        ----------------
          F (TrsFun "0") :: [] -(0)-> "A"(1)
          F (TrsFun "0") :: [] -(0)-> "A"(0)
          F (TrsFun "E") :: [] -(0)-> "A"(11)
          F (TrsFun "E") :: [] -(0)-> "A"(15)
          F (TrsFun "Elem") :: ["A"(1)] -(1)-> "A"(1)
          F (TrsFun "Elem") :: ["A"(0)] -(0)-> "A"(0)
          F (TrsFun "False") :: [] -(0)-> "A"(0)
          F (TrsFun "False") :: [] -(0)-> "A"(5)
          F (TrsFun "False") :: [] -(0)-> "A"(15)
          F (TrsFun "Pair") :: ["A"(0) x "A"(0)] -(4)-> "A"(4)
          F (TrsFun "Pair") :: ["A"(0) x "A"(0)] -(3)-> "A"(3)
          F (TrsFun "Pair") :: ["A"(0) x "A"(0)] -(6)-> "A"(6)
          F (TrsFun "S") :: ["A"(1)] -(1)-> "A"(1)
          F (TrsFun "S") :: ["A"(0)] -(0)-> "A"(0)
          F (TrsFun "T") :: ["A"(11) x "A"(11) x "A"(11)] -(11)-> "A"(11)
          F (TrsFun "T") :: ["A"(0) x "A"(0) x "A"(0)] -(0)-> "A"(0)
          F (TrsFun "True") :: [] -(0)-> "A"(0)
          F (TrsFun "True") :: [] -(0)-> "A"(5)
          F (TrsFun "True") :: [] -(0)-> "A"(15)
          F (TrsFun "cond_partition_pivot_heap_1") :: ["A"(0) x "A"(10) x "A"(11) x "A"(4) x "A"(11)] -(13)-> "A"(4)
          F (TrsFun "cond_partition_pivot_heap_3") :: ["A"(5) x "A"(10) x "A"(0) x "A"(0) x "A"(11) x "A"(0) x "A"(11)] -(15)-> "A"(4)
          F (TrsFun "cond_partition_pivot_heap_4") :: ["A"(4) x "A"(0) x "A"(0) x "A"(1) x "A"(0)] -(5)-> "A"(6)
          F (TrsFun "cond_partition_pivot_heap_5") :: ["A"(4) x "A"(0) x "A"(0) x "A"(0) x "A"(1)] -(1)-> "A"(4)
          F (TrsFun "cond_partition_pivot_heap_7") :: ["A"(5) x "A"(10) x "A"(0) x "A"(0) x "A"(11) x "A"(2) x "A"(11)] -(12)-> "A"(4)
          F (TrsFun "cond_partition_pivot_heap_8") :: ["A"(4) x "A"(0) x "A"(0) x "A"(1) x "A"(1)] -(1)-> "A"(4)
          F (TrsFun "cond_partition_pivot_heap_9") :: ["A"(3) x "A"(0) x "A"(0) x "A"(2) x "A"(1)] -(2)-> "A"(4)
          F (TrsFun "leq#2") :: ["A"(1) x "A"(0)] -(1)-> "A"(14)
          F (TrsFun "leqElem#2") :: ["A"(1) x "A"(0)] -(1)-> "A"(13)
          F (TrsFun "main") :: ["A"(13) x "A"(12)] -(15)-> "A"(2)
          F (TrsFun "partition#2") :: ["A"(10) x "A"(11)] -(8)-> "A"(4)
        
        
        Cost-free Signatures used:
        --------------------------
        
        
        
        Base Constructor Signatures used:
        ---------------------------------
          "F (TrsFun \"0\")_A" :: [] -(0)-> "A"(1)
          "F (TrsFun \"E\")_A" :: [] -(0)-> "A"(1)
          "F (TrsFun \"Elem\")_A" :: ["A"(1)] -(1)-> "A"(1)
          "F (TrsFun \"False\")_A" :: [] -(0)-> "A"(1)
          "F (TrsFun \"Pair\")_A" :: ["A"(0) x "A"(0)] -(1)-> "A"(1)
          "F (TrsFun \"S\")_A" :: ["A"(1)] -(1)-> "A"(1)
          "F (TrsFun \"T\")_A" :: ["A"(1) x "A"(1) x "A"(1)] -(1)-> "A"(1)
          "F (TrsFun \"True\")_A" :: [] -(0)-> "A"(1)
        

WORST_CASE(?,O(n^1))