WORST_CASE(Omega(n^1),O(n^1))
* Step 1: Sum.  WORST_CASE(Omega(n^1),O(n^1))
    + Considered Problem:
        - Strict TRS:
            ++'(.(z0,z1),z2) -> c5(++'(z1,z2))
            ++'(nil(),z0) -> c4()
            IF(false(),z0,z1) -> c7()
            IF(true(),z0,z1) -> c6()
            MERGE(z0,nil()) -> c1()
            MERGE(.(z0,z1),.(z2,z3)) -> c2(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(z1,.(z2,z3)))
            MERGE(.(z0,z1),.(z2,z3)) -> c3(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(.(z0,z1),z3))
            MERGE(nil(),z0) -> c()
        - Weak TRS:
            ++(.(z0,z1),z2) -> .(z0,++(z1,z2))
            ++(nil(),z0) -> z0
            if(false(),z0,z1) -> z0
            if(true(),z0,z1) -> z0
            merge(z0,nil()) -> z0
            merge(.(z0,z1),.(z2,z3)) -> if(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
            merge(nil(),z0) -> z0
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2} / {./2,</2,c/0,c1/0,c2/2,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0
            ,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++,++',IF,MERGE,if,merge} and constructors {.,<,c,c1,c2
            ,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
** Step 1.a:1: Sum.  WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            ++'(.(z0,z1),z2) -> c5(++'(z1,z2))
            ++'(nil(),z0) -> c4()
            IF(false(),z0,z1) -> c7()
            IF(true(),z0,z1) -> c6()
            MERGE(z0,nil()) -> c1()
            MERGE(.(z0,z1),.(z2,z3)) -> c2(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(z1,.(z2,z3)))
            MERGE(.(z0,z1),.(z2,z3)) -> c3(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(.(z0,z1),z3))
            MERGE(nil(),z0) -> c()
        - Weak TRS:
            ++(.(z0,z1),z2) -> .(z0,++(z1,z2))
            ++(nil(),z0) -> z0
            if(false(),z0,z1) -> z0
            if(true(),z0,z1) -> z0
            merge(z0,nil()) -> z0
            merge(.(z0,z1),.(z2,z3)) -> if(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
            merge(nil(),z0) -> z0
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2} / {./2,</2,c/0,c1/0,c2/2,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0
            ,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++,++',IF,MERGE,if,merge} and constructors {.,<,c,c1,c2
            ,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
** Step 1.a:2: DecreasingLoops.  WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            ++'(.(z0,z1),z2) -> c5(++'(z1,z2))
            ++'(nil(),z0) -> c4()
            IF(false(),z0,z1) -> c7()
            IF(true(),z0,z1) -> c6()
            MERGE(z0,nil()) -> c1()
            MERGE(.(z0,z1),.(z2,z3)) -> c2(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(z1,.(z2,z3)))
            MERGE(.(z0,z1),.(z2,z3)) -> c3(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(.(z0,z1),z3))
            MERGE(nil(),z0) -> c()
        - Weak TRS:
            ++(.(z0,z1),z2) -> .(z0,++(z1,z2))
            ++(nil(),z0) -> z0
            if(false(),z0,z1) -> z0
            if(true(),z0,z1) -> z0
            merge(z0,nil()) -> z0
            merge(.(z0,z1),.(z2,z3)) -> if(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
            merge(nil(),z0) -> z0
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2} / {./2,</2,c/0,c1/0,c2/2,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0
            ,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++,++',IF,MERGE,if,merge} and constructors {.,<,c,c1,c2
            ,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        DecreasingLoops {bound = AnyLoop, narrow = 10}
    + Details:
        The system has following decreasing Loops:
          ++'(y,z){y -> .(x,y)} =
            ++'(.(x,y),z) ->^+ c5(++'(y,z))
              = C[++'(y,z) = ++'(y,z){}]

** Step 1.b:1: DependencyPairs.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            ++'(.(z0,z1),z2) -> c5(++'(z1,z2))
            ++'(nil(),z0) -> c4()
            IF(false(),z0,z1) -> c7()
            IF(true(),z0,z1) -> c6()
            MERGE(z0,nil()) -> c1()
            MERGE(.(z0,z1),.(z2,z3)) -> c2(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(z1,.(z2,z3)))
            MERGE(.(z0,z1),.(z2,z3)) -> c3(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(.(z0,z1),z3))
            MERGE(nil(),z0) -> c()
        - Weak TRS:
            ++(.(z0,z1),z2) -> .(z0,++(z1,z2))
            ++(nil(),z0) -> z0
            if(false(),z0,z1) -> z0
            if(true(),z0,z1) -> z0
            merge(z0,nil()) -> z0
            merge(.(z0,z1),.(z2,z3)) -> if(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
            merge(nil(),z0) -> z0
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2} / {./2,</2,c/0,c1/0,c2/2,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0
            ,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++,++',IF,MERGE,if,merge} and constructors {.,<,c,c1,c2
            ,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        DependencyPairs {dpKind_ = DT}
    + Details:
        We add the following dependency tuples:
        
        Strict DPs
          ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
          ++'#(nil(),z0) -> c_2()
          IF#(false(),z0,z1) -> c_3()
          IF#(true(),z0,z1) -> c_4()
          MERGE#(z0,nil()) -> c_5()
          MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,merge#(z1,.(z2,z3))
                                          ,merge#(.(z0,z1),z3)
                                          ,MERGE#(z1,.(z2,z3)))
          MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,merge#(z1,.(z2,z3))
                                          ,merge#(.(z0,z1),z3)
                                          ,MERGE#(.(z0,z1),z3))
          MERGE#(nil(),z0) -> c_8()
        Weak DPs
          ++#(.(z0,z1),z2) -> c_9(++#(z1,z2))
          ++#(nil(),z0) -> c_10()
          if#(false(),z0,z1) -> c_11()
          if#(true(),z0,z1) -> c_12()
          merge#(z0,nil()) -> c_13()
          merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                           ,merge#(z1,.(z2,z3))
                                           ,merge#(.(z0,z1),z3))
          merge#(nil(),z0) -> c_15()
        
        and mark the set of starting terms.
** Step 1.b:2: PredecessorEstimation.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
            ++'#(nil(),z0) -> c_2()
            IF#(false(),z0,z1) -> c_3()
            IF#(true(),z0,z1) -> c_4()
            MERGE#(z0,nil()) -> c_5()
            MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                            ,merge#(z1,.(z2,z3))
                                            ,merge#(.(z0,z1),z3)
                                            ,MERGE#(z1,.(z2,z3)))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                            ,merge#(z1,.(z2,z3))
                                            ,merge#(.(z0,z1),z3)
                                            ,MERGE#(.(z0,z1),z3))
            MERGE#(nil(),z0) -> c_8()
        - Weak DPs:
            ++#(.(z0,z1),z2) -> c_9(++#(z1,z2))
            ++#(nil(),z0) -> c_10()
            if#(false(),z0,z1) -> c_11()
            if#(true(),z0,z1) -> c_12()
            merge#(z0,nil()) -> c_13()
            merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                             ,merge#(z1,.(z2,z3))
                                             ,merge#(.(z0,z1),z3))
            merge#(nil(),z0) -> c_15()
        - Weak TRS:
            ++(.(z0,z1),z2) -> .(z0,++(z1,z2))
            ++(nil(),z0) -> z0
            ++'(.(z0,z1),z2) -> c5(++'(z1,z2))
            ++'(nil(),z0) -> c4()
            IF(false(),z0,z1) -> c7()
            IF(true(),z0,z1) -> c6()
            MERGE(z0,nil()) -> c1()
            MERGE(.(z0,z1),.(z2,z3)) -> c2(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(z1,.(z2,z3)))
            MERGE(.(z0,z1),.(z2,z3)) -> c3(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(.(z0,z1),z3))
            MERGE(nil(),z0) -> c()
            if(false(),z0,z1) -> z0
            if(true(),z0,z1) -> z0
            merge(z0,nil()) -> z0
            merge(.(z0,z1),.(z2,z3)) -> if(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
            merge(nil(),z0) -> z0
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2,++#/2,++'#/2,IF#/3,MERGE#/2,if#/3,merge#/2} / {./2,</2,c/0,c1/0,c2/2
            ,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0,true/0,c_1/1,c_2/0,c_3/0,c_4/0,c_5/0,c_6/4,c_7/4,c_8/0,c_9/1,c_10/0
            ,c_11/0,c_12/0,c_13/0,c_14/3,c_15/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++#,++'#,IF#,MERGE#,if#,merge#} and constructors {.,<,c
            ,c1,c2,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        PredecessorEstimation {onSelection = all simple predecessor estimation selector}
    + Details:
        We estimate the number of application of
          {2,3,4,5,8}
        by application of
          Pre({2,3,4,5,8}) = {1,6,7}.
        Here rules are labelled as follows:
          1: ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
          2: ++'#(nil(),z0) -> c_2()
          3: IF#(false(),z0,z1) -> c_3()
          4: IF#(true(),z0,z1) -> c_4()
          5: MERGE#(z0,nil()) -> c_5()
          6: MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                             ,merge#(z1,.(z2,z3))
                                             ,merge#(.(z0,z1),z3)
                                             ,MERGE#(z1,.(z2,z3)))
          7: MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                             ,merge#(z1,.(z2,z3))
                                             ,merge#(.(z0,z1),z3)
                                             ,MERGE#(.(z0,z1),z3))
          8: MERGE#(nil(),z0) -> c_8()
          9: ++#(.(z0,z1),z2) -> c_9(++#(z1,z2))
          10: ++#(nil(),z0) -> c_10()
          11: if#(false(),z0,z1) -> c_11()
          12: if#(true(),z0,z1) -> c_12()
          13: merge#(z0,nil()) -> c_13()
          14: merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                               ,merge#(z1,.(z2,z3))
                                               ,merge#(.(z0,z1),z3))
          15: merge#(nil(),z0) -> c_15()
** Step 1.b:3: RemoveWeakSuffixes.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                            ,merge#(z1,.(z2,z3))
                                            ,merge#(.(z0,z1),z3)
                                            ,MERGE#(z1,.(z2,z3)))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                            ,merge#(z1,.(z2,z3))
                                            ,merge#(.(z0,z1),z3)
                                            ,MERGE#(.(z0,z1),z3))
        - Weak DPs:
            ++#(.(z0,z1),z2) -> c_9(++#(z1,z2))
            ++#(nil(),z0) -> c_10()
            ++'#(nil(),z0) -> c_2()
            IF#(false(),z0,z1) -> c_3()
            IF#(true(),z0,z1) -> c_4()
            MERGE#(z0,nil()) -> c_5()
            MERGE#(nil(),z0) -> c_8()
            if#(false(),z0,z1) -> c_11()
            if#(true(),z0,z1) -> c_12()
            merge#(z0,nil()) -> c_13()
            merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                             ,merge#(z1,.(z2,z3))
                                             ,merge#(.(z0,z1),z3))
            merge#(nil(),z0) -> c_15()
        - Weak TRS:
            ++(.(z0,z1),z2) -> .(z0,++(z1,z2))
            ++(nil(),z0) -> z0
            ++'(.(z0,z1),z2) -> c5(++'(z1,z2))
            ++'(nil(),z0) -> c4()
            IF(false(),z0,z1) -> c7()
            IF(true(),z0,z1) -> c6()
            MERGE(z0,nil()) -> c1()
            MERGE(.(z0,z1),.(z2,z3)) -> c2(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(z1,.(z2,z3)))
            MERGE(.(z0,z1),.(z2,z3)) -> c3(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(.(z0,z1),z3))
            MERGE(nil(),z0) -> c()
            if(false(),z0,z1) -> z0
            if(true(),z0,z1) -> z0
            merge(z0,nil()) -> z0
            merge(.(z0,z1),.(z2,z3)) -> if(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
            merge(nil(),z0) -> z0
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2,++#/2,++'#/2,IF#/3,MERGE#/2,if#/3,merge#/2} / {./2,</2,c/0,c1/0,c2/2
            ,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0,true/0,c_1/1,c_2/0,c_3/0,c_4/0,c_5/0,c_6/4,c_7/4,c_8/0,c_9/1,c_10/0
            ,c_11/0,c_12/0,c_13/0,c_14/3,c_15/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++#,++'#,IF#,MERGE#,if#,merge#} and constructors {.,<,c
            ,c1,c2,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
             -->_1 ++'#(nil(),z0) -> c_2():6
             -->_1 ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2)):1
          
          2:S:MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                              ,merge#(z1,.(z2,z3))
                                              ,merge#(.(z0,z1),z3)
                                              ,MERGE#(z1,.(z2,z3)))
             -->_3 merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                    ,merge#(z1,.(z2,z3))
                                                    ,merge#(.(z0,z1),z3)):14
             -->_2 merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                    ,merge#(z1,.(z2,z3))
                                                    ,merge#(.(z0,z1),z3)):14
             -->_4 MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                   ,merge#(z1,.(z2,z3))
                                                   ,merge#(.(z0,z1),z3)
                                                   ,MERGE#(.(z0,z1),z3)):3
             -->_2 merge#(nil(),z0) -> c_15():15
             -->_3 merge#(z0,nil()) -> c_13():13
             -->_4 MERGE#(nil(),z0) -> c_8():10
             -->_4 MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                   ,merge#(z1,.(z2,z3))
                                                   ,merge#(.(z0,z1),z3)
                                                   ,MERGE#(z1,.(z2,z3))):2
          
          3:S:MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                              ,merge#(z1,.(z2,z3))
                                              ,merge#(.(z0,z1),z3)
                                              ,MERGE#(.(z0,z1),z3))
             -->_3 merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                    ,merge#(z1,.(z2,z3))
                                                    ,merge#(.(z0,z1),z3)):14
             -->_2 merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                    ,merge#(z1,.(z2,z3))
                                                    ,merge#(.(z0,z1),z3)):14
             -->_2 merge#(nil(),z0) -> c_15():15
             -->_3 merge#(z0,nil()) -> c_13():13
             -->_4 MERGE#(z0,nil()) -> c_5():9
             -->_4 MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                   ,merge#(z1,.(z2,z3))
                                                   ,merge#(.(z0,z1),z3)
                                                   ,MERGE#(.(z0,z1),z3)):3
             -->_4 MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                   ,merge#(z1,.(z2,z3))
                                                   ,merge#(.(z0,z1),z3)
                                                   ,MERGE#(z1,.(z2,z3))):2
          
          4:W:++#(.(z0,z1),z2) -> c_9(++#(z1,z2))
             -->_1 ++#(nil(),z0) -> c_10():5
             -->_1 ++#(.(z0,z1),z2) -> c_9(++#(z1,z2)):4
          
          5:W:++#(nil(),z0) -> c_10()
             
          
          6:W:++'#(nil(),z0) -> c_2()
             
          
          7:W:IF#(false(),z0,z1) -> c_3()
             
          
          8:W:IF#(true(),z0,z1) -> c_4()
             
          
          9:W:MERGE#(z0,nil()) -> c_5()
             
          
          10:W:MERGE#(nil(),z0) -> c_8()
             
          
          11:W:if#(false(),z0,z1) -> c_11()
             
          
          12:W:if#(true(),z0,z1) -> c_12()
             
          
          13:W:merge#(z0,nil()) -> c_13()
             
          
          14:W:merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                ,merge#(z1,.(z2,z3))
                                                ,merge#(.(z0,z1),z3))
             -->_2 merge#(nil(),z0) -> c_15():15
             -->_3 merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                    ,merge#(z1,.(z2,z3))
                                                    ,merge#(.(z0,z1),z3)):14
             -->_2 merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                    ,merge#(z1,.(z2,z3))
                                                    ,merge#(.(z0,z1),z3)):14
             -->_3 merge#(z0,nil()) -> c_13():13
          
          15:W:merge#(nil(),z0) -> c_15()
             
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          12: if#(true(),z0,z1) -> c_12()
          11: if#(false(),z0,z1) -> c_11()
          8: IF#(true(),z0,z1) -> c_4()
          7: IF#(false(),z0,z1) -> c_3()
          4: ++#(.(z0,z1),z2) -> c_9(++#(z1,z2))
          5: ++#(nil(),z0) -> c_10()
          10: MERGE#(nil(),z0) -> c_8()
          9: MERGE#(z0,nil()) -> c_5()
          14: merge#(.(z0,z1),.(z2,z3)) -> c_14(if#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                               ,merge#(z1,.(z2,z3))
                                               ,merge#(.(z0,z1),z3))
          13: merge#(z0,nil()) -> c_13()
          15: merge#(nil(),z0) -> c_15()
          6: ++'#(nil(),z0) -> c_2()
** Step 1.b:4: SimplifyRHS.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                            ,merge#(z1,.(z2,z3))
                                            ,merge#(.(z0,z1),z3)
                                            ,MERGE#(z1,.(z2,z3)))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                            ,merge#(z1,.(z2,z3))
                                            ,merge#(.(z0,z1),z3)
                                            ,MERGE#(.(z0,z1),z3))
        - Weak TRS:
            ++(.(z0,z1),z2) -> .(z0,++(z1,z2))
            ++(nil(),z0) -> z0
            ++'(.(z0,z1),z2) -> c5(++'(z1,z2))
            ++'(nil(),z0) -> c4()
            IF(false(),z0,z1) -> c7()
            IF(true(),z0,z1) -> c6()
            MERGE(z0,nil()) -> c1()
            MERGE(.(z0,z1),.(z2,z3)) -> c2(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(z1,.(z2,z3)))
            MERGE(.(z0,z1),.(z2,z3)) -> c3(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(.(z0,z1),z3))
            MERGE(nil(),z0) -> c()
            if(false(),z0,z1) -> z0
            if(true(),z0,z1) -> z0
            merge(z0,nil()) -> z0
            merge(.(z0,z1),.(z2,z3)) -> if(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
            merge(nil(),z0) -> z0
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2,++#/2,++'#/2,IF#/3,MERGE#/2,if#/3,merge#/2} / {./2,</2,c/0,c1/0,c2/2
            ,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0,true/0,c_1/1,c_2/0,c_3/0,c_4/0,c_5/0,c_6/4,c_7/4,c_8/0,c_9/1,c_10/0
            ,c_11/0,c_12/0,c_13/0,c_14/3,c_15/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++#,++'#,IF#,MERGE#,if#,merge#} and constructors {.,<,c
            ,c1,c2,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
             -->_1 ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2)):1
          
          2:S:MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                              ,merge#(z1,.(z2,z3))
                                              ,merge#(.(z0,z1),z3)
                                              ,MERGE#(z1,.(z2,z3)))
             -->_4 MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                   ,merge#(z1,.(z2,z3))
                                                   ,merge#(.(z0,z1),z3)
                                                   ,MERGE#(.(z0,z1),z3)):3
             -->_4 MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                   ,merge#(z1,.(z2,z3))
                                                   ,merge#(.(z0,z1),z3)
                                                   ,MERGE#(z1,.(z2,z3))):2
          
          3:S:MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                              ,merge#(z1,.(z2,z3))
                                              ,merge#(.(z0,z1),z3)
                                              ,MERGE#(.(z0,z1),z3))
             -->_4 MERGE#(.(z0,z1),.(z2,z3)) -> c_7(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                   ,merge#(z1,.(z2,z3))
                                                   ,merge#(.(z0,z1),z3)
                                                   ,MERGE#(.(z0,z1),z3)):3
             -->_4 MERGE#(.(z0,z1),.(z2,z3)) -> c_6(IF#(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                                   ,merge#(z1,.(z2,z3))
                                                   ,merge#(.(z0,z1),z3)
                                                   ,MERGE#(z1,.(z2,z3))):2
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          MERGE#(.(z0,z1),.(z2,z3)) -> c_6(MERGE#(z1,.(z2,z3)))
          MERGE#(.(z0,z1),.(z2,z3)) -> c_7(MERGE#(.(z0,z1),z3))
** Step 1.b:5: UsableRules.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_6(MERGE#(z1,.(z2,z3)))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_7(MERGE#(.(z0,z1),z3))
        - Weak TRS:
            ++(.(z0,z1),z2) -> .(z0,++(z1,z2))
            ++(nil(),z0) -> z0
            ++'(.(z0,z1),z2) -> c5(++'(z1,z2))
            ++'(nil(),z0) -> c4()
            IF(false(),z0,z1) -> c7()
            IF(true(),z0,z1) -> c6()
            MERGE(z0,nil()) -> c1()
            MERGE(.(z0,z1),.(z2,z3)) -> c2(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(z1,.(z2,z3)))
            MERGE(.(z0,z1),.(z2,z3)) -> c3(IF(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
                                          ,MERGE(.(z0,z1),z3))
            MERGE(nil(),z0) -> c()
            if(false(),z0,z1) -> z0
            if(true(),z0,z1) -> z0
            merge(z0,nil()) -> z0
            merge(.(z0,z1),.(z2,z3)) -> if(<(z0,z2),.(z0,merge(z1,.(z2,z3))),.(z2,merge(.(z0,z1),z3)))
            merge(nil(),z0) -> z0
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2,++#/2,++'#/2,IF#/3,MERGE#/2,if#/3,merge#/2} / {./2,</2,c/0,c1/0,c2/2
            ,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0,true/0,c_1/1,c_2/0,c_3/0,c_4/0,c_5/0,c_6/1,c_7/1,c_8/0,c_9/1,c_10/0
            ,c_11/0,c_12/0,c_13/0,c_14/3,c_15/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++#,++'#,IF#,MERGE#,if#,merge#} and constructors {.,<,c
            ,c1,c2,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        UsableRules
    + Details:
        We replace rewrite rules by usable rules:
          ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
          MERGE#(.(z0,z1),.(z2,z3)) -> c_6(MERGE#(z1,.(z2,z3)))
          MERGE#(.(z0,z1),.(z2,z3)) -> c_7(MERGE#(.(z0,z1),z3))
** Step 1.b:6: NaturalMI.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_6(MERGE#(z1,.(z2,z3)))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_7(MERGE#(.(z0,z1),z3))
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2,++#/2,++'#/2,IF#/3,MERGE#/2,if#/3,merge#/2} / {./2,</2,c/0,c1/0,c2/2
            ,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0,true/0,c_1/1,c_2/0,c_3/0,c_4/0,c_5/0,c_6/1,c_7/1,c_8/0,c_9/1,c_10/0
            ,c_11/0,c_12/0,c_13/0,c_14/3,c_15/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++#,++'#,IF#,MERGE#,if#,merge#} and constructors {.,<,c
            ,c1,c2,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          uargs(c_1) = {1},
          uargs(c_6) = {1},
          uargs(c_7) = {1}
        
        Following symbols are considered usable:
          {++#,++'#,IF#,MERGE#,if#,merge#}
        TcT has computed the following interpretation:
              p(++) = [0]                           
             p(++') = [0]                           
               p(.) = [1] x1 + [1] x2 + [6]         
               p(<) = [1] x1 + [0]                  
              p(IF) = [8] x2 + [8] x3 + [0]         
           p(MERGE) = [8] x1 + [0]                  
               p(c) = [0]                           
              p(c1) = [0]                           
              p(c2) = [1] x1 + [0]                  
              p(c3) = [1] x2 + [0]                  
              p(c4) = [0]                           
              p(c5) = [1] x1 + [0]                  
              p(c6) = [0]                           
              p(c7) = [0]                           
           p(false) = [0]                           
              p(if) = [1] x3 + [0]                  
           p(merge) = [1] x2 + [0]                  
             p(nil) = [0]                           
            p(true) = [0]                           
             p(++#) = [1] x1 + [1] x2 + [1]         
            p(++'#) = [5] x1 + [5] x2 + [1]         
             p(IF#) = [1] x1 + [1] x2 + [1] x3 + [8]
          p(MERGE#) = [0]                           
             p(if#) = [1] x1 + [2] x2 + [0]         
          p(merge#) = [2]                           
             p(c_1) = [1] x1 + [9]                  
             p(c_2) = [1]                           
             p(c_3) = [2]                           
             p(c_4) = [0]                           
             p(c_5) = [0]                           
             p(c_6) = [8] x1 + [0]                  
             p(c_7) = [8] x1 + [0]                  
             p(c_8) = [1]                           
             p(c_9) = [2] x1 + [0]                  
            p(c_10) = [1]                           
            p(c_11) = [1]                           
            p(c_12) = [0]                           
            p(c_13) = [1]                           
            p(c_14) = [2] x1 + [1] x2 + [4] x3 + [4]
            p(c_15) = [2]                           
        
        Following rules are strictly oriented:
        ++'#(.(z0,z1),z2) = [5] z0 + [5] z1 + [5] z2 + [31]
                          > [5] z1 + [5] z2 + [10]         
                          = c_1(++'#(z1,z2))               
        
        
        Following rules are (at-least) weakly oriented:
        MERGE#(.(z0,z1),.(z2,z3)) =  [0]                     
                                  >= [0]                     
                                  =  c_6(MERGE#(z1,.(z2,z3)))
        
        MERGE#(.(z0,z1),.(z2,z3)) =  [0]                     
                                  >= [0]                     
                                  =  c_7(MERGE#(.(z0,z1),z3))
        
** Step 1.b:7: NaturalMI.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            MERGE#(.(z0,z1),.(z2,z3)) -> c_6(MERGE#(z1,.(z2,z3)))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_7(MERGE#(.(z0,z1),z3))
        - Weak DPs:
            ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2,++#/2,++'#/2,IF#/3,MERGE#/2,if#/3,merge#/2} / {./2,</2,c/0,c1/0,c2/2
            ,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0,true/0,c_1/1,c_2/0,c_3/0,c_4/0,c_5/0,c_6/1,c_7/1,c_8/0,c_9/1,c_10/0
            ,c_11/0,c_12/0,c_13/0,c_14/3,c_15/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++#,++'#,IF#,MERGE#,if#,merge#} and constructors {.,<,c
            ,c1,c2,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          uargs(c_1) = {1},
          uargs(c_6) = {1},
          uargs(c_7) = {1}
        
        Following symbols are considered usable:
          {++#,++'#,IF#,MERGE#,if#,merge#}
        TcT has computed the following interpretation:
              p(++) = [1] x1 + [8] x2 + [0]
             p(++') = [4]                  
               p(.) = [1] x2 + [1]         
               p(<) = [0]                  
              p(IF) = [1] x1 + [1] x2 + [1]
           p(MERGE) = [1] x1 + [1]         
               p(c) = [2]                  
              p(c1) = [1]                  
              p(c2) = [1] x1 + [1] x2 + [1]
              p(c3) = [1] x1 + [1]         
              p(c4) = [2]                  
              p(c5) = [0]                  
              p(c6) = [1]                  
              p(c7) = [2]                  
           p(false) = [0]                  
              p(if) = [2] x2 + [0]         
           p(merge) = [1] x1 + [1] x2 + [1]
             p(nil) = [0]                  
            p(true) = [1]                  
             p(++#) = [8] x1 + [1]         
            p(++'#) = [8] x2 + [8]         
             p(IF#) = [4] x1 + [1] x3 + [1]
          p(MERGE#) = [1] x1 + [2] x2 + [0]
             p(if#) = [2] x2 + [2] x3 + [0]
          p(merge#) = [1] x1 + [1] x2 + [1]
             p(c_1) = [1] x1 + [0]         
             p(c_2) = [0]                  
             p(c_3) = [1]                  
             p(c_4) = [0]                  
             p(c_5) = [1]                  
             p(c_6) = [1] x1 + [0]         
             p(c_7) = [1] x1 + [2]         
             p(c_8) = [1]                  
             p(c_9) = [2]                  
            p(c_10) = [4]                  
            p(c_11) = [1]                  
            p(c_12) = [0]                  
            p(c_13) = [0]                  
            p(c_14) = [1] x2 + [1] x3 + [1]
            p(c_15) = [0]                  
        
        Following rules are strictly oriented:
        MERGE#(.(z0,z1),.(z2,z3)) = [1] z1 + [2] z3 + [3]   
                                  > [1] z1 + [2] z3 + [2]   
                                  = c_6(MERGE#(z1,.(z2,z3)))
        
        
        Following rules are (at-least) weakly oriented:
                ++'#(.(z0,z1),z2) =  [8] z2 + [8]            
                                  >= [8] z2 + [8]            
                                  =  c_1(++'#(z1,z2))        
        
        MERGE#(.(z0,z1),.(z2,z3)) =  [1] z1 + [2] z3 + [3]   
                                  >= [1] z1 + [2] z3 + [3]   
                                  =  c_7(MERGE#(.(z0,z1),z3))
        
** Step 1.b:8: NaturalMI.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            MERGE#(.(z0,z1),.(z2,z3)) -> c_7(MERGE#(.(z0,z1),z3))
        - Weak DPs:
            ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_6(MERGE#(z1,.(z2,z3)))
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2,++#/2,++'#/2,IF#/3,MERGE#/2,if#/3,merge#/2} / {./2,</2,c/0,c1/0,c2/2
            ,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0,true/0,c_1/1,c_2/0,c_3/0,c_4/0,c_5/0,c_6/1,c_7/1,c_8/0,c_9/1,c_10/0
            ,c_11/0,c_12/0,c_13/0,c_14/3,c_15/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++#,++'#,IF#,MERGE#,if#,merge#} and constructors {.,<,c
            ,c1,c2,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          uargs(c_1) = {1},
          uargs(c_6) = {1},
          uargs(c_7) = {1}
        
        Following symbols are considered usable:
          {++#,++'#,IF#,MERGE#,if#,merge#}
        TcT has computed the following interpretation:
              p(++) = [0]                           
             p(++') = [0]                           
               p(.) = [1] x1 + [1] x2 + [1]         
               p(<) = [1] x1 + [1] x2 + [0]         
              p(IF) = [8] x1 + [2] x3 + [8]         
           p(MERGE) = [8]                           
               p(c) = [4]                           
              p(c1) = [1]                           
              p(c2) = [1]                           
              p(c3) = [1] x1 + [1]                  
              p(c4) = [8]                           
              p(c5) = [1]                           
              p(c6) = [0]                           
              p(c7) = [1]                           
           p(false) = [0]                           
              p(if) = [4] x1 + [1] x3 + [2]         
           p(merge) = [1] x2 + [0]                  
             p(nil) = [1]                           
            p(true) = [1]                           
             p(++#) = [4] x1 + [2] x2 + [0]         
            p(++'#) = [4] x1 + [0]                  
             p(IF#) = [8] x2 + [4]                  
          p(MERGE#) = [2] x2 + [1]                  
             p(if#) = [1] x1 + [2] x3 + [2]         
          p(merge#) = [2] x2 + [1]                  
             p(c_1) = [1] x1 + [1]                  
             p(c_2) = [1]                           
             p(c_3) = [0]                           
             p(c_4) = [1]                           
             p(c_5) = [0]                           
             p(c_6) = [1] x1 + [0]                  
             p(c_7) = [1] x1 + [0]                  
             p(c_8) = [2]                           
             p(c_9) = [1]                           
            p(c_10) = [0]                           
            p(c_11) = [1]                           
            p(c_12) = [1]                           
            p(c_13) = [1]                           
            p(c_14) = [2] x1 + [1] x2 + [1] x3 + [1]
            p(c_15) = [1]                           
        
        Following rules are strictly oriented:
        MERGE#(.(z0,z1),.(z2,z3)) = [2] z2 + [2] z3 + [3]   
                                  > [2] z3 + [1]            
                                  = c_7(MERGE#(.(z0,z1),z3))
        
        
        Following rules are (at-least) weakly oriented:
                ++'#(.(z0,z1),z2) =  [4] z0 + [4] z1 + [4]   
                                  >= [4] z1 + [1]            
                                  =  c_1(++'#(z1,z2))        
        
        MERGE#(.(z0,z1),.(z2,z3)) =  [2] z2 + [2] z3 + [3]   
                                  >= [2] z2 + [2] z3 + [3]   
                                  =  c_6(MERGE#(z1,.(z2,z3)))
        
** Step 1.b:9: EmptyProcessor.  WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            ++'#(.(z0,z1),z2) -> c_1(++'#(z1,z2))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_6(MERGE#(z1,.(z2,z3)))
            MERGE#(.(z0,z1),.(z2,z3)) -> c_7(MERGE#(.(z0,z1),z3))
        - Signature:
            {++/2,++'/2,IF/3,MERGE/2,if/3,merge/2,++#/2,++'#/2,IF#/3,MERGE#/2,if#/3,merge#/2} / {./2,</2,c/0,c1/0,c2/2
            ,c3/2,c4/0,c5/1,c6/0,c7/0,false/0,nil/0,true/0,c_1/1,c_2/0,c_3/0,c_4/0,c_5/0,c_6/1,c_7/1,c_8/0,c_9/1,c_10/0
            ,c_11/0,c_12/0,c_13/0,c_14/3,c_15/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++#,++'#,IF#,MERGE#,if#,merge#} and constructors {.,<,c
            ,c1,c2,c3,c4,c5,c6,c7,false,nil,true}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(Omega(n^1),O(n^1))