WORST_CASE(?,O(n^2))
* Step 1: DependencyPairs WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            flattensort(t) -> insertionsort(flatten(t))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1} / {'0/0,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0
            ,dd/2,leaf/0,nil/0,node/3}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt,'compare,'less,append,append'1,flatten,flatten'1
            ,flattensort,insert,insert'1,insert'2,insertionsort,insertionsort'1} and constructors {'0,'EQ,'GT,'LT,'false
            ,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        DependencyPairs {dpKind_ = DT}
    + Details:
        We add the following dependency tuples:
        
        Strict DPs
          'cklt#('EQ()) -> c_1()
          'cklt#('GT()) -> c_2()
          'cklt#('LT()) -> c_3()
          'compare#('0(),'0()) -> c_4()
          'compare#('0(),'neg(y)) -> c_5()
          'compare#('0(),'pos(y)) -> c_6()
          'compare#('0(),'s(y)) -> c_7()
          'compare#('neg(x),'0()) -> c_8()
          'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          'compare#('neg(x),'pos(y)) -> c_10()
          'compare#('pos(x),'0()) -> c_11()
          'compare#('pos(x),'neg(y)) -> c_12()
          'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          'compare#('s(x),'0()) -> c_14()
          'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
          append#(l1,l2) -> c_17(append'1#(l1,l2))
          append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          append'1#(nil(),l2) -> c_19()
          flatten#(t) -> c_20(flatten'1#(t))
          flatten'1#(leaf()) -> c_21()
          flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                           ,append#(flatten(t1),flatten(t2))
                                           ,flatten#(t1)
                                           ,flatten#(t2))
          flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
          insert#(x,l) -> c_24(insert'1#(l,x))
          insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
          insert'1#(nil(),x) -> c_26()
          insert'2#('false(),x,y,ys) -> c_27()
          insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          insertionsort#(l) -> c_29(insertionsort'1#(l))
          insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          insertionsort'1#(nil()) -> c_31()
        Weak DPs
          
        
        and mark the set of starting terms.
* Step 2: UsableRules WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'cklt#('EQ()) -> c_1()
            'cklt#('GT()) -> c_2()
            'cklt#('LT()) -> c_3()
            'compare#('0(),'0()) -> c_4()
            'compare#('0(),'neg(y)) -> c_5()
            'compare#('0(),'pos(y)) -> c_6()
            'compare#('0(),'s(y)) -> c_7()
            'compare#('neg(x),'0()) -> c_8()
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('neg(x),'pos(y)) -> c_10()
            'compare#('pos(x),'0()) -> c_11()
            'compare#('pos(x),'neg(y)) -> c_12()
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'0()) -> c_14()
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            append'1#(nil(),l2) -> c_19()
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(leaf()) -> c_21()
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'1#(nil(),x) -> c_26()
            insert'2#('false(),x,y,ys) -> c_27()
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
            insertionsort'1#(nil()) -> c_31()
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            flattensort(t) -> insertionsort(flatten(t))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/2,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        UsableRules
    + Details:
        We replace rewrite rules by usable rules:
          'cklt('EQ()) -> 'false()
          'cklt('GT()) -> 'false()
          'cklt('LT()) -> 'true()
          'compare('0(),'0()) -> 'EQ()
          'compare('0(),'neg(y)) -> 'GT()
          'compare('0(),'pos(y)) -> 'LT()
          'compare('0(),'s(y)) -> 'LT()
          'compare('neg(x),'0()) -> 'LT()
          'compare('neg(x),'neg(y)) -> 'compare(y,x)
          'compare('neg(x),'pos(y)) -> 'LT()
          'compare('pos(x),'0()) -> 'GT()
          'compare('pos(x),'neg(y)) -> 'GT()
          'compare('pos(x),'pos(y)) -> 'compare(x,y)
          'compare('s(x),'0()) -> 'GT()
          'compare('s(x),'s(y)) -> 'compare(x,y)
          'less(x,y) -> 'cklt('compare(x,y))
          append(l1,l2) -> append'1(l1,l2)
          append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
          append'1(nil(),l2) -> l2
          flatten(t) -> flatten'1(t)
          flatten'1(leaf()) -> nil()
          flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
          insert(x,l) -> insert'1(l,x)
          insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
          insert'1(nil(),x) -> dd(x,nil())
          insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
          insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
          insertionsort(l) -> insertionsort'1(l)
          insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
          insertionsort'1(nil()) -> nil()
          'cklt#('EQ()) -> c_1()
          'cklt#('GT()) -> c_2()
          'cklt#('LT()) -> c_3()
          'compare#('0(),'0()) -> c_4()
          'compare#('0(),'neg(y)) -> c_5()
          'compare#('0(),'pos(y)) -> c_6()
          'compare#('0(),'s(y)) -> c_7()
          'compare#('neg(x),'0()) -> c_8()
          'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          'compare#('neg(x),'pos(y)) -> c_10()
          'compare#('pos(x),'0()) -> c_11()
          'compare#('pos(x),'neg(y)) -> c_12()
          'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          'compare#('s(x),'0()) -> c_14()
          'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
          append#(l1,l2) -> c_17(append'1#(l1,l2))
          append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          append'1#(nil(),l2) -> c_19()
          flatten#(t) -> c_20(flatten'1#(t))
          flatten'1#(leaf()) -> c_21()
          flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                           ,append#(flatten(t1),flatten(t2))
                                           ,flatten#(t1)
                                           ,flatten#(t2))
          flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
          insert#(x,l) -> c_24(insert'1#(l,x))
          insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
          insert'1#(nil(),x) -> c_26()
          insert'2#('false(),x,y,ys) -> c_27()
          insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          insertionsort#(l) -> c_29(insertionsort'1#(l))
          insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          insertionsort'1#(nil()) -> c_31()
* Step 3: PredecessorEstimation WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'cklt#('EQ()) -> c_1()
            'cklt#('GT()) -> c_2()
            'cklt#('LT()) -> c_3()
            'compare#('0(),'0()) -> c_4()
            'compare#('0(),'neg(y)) -> c_5()
            'compare#('0(),'pos(y)) -> c_6()
            'compare#('0(),'s(y)) -> c_7()
            'compare#('neg(x),'0()) -> c_8()
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('neg(x),'pos(y)) -> c_10()
            'compare#('pos(x),'0()) -> c_11()
            'compare#('pos(x),'neg(y)) -> c_12()
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'0()) -> c_14()
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            append'1#(nil(),l2) -> c_19()
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(leaf()) -> c_21()
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'1#(nil(),x) -> c_26()
            insert'2#('false(),x,y,ys) -> c_27()
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
            insertionsort'1#(nil()) -> c_31()
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/2,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimation {onSelection = all simple predecessor estimation selector}
    + Details:
        We estimate the number of application of
          {1,2,3,4,5,6,7,8,10,11,12,14,19,21,26,27,31}
        by application of
          Pre({1,2,3,4,5,6,7,8,10,11,12,14,19,21,26,27,31}) = {9,13,15,16,17,20,24,25,29}.
        Here rules are labelled as follows:
          1: 'cklt#('EQ()) -> c_1()
          2: 'cklt#('GT()) -> c_2()
          3: 'cklt#('LT()) -> c_3()
          4: 'compare#('0(),'0()) -> c_4()
          5: 'compare#('0(),'neg(y)) -> c_5()
          6: 'compare#('0(),'pos(y)) -> c_6()
          7: 'compare#('0(),'s(y)) -> c_7()
          8: 'compare#('neg(x),'0()) -> c_8()
          9: 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          10: 'compare#('neg(x),'pos(y)) -> c_10()
          11: 'compare#('pos(x),'0()) -> c_11()
          12: 'compare#('pos(x),'neg(y)) -> c_12()
          13: 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          14: 'compare#('s(x),'0()) -> c_14()
          15: 'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          16: 'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
          17: append#(l1,l2) -> c_17(append'1#(l1,l2))
          18: append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          19: append'1#(nil(),l2) -> c_19()
          20: flatten#(t) -> c_20(flatten'1#(t))
          21: flatten'1#(leaf()) -> c_21()
          22: flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
          23: flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
          24: insert#(x,l) -> c_24(insert'1#(l,x))
          25: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
          26: insert'1#(nil(),x) -> c_26()
          27: insert'2#('false(),x,y,ys) -> c_27()
          28: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          29: insertionsort#(l) -> c_29(insertionsort'1#(l))
          30: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          31: insertionsort'1#(nil()) -> c_31()
* Step 4: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            'cklt#('EQ()) -> c_1()
            'cklt#('GT()) -> c_2()
            'cklt#('LT()) -> c_3()
            'compare#('0(),'0()) -> c_4()
            'compare#('0(),'neg(y)) -> c_5()
            'compare#('0(),'pos(y)) -> c_6()
            'compare#('0(),'s(y)) -> c_7()
            'compare#('neg(x),'0()) -> c_8()
            'compare#('neg(x),'pos(y)) -> c_10()
            'compare#('pos(x),'0()) -> c_11()
            'compare#('pos(x),'neg(y)) -> c_12()
            'compare#('s(x),'0()) -> c_14()
            append'1#(nil(),l2) -> c_19()
            flatten'1#(leaf()) -> c_21()
            insert'1#(nil(),x) -> c_26()
            insert'2#('false(),x,y,ys) -> c_27()
            insertionsort'1#(nil()) -> c_31()
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/2,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('s(x),'0()) -> c_14():26
             -->_1 'compare#('pos(x),'neg(y)) -> c_12():25
             -->_1 'compare#('pos(x),'0()) -> c_11():24
             -->_1 'compare#('neg(x),'pos(y)) -> c_10():23
             -->_1 'compare#('neg(x),'0()) -> c_8():22
             -->_1 'compare#('0(),'s(y)) -> c_7():21
             -->_1 'compare#('0(),'pos(y)) -> c_6():20
             -->_1 'compare#('0(),'neg(y)) -> c_5():19
             -->_1 'compare#('0(),'0()) -> c_4():18
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          2:S:'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('s(x),'0()) -> c_14():26
             -->_1 'compare#('pos(x),'neg(y)) -> c_12():25
             -->_1 'compare#('pos(x),'0()) -> c_11():24
             -->_1 'compare#('neg(x),'pos(y)) -> c_10():23
             -->_1 'compare#('neg(x),'0()) -> c_8():22
             -->_1 'compare#('0(),'s(y)) -> c_7():21
             -->_1 'compare#('0(),'pos(y)) -> c_6():20
             -->_1 'compare#('0(),'neg(y)) -> c_5():19
             -->_1 'compare#('0(),'0()) -> c_4():18
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          3:S:'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
             -->_1 'compare#('s(x),'0()) -> c_14():26
             -->_1 'compare#('pos(x),'neg(y)) -> c_12():25
             -->_1 'compare#('pos(x),'0()) -> c_11():24
             -->_1 'compare#('neg(x),'pos(y)) -> c_10():23
             -->_1 'compare#('neg(x),'0()) -> c_8():22
             -->_1 'compare#('0(),'s(y)) -> c_7():21
             -->_1 'compare#('0(),'pos(y)) -> c_6():20
             -->_1 'compare#('0(),'neg(y)) -> c_5():19
             -->_1 'compare#('0(),'0()) -> c_4():18
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          4:S:'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
             -->_2 'compare#('s(x),'0()) -> c_14():26
             -->_2 'compare#('pos(x),'neg(y)) -> c_12():25
             -->_2 'compare#('pos(x),'0()) -> c_11():24
             -->_2 'compare#('neg(x),'pos(y)) -> c_10():23
             -->_2 'compare#('neg(x),'0()) -> c_8():22
             -->_2 'compare#('0(),'s(y)) -> c_7():21
             -->_2 'compare#('0(),'pos(y)) -> c_6():20
             -->_2 'compare#('0(),'neg(y)) -> c_5():19
             -->_2 'compare#('0(),'0()) -> c_4():18
             -->_1 'cklt#('LT()) -> c_3():17
             -->_1 'cklt#('GT()) -> c_2():16
             -->_1 'cklt#('EQ()) -> c_1():15
             -->_2 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_2 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_2 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          5:S:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):6
             -->_1 append'1#(nil(),l2) -> c_19():27
          
          6:S:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
          
          7:S:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):8
             -->_1 flatten'1#(leaf()) -> c_21():28
          
          8:S:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):7
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):7
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
          
          9:S:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):13
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):7
          
          10:S:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x)):11
             -->_1 insert'1#(nil(),x) -> c_26():29
          
          11:S:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):12
             -->_1 insert'2#('false(),x,y,ys) -> c_27():30
             -->_2 'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y)):4
          
          12:S:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):10
          
          13:S:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):14
             -->_1 insertionsort'1#(nil()) -> c_31():31
          
          14:S:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):13
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):10
          
          15:W:'cklt#('EQ()) -> c_1()
             
          
          16:W:'cklt#('GT()) -> c_2()
             
          
          17:W:'cklt#('LT()) -> c_3()
             
          
          18:W:'compare#('0(),'0()) -> c_4()
             
          
          19:W:'compare#('0(),'neg(y)) -> c_5()
             
          
          20:W:'compare#('0(),'pos(y)) -> c_6()
             
          
          21:W:'compare#('0(),'s(y)) -> c_7()
             
          
          22:W:'compare#('neg(x),'0()) -> c_8()
             
          
          23:W:'compare#('neg(x),'pos(y)) -> c_10()
             
          
          24:W:'compare#('pos(x),'0()) -> c_11()
             
          
          25:W:'compare#('pos(x),'neg(y)) -> c_12()
             
          
          26:W:'compare#('s(x),'0()) -> c_14()
             
          
          27:W:append'1#(nil(),l2) -> c_19()
             
          
          28:W:flatten'1#(leaf()) -> c_21()
             
          
          29:W:insert'1#(nil(),x) -> c_26()
             
          
          30:W:insert'2#('false(),x,y,ys) -> c_27()
             
          
          31:W:insertionsort'1#(nil()) -> c_31()
             
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          31: insertionsort'1#(nil()) -> c_31()
          29: insert'1#(nil(),x) -> c_26()
          30: insert'2#('false(),x,y,ys) -> c_27()
          28: flatten'1#(leaf()) -> c_21()
          27: append'1#(nil(),l2) -> c_19()
          15: 'cklt#('EQ()) -> c_1()
          16: 'cklt#('GT()) -> c_2()
          17: 'cklt#('LT()) -> c_3()
          18: 'compare#('0(),'0()) -> c_4()
          19: 'compare#('0(),'neg(y)) -> c_5()
          20: 'compare#('0(),'pos(y)) -> c_6()
          21: 'compare#('0(),'s(y)) -> c_7()
          22: 'compare#('neg(x),'0()) -> c_8()
          23: 'compare#('neg(x),'pos(y)) -> c_10()
          24: 'compare#('pos(x),'0()) -> c_11()
          25: 'compare#('pos(x),'neg(y)) -> c_12()
          26: 'compare#('s(x),'0()) -> c_14()
* Step 5: SimplifyRHS WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/2,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          2:S:'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          3:S:'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          4:S:'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y))
             -->_2 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_2 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_2 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          5:S:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):6
          
          6:S:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
          
          7:S:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):8
          
          8:S:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):7
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):7
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
          
          9:S:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):13
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):7
          
          10:S:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x)):11
          
          11:S:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):12
             -->_2 'less#(x,y) -> c_16('cklt#('compare(x,y)),'compare#(x,y)):4
          
          12:S:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):10
          
          13:S:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):14
          
          14:S:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):13
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):10
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          'less#(x,y) -> c_16('compare#(x,y))
* Step 6: Decompose WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd}
    + Details:
        We analyse the complexity of following sub-problems (R) and (S).
        Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component.
        
        Problem (R)
          - Strict DPs:
              'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
              'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
              'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          - Weak DPs:
              'less#(x,y) -> c_16('compare#(x,y))
              append#(l1,l2) -> c_17(append'1#(l1,l2))
              append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
              flatten#(t) -> c_20(flatten'1#(t))
              flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
              flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
              insert#(x,l) -> c_24(insert'1#(l,x))
              insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
              insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
              insertionsort#(l) -> c_29(insertionsort'1#(l))
              insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          - Weak TRS:
              'cklt('EQ()) -> 'false()
              'cklt('GT()) -> 'false()
              'cklt('LT()) -> 'true()
              'compare('0(),'0()) -> 'EQ()
              'compare('0(),'neg(y)) -> 'GT()
              'compare('0(),'pos(y)) -> 'LT()
              'compare('0(),'s(y)) -> 'LT()
              'compare('neg(x),'0()) -> 'LT()
              'compare('neg(x),'neg(y)) -> 'compare(y,x)
              'compare('neg(x),'pos(y)) -> 'LT()
              'compare('pos(x),'0()) -> 'GT()
              'compare('pos(x),'neg(y)) -> 'GT()
              'compare('pos(x),'pos(y)) -> 'compare(x,y)
              'compare('s(x),'0()) -> 'GT()
              'compare('s(x),'s(y)) -> 'compare(x,y)
              'less(x,y) -> 'cklt('compare(x,y))
              append(l1,l2) -> append'1(l1,l2)
              append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
              append'1(nil(),l2) -> l2
              flatten(t) -> flatten'1(t)
              flatten'1(leaf()) -> nil()
              flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
              insert(x,l) -> insert'1(l,x)
              insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
              insert'1(nil(),x) -> dd(x,nil())
              insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
              insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
              insertionsort(l) -> insertionsort'1(l)
              insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
              insertionsort'1(nil()) -> nil()
          - Signature:
              {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
              ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2
              ,flatten#/1,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1
              ,insertionsort'1#/1} / {'0/0,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0
              ,node/3,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1
              ,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2
              ,c_31/0}
          - Obligation:
              innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
              ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
              ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
        
        Problem (S)
          - Strict DPs:
              'less#(x,y) -> c_16('compare#(x,y))
              append#(l1,l2) -> c_17(append'1#(l1,l2))
              append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
              flatten#(t) -> c_20(flatten'1#(t))
              flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
              flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
              insert#(x,l) -> c_24(insert'1#(l,x))
              insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
              insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
              insertionsort#(l) -> c_29(insertionsort'1#(l))
              insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          - Weak DPs:
              'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
              'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
              'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          - Weak TRS:
              'cklt('EQ()) -> 'false()
              'cklt('GT()) -> 'false()
              'cklt('LT()) -> 'true()
              'compare('0(),'0()) -> 'EQ()
              'compare('0(),'neg(y)) -> 'GT()
              'compare('0(),'pos(y)) -> 'LT()
              'compare('0(),'s(y)) -> 'LT()
              'compare('neg(x),'0()) -> 'LT()
              'compare('neg(x),'neg(y)) -> 'compare(y,x)
              'compare('neg(x),'pos(y)) -> 'LT()
              'compare('pos(x),'0()) -> 'GT()
              'compare('pos(x),'neg(y)) -> 'GT()
              'compare('pos(x),'pos(y)) -> 'compare(x,y)
              'compare('s(x),'0()) -> 'GT()
              'compare('s(x),'s(y)) -> 'compare(x,y)
              'less(x,y) -> 'cklt('compare(x,y))
              append(l1,l2) -> append'1(l1,l2)
              append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
              append'1(nil(),l2) -> l2
              flatten(t) -> flatten'1(t)
              flatten'1(leaf()) -> nil()
              flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
              insert(x,l) -> insert'1(l,x)
              insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
              insert'1(nil(),x) -> dd(x,nil())
              insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
              insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
              insertionsort(l) -> insertionsort'1(l)
              insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
              insertionsort'1(nil()) -> nil()
          - Signature:
              {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
              ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2
              ,flatten#/1,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1
              ,insertionsort'1#/1} / {'0/0,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0
              ,node/3,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1
              ,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2
              ,c_31/0}
          - Obligation:
              innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
              ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
              ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
** Step 6.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
        - Weak DPs:
            'less#(x,y) -> c_16('compare#(x,y))
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          2:S:'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
          
          3:S:'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
          
          4:W:'less#(x,y) -> c_16('compare#(x,y))
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
          
          5:W:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):6
          
          6:W:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
          
          7:W:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):8
          
          8:W:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):5
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):7
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):7
          
          9:W:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):7
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):13
          
          10:W:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x)):11
          
          11:W:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
             -->_2 'less#(x,y) -> c_16('compare#(x,y)):4
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):12
          
          12:W:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):10
          
          13:W:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):14
          
          14:W:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):10
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):13
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          7: flatten#(t) -> c_20(flatten'1#(t))
          8: flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                              ,append#(flatten(t1),flatten(t2))
                                              ,flatten#(t1)
                                              ,flatten#(t2))
          5: append#(l1,l2) -> c_17(append'1#(l1,l2))
          6: append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
** Step 6.a:2: SimplifyRHS WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
        - Weak DPs:
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          2:S:'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
          
          3:S:'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
          
          4:W:'less#(x,y) -> c_16('compare#(x,y))
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
          
          9:W:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):13
          
          10:W:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x)):11
          
          11:W:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
             -->_2 'less#(x,y) -> c_16('compare#(x,y)):4
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):12
          
          12:W:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):10
          
          13:W:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):14
          
          14:W:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):10
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):13
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          flattensort#(t) -> c_23(insertionsort#(flatten(t)))
** Step 6.a:3: PredecessorEstimationCP WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
        - Weak DPs:
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          3: 'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          
        Consider the set of all dependency pairs
          1: 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          2: 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          3: 'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          4: 'less#(x,y) -> c_16('compare#(x,y))
          5: flattensort#(t) -> c_23(insertionsort#(flatten(t)))
          6: insert#(x,l) -> c_24(insert'1#(l,x))
          7: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
          8: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          9: insertionsort#(l) -> c_29(insertionsort'1#(l))
          10: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2))
        SPACE(?,?)on application of the dependency pairs
          {3}
        These cover all (indirect) predecessors of dependency pairs
          {3,5}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
*** Step 6.a:3.a:1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
        - Weak DPs:
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(c_9) = {1},
          uargs(c_13) = {1},
          uargs(c_15) = {1},
          uargs(c_16) = {1},
          uargs(c_23) = {1},
          uargs(c_24) = {1},
          uargs(c_25) = {1,2},
          uargs(c_28) = {1},
          uargs(c_29) = {1},
          uargs(c_30) = {1,2}
        
        Following symbols are considered usable:
          {append,append'1,flatten,flatten'1,insert,insert'1,insert'2,insertionsort,insertionsort'1,'cklt#,'compare#
          ,'less#,append#,append'1#,flatten#,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#
          ,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = 0               
                       p('EQ) = 0               
                       p('GT) = 0               
                       p('LT) = 0               
                     p('cklt) = 0               
                  p('compare) = 0               
                    p('false) = 1               
                     p('less) = 0               
                      p('neg) = x1              
                      p('pos) = x1              
                        p('s) = 1 + x1          
                     p('true) = 0               
                    p(append) = x1 + x2         
                  p(append'1) = x1 + x2         
                        p(dd) = x1 + x2         
                   p(flatten) = x1              
                 p(flatten'1) = x1              
               p(flattensort) = 0               
                    p(insert) = x1 + x2         
                  p(insert'1) = x1 + x2         
                  p(insert'2) = x2 + x3 + x4    
             p(insertionsort) = x1              
           p(insertionsort'1) = x1              
                      p(leaf) = 0               
                       p(nil) = 0               
                      p(node) = 1 + x1 + x2 + x3
                    p('cklt#) = 0               
                 p('compare#) = x1*x2           
                    p('less#) = x1*x2           
                   p(append#) = 0               
                 p(append'1#) = 0               
                  p(flatten#) = 0               
                p(flatten'1#) = 0               
              p(flattensort#) = 1 + x1 + x1^2   
                   p(insert#) = x1 + x1*x2      
                 p(insert'1#) = x1*x2 + x2      
                 p(insert'2#) = x2 + x2*x4      
            p(insertionsort#) = x1 + x1^2       
          p(insertionsort'1#) = x1 + x1^2       
                       p(c_1) = 0               
                       p(c_2) = 0               
                       p(c_3) = 0               
                       p(c_4) = 0               
                       p(c_5) = 0               
                       p(c_6) = 0               
                       p(c_7) = 0               
                       p(c_8) = 0               
                       p(c_9) = x1              
                      p(c_10) = 0               
                      p(c_11) = 0               
                      p(c_12) = 0               
                      p(c_13) = x1              
                      p(c_14) = 0               
                      p(c_15) = x1              
                      p(c_16) = x1              
                      p(c_17) = 0               
                      p(c_18) = 0               
                      p(c_19) = 0               
                      p(c_20) = 0               
                      p(c_21) = 0               
                      p(c_22) = 0               
                      p(c_23) = 1 + x1          
                      p(c_24) = x1              
                      p(c_25) = x1 + x2         
                      p(c_26) = 0               
                      p(c_27) = 0               
                      p(c_28) = x1              
                      p(c_29) = x1              
                      p(c_30) = x1 + x2         
                      p(c_31) = 0               
        
        Following rules are strictly oriented:
        'compare#('s(x),'s(y)) = 1 + x + x*y + y     
                               > x*y                 
                               = c_15('compare#(x,y))
        
        
        Following rules are (at-least) weakly oriented:
        'compare#('neg(x),'neg(y)) =  x*y                                                  
                                   >= x*y                                                  
                                   =  c_9('compare#(y,x))                                  
        
        'compare#('pos(x),'pos(y)) =  x*y                                                  
                                   >= x*y                                                  
                                   =  c_13('compare#(x,y))                                 
        
                       'less#(x,y) =  x*y                                                  
                                   >= x*y                                                  
                                   =  c_16('compare#(x,y))                                 
        
                   flattensort#(t) =  1 + t + t^2                                          
                                   >= 1 + t + t^2                                          
                                   =  c_23(insertionsort#(flatten(t)))                     
        
                      insert#(x,l) =  l*x + x                                              
                                   >= l*x + x                                              
                                   =  c_24(insert'1#(l,x))                                 
        
             insert'1#(dd(y,ys),x) =  x + x*y + x*ys                                       
                                   >= x + x*y + x*ys                                       
                                   =  c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))       
        
         insert'2#('true(),x,y,ys) =  x + x*ys                                             
                                   >= x + x*ys                                             
                                   =  c_28(insert#(x,ys))                                  
        
                 insertionsort#(l) =  l + l^2                                              
                                   >= l + l^2                                              
                                   =  c_29(insertionsort'1#(l))                            
        
        insertionsort'1#(dd(x,xs)) =  x + 2*x*xs + x^2 + xs + xs^2                         
                                   >= x + x*xs + xs + xs^2                                 
                                   =  c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        
                     append(l1,l2) =  l1 + l2                                              
                                   >= l1 + l2                                              
                                   =  append'1(l1,l2)                                      
        
             append'1(dd(x,xs),l2) =  l2 + x + xs                                          
                                   >= l2 + x + xs                                          
                                   =  dd(x,append(xs,l2))                                  
        
                append'1(nil(),l2) =  l2                                                   
                                   >= l2                                                   
                                   =  l2                                                   
        
                        flatten(t) =  t                                                    
                                   >= t                                                    
                                   =  flatten'1(t)                                         
        
                 flatten'1(leaf()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
          flatten'1(node(l,t1,t2)) =  1 + l + t1 + t2                                      
                                   >= l + t1 + t2                                          
                                   =  append(l,append(flatten(t1),flatten(t2)))            
        
                       insert(x,l) =  l + x                                                
                                   >= l + x                                                
                                   =  insert'1(l,x)                                        
        
              insert'1(dd(y,ys),x) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  insert'2('less(y,x),x,y,ys)                          
        
                 insert'1(nil(),x) =  x                                                    
                                   >= x                                                    
                                   =  dd(x,nil())                                          
        
         insert'2('false(),x,y,ys) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  dd(x,dd(y,ys))                                       
        
          insert'2('true(),x,y,ys) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  dd(y,insert(x,ys))                                   
        
                  insertionsort(l) =  l                                                    
                                   >= l                                                    
                                   =  insertionsort'1(l)                                   
        
         insertionsort'1(dd(x,xs)) =  x + xs                                               
                                   >= x + xs                                               
                                   =  insert(x,insertionsort(xs))                          
        
            insertionsort'1(nil()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
*** Step 6.a:3.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
        - Weak DPs:
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

*** Step 6.a:3.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
        - Weak DPs:
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          2: 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          
        Consider the set of all dependency pairs
          1: 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          2: 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          3: 'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          4: 'less#(x,y) -> c_16('compare#(x,y))
          5: flattensort#(t) -> c_23(insertionsort#(flatten(t)))
          6: insert#(x,l) -> c_24(insert'1#(l,x))
          7: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
          8: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          9: insertionsort#(l) -> c_29(insertionsort'1#(l))
          10: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2))
        SPACE(?,?)on application of the dependency pairs
          {2}
        These cover all (indirect) predecessors of dependency pairs
          {2,5}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
**** Step 6.a:3.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
        - Weak DPs:
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(c_9) = {1},
          uargs(c_13) = {1},
          uargs(c_15) = {1},
          uargs(c_16) = {1},
          uargs(c_23) = {1},
          uargs(c_24) = {1},
          uargs(c_25) = {1,2},
          uargs(c_28) = {1},
          uargs(c_29) = {1},
          uargs(c_30) = {1,2}
        
        Following symbols are considered usable:
          {append,append'1,flatten,flatten'1,insert,insert'1,insert'2,insertionsort,insertionsort'1,'cklt#,'compare#
          ,'less#,append#,append'1#,flatten#,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#
          ,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = 1           
                       p('EQ) = 0           
                       p('GT) = 1           
                       p('LT) = 0           
                     p('cklt) = 0           
                  p('compare) = x1*x2 + x2  
                    p('false) = 0           
                     p('less) = x1^2        
                      p('neg) = x1          
                      p('pos) = 1 + x1      
                        p('s) = x1          
                     p('true) = 1           
                    p(append) = x1 + x2     
                  p(append'1) = x1 + x2     
                        p(dd) = x1 + x2     
                   p(flatten) = x1          
                 p(flatten'1) = x1          
               p(flattensort) = 0           
                    p(insert) = x1 + x2     
                  p(insert'1) = x1 + x2     
                  p(insert'2) = x2 + x3 + x4
             p(insertionsort) = x1          
           p(insertionsort'1) = x1          
                      p(leaf) = 0           
                       p(nil) = 0           
                      p(node) = x1 + x2 + x3
                    p('cklt#) = 0           
                 p('compare#) = x1*x2       
                    p('less#) = x1*x2       
                   p(append#) = 0           
                 p(append'1#) = 0           
                  p(flatten#) = 0           
                p(flatten'1#) = 0           
              p(flattensort#) = 1 + x1^2    
                   p(insert#) = x1*x2       
                 p(insert'1#) = x1*x2       
                 p(insert'2#) = x2*x4       
            p(insertionsort#) = 1 + x1^2    
          p(insertionsort'1#) = 1 + x1^2    
                       p(c_1) = 0           
                       p(c_2) = 0           
                       p(c_3) = 0           
                       p(c_4) = 0           
                       p(c_5) = 0           
                       p(c_6) = 0           
                       p(c_7) = 0           
                       p(c_8) = 0           
                       p(c_9) = x1          
                      p(c_10) = 0           
                      p(c_11) = 0           
                      p(c_12) = 0           
                      p(c_13) = x1          
                      p(c_14) = 0           
                      p(c_15) = x1          
                      p(c_16) = x1          
                      p(c_17) = 0           
                      p(c_18) = 0           
                      p(c_19) = 0           
                      p(c_20) = 0           
                      p(c_21) = 0           
                      p(c_22) = 0           
                      p(c_23) = x1          
                      p(c_24) = x1          
                      p(c_25) = x1 + x2     
                      p(c_26) = 0           
                      p(c_27) = 0           
                      p(c_28) = x1          
                      p(c_29) = x1          
                      p(c_30) = x1 + x2     
                      p(c_31) = 0           
        
        Following rules are strictly oriented:
        'compare#('pos(x),'pos(y)) = 1 + x + x*y + y     
                                   > x*y                 
                                   = c_13('compare#(x,y))
        
        
        Following rules are (at-least) weakly oriented:
        'compare#('neg(x),'neg(y)) =  x*y                                                  
                                   >= x*y                                                  
                                   =  c_9('compare#(y,x))                                  
        
            'compare#('s(x),'s(y)) =  x*y                                                  
                                   >= x*y                                                  
                                   =  c_15('compare#(x,y))                                 
        
                       'less#(x,y) =  x*y                                                  
                                   >= x*y                                                  
                                   =  c_16('compare#(x,y))                                 
        
                   flattensort#(t) =  1 + t^2                                              
                                   >= 1 + t^2                                              
                                   =  c_23(insertionsort#(flatten(t)))                     
        
                      insert#(x,l) =  l*x                                                  
                                   >= l*x                                                  
                                   =  c_24(insert'1#(l,x))                                 
        
             insert'1#(dd(y,ys),x) =  x*y + x*ys                                           
                                   >= x*y + x*ys                                           
                                   =  c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))       
        
         insert'2#('true(),x,y,ys) =  x*ys                                                 
                                   >= x*ys                                                 
                                   =  c_28(insert#(x,ys))                                  
        
                 insertionsort#(l) =  1 + l^2                                              
                                   >= 1 + l^2                                              
                                   =  c_29(insertionsort'1#(l))                            
        
        insertionsort'1#(dd(x,xs)) =  1 + 2*x*xs + x^2 + xs^2                              
                                   >= 1 + x*xs + xs^2                                      
                                   =  c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        
                     append(l1,l2) =  l1 + l2                                              
                                   >= l1 + l2                                              
                                   =  append'1(l1,l2)                                      
        
             append'1(dd(x,xs),l2) =  l2 + x + xs                                          
                                   >= l2 + x + xs                                          
                                   =  dd(x,append(xs,l2))                                  
        
                append'1(nil(),l2) =  l2                                                   
                                   >= l2                                                   
                                   =  l2                                                   
        
                        flatten(t) =  t                                                    
                                   >= t                                                    
                                   =  flatten'1(t)                                         
        
                 flatten'1(leaf()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
          flatten'1(node(l,t1,t2)) =  l + t1 + t2                                          
                                   >= l + t1 + t2                                          
                                   =  append(l,append(flatten(t1),flatten(t2)))            
        
                       insert(x,l) =  l + x                                                
                                   >= l + x                                                
                                   =  insert'1(l,x)                                        
        
              insert'1(dd(y,ys),x) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  insert'2('less(y,x),x,y,ys)                          
        
                 insert'1(nil(),x) =  x                                                    
                                   >= x                                                    
                                   =  dd(x,nil())                                          
        
         insert'2('false(),x,y,ys) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  dd(x,dd(y,ys))                                       
        
          insert'2('true(),x,y,ys) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  dd(y,insert(x,ys))                                   
        
                  insertionsort(l) =  l                                                    
                                   >= l                                                    
                                   =  insertionsort'1(l)                                   
        
         insertionsort'1(dd(x,xs)) =  x + xs                                               
                                   >= x + xs                                               
                                   =  insert(x,insertionsort(xs))                          
        
            insertionsort'1(nil()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
**** Step 6.a:3.b:1.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
        - Weak DPs:
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

**** Step 6.a:3.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
        - Weak DPs:
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          1: 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          
        Consider the set of all dependency pairs
          1: 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          2: 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          3: 'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          4: 'less#(x,y) -> c_16('compare#(x,y))
          5: flattensort#(t) -> c_23(insertionsort#(flatten(t)))
          6: insert#(x,l) -> c_24(insert'1#(l,x))
          7: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
          8: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          9: insertionsort#(l) -> c_29(insertionsort'1#(l))
          10: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2))
        SPACE(?,?)on application of the dependency pairs
          {1}
        These cover all (indirect) predecessors of dependency pairs
          {1,5}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
***** Step 6.a:3.b:1.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
        - Weak DPs:
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(c_9) = {1},
          uargs(c_13) = {1},
          uargs(c_15) = {1},
          uargs(c_16) = {1},
          uargs(c_23) = {1},
          uargs(c_24) = {1},
          uargs(c_25) = {1,2},
          uargs(c_28) = {1},
          uargs(c_29) = {1},
          uargs(c_30) = {1,2}
        
        Following symbols are considered usable:
          {append,append'1,flatten,flatten'1,insert,insert'1,insert'2,insertionsort,insertionsort'1,'cklt#,'compare#
          ,'less#,append#,append'1#,flatten#,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#
          ,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = 0                
                       p('EQ) = 1                
                       p('GT) = 0                
                       p('LT) = 1                
                     p('cklt) = 0                
                  p('compare) = x1               
                    p('false) = 0                
                     p('less) = 0                
                      p('neg) = 1 + x1           
                      p('pos) = 1 + x1           
                        p('s) = 1 + x1           
                     p('true) = 0                
                    p(append) = x1 + x2          
                  p(append'1) = x1 + x2          
                        p(dd) = x1 + x2          
                   p(flatten) = x1               
                 p(flatten'1) = x1               
               p(flattensort) = 0                
                    p(insert) = x1 + x2          
                  p(insert'1) = x1 + x2          
                  p(insert'2) = x2 + x3 + x4     
             p(insertionsort) = x1               
           p(insertionsort'1) = x1               
                      p(leaf) = 0                
                       p(nil) = 0                
                      p(node) = x1 + x2 + x3     
                    p('cklt#) = 0                
                 p('compare#) = x1*x2            
                    p('less#) = x1*x2            
                   p(append#) = 0                
                 p(append'1#) = 0                
                  p(flatten#) = 0                
                p(flatten'1#) = 0                
              p(flattensort#) = x1 + x1^2        
                   p(insert#) = x1 + x1*x2 + x1^2
                 p(insert'1#) = x1*x2 + x2 + x2^2
                 p(insert'2#) = x2 + x2*x4 + x2^2
            p(insertionsort#) = x1 + x1^2        
          p(insertionsort'1#) = x1 + x1^2        
                       p(c_1) = 0                
                       p(c_2) = 0                
                       p(c_3) = 0                
                       p(c_4) = 0                
                       p(c_5) = 0                
                       p(c_6) = 0                
                       p(c_7) = 0                
                       p(c_8) = 0                
                       p(c_9) = x1               
                      p(c_10) = 0                
                      p(c_11) = 0                
                      p(c_12) = 0                
                      p(c_13) = 1 + x1           
                      p(c_14) = 0                
                      p(c_15) = 1 + x1           
                      p(c_16) = x1               
                      p(c_17) = 0                
                      p(c_18) = 0                
                      p(c_19) = 0                
                      p(c_20) = 0                
                      p(c_21) = 0                
                      p(c_22) = 0                
                      p(c_23) = x1               
                      p(c_24) = x1               
                      p(c_25) = x1 + x2          
                      p(c_26) = 0                
                      p(c_27) = 0                
                      p(c_28) = x1               
                      p(c_29) = x1               
                      p(c_30) = x1 + x2          
                      p(c_31) = 0                
        
        Following rules are strictly oriented:
        'compare#('neg(x),'neg(y)) = 1 + x + x*y + y    
                                   > x*y                
                                   = c_9('compare#(y,x))
        
        
        Following rules are (at-least) weakly oriented:
        'compare#('pos(x),'pos(y)) =  1 + x + x*y + y                                      
                                   >= 1 + x*y                                              
                                   =  c_13('compare#(x,y))                                 
        
            'compare#('s(x),'s(y)) =  1 + x + x*y + y                                      
                                   >= 1 + x*y                                              
                                   =  c_15('compare#(x,y))                                 
        
                       'less#(x,y) =  x*y                                                  
                                   >= x*y                                                  
                                   =  c_16('compare#(x,y))                                 
        
                   flattensort#(t) =  t + t^2                                              
                                   >= t + t^2                                              
                                   =  c_23(insertionsort#(flatten(t)))                     
        
                      insert#(x,l) =  l*x + x + x^2                                        
                                   >= l*x + x + x^2                                        
                                   =  c_24(insert'1#(l,x))                                 
        
             insert'1#(dd(y,ys),x) =  x + x*y + x*ys + x^2                                 
                                   >= x + x*y + x*ys + x^2                                 
                                   =  c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))       
        
         insert'2#('true(),x,y,ys) =  x + x*ys + x^2                                       
                                   >= x + x*ys + x^2                                       
                                   =  c_28(insert#(x,ys))                                  
        
                 insertionsort#(l) =  l + l^2                                              
                                   >= l + l^2                                              
                                   =  c_29(insertionsort'1#(l))                            
        
        insertionsort'1#(dd(x,xs)) =  x + 2*x*xs + x^2 + xs + xs^2                         
                                   >= x + x*xs + x^2 + xs + xs^2                           
                                   =  c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        
                     append(l1,l2) =  l1 + l2                                              
                                   >= l1 + l2                                              
                                   =  append'1(l1,l2)                                      
        
             append'1(dd(x,xs),l2) =  l2 + x + xs                                          
                                   >= l2 + x + xs                                          
                                   =  dd(x,append(xs,l2))                                  
        
                append'1(nil(),l2) =  l2                                                   
                                   >= l2                                                   
                                   =  l2                                                   
        
                        flatten(t) =  t                                                    
                                   >= t                                                    
                                   =  flatten'1(t)                                         
        
                 flatten'1(leaf()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
          flatten'1(node(l,t1,t2)) =  l + t1 + t2                                          
                                   >= l + t1 + t2                                          
                                   =  append(l,append(flatten(t1),flatten(t2)))            
        
                       insert(x,l) =  l + x                                                
                                   >= l + x                                                
                                   =  insert'1(l,x)                                        
        
              insert'1(dd(y,ys),x) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  insert'2('less(y,x),x,y,ys)                          
        
                 insert'1(nil(),x) =  x                                                    
                                   >= x                                                    
                                   =  dd(x,nil())                                          
        
         insert'2('false(),x,y,ys) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  dd(x,dd(y,ys))                                       
        
          insert'2('true(),x,y,ys) =  x + y + ys                                           
                                   >= x + y + ys                                           
                                   =  dd(y,insert(x,ys))                                   
        
                  insertionsort(l) =  l                                                    
                                   >= l                                                    
                                   =  insertionsort'1(l)                                   
        
         insertionsort'1(dd(x,xs)) =  x + xs                                               
                                   >= x + xs                                               
                                   =  insert(x,insertionsort(xs))                          
        
            insertionsort'1(nil()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
***** Step 6.a:3.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

***** Step 6.a:3.b:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:W:'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          2:W:'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          3:W:'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          4:W:'less#(x,y) -> c_16('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):3
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):2
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):1
          
          5:W:flattensort#(t) -> c_23(insertionsort#(flatten(t)))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):9
          
          6:W:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x)):7
          
          7:W:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):8
             -->_2 'less#(x,y) -> c_16('compare#(x,y)):4
          
          8:W:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):6
          
          9:W:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):10
          
          10:W:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):9
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):6
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          5: flattensort#(t) -> c_23(insertionsort#(flatten(t)))
          9: insertionsort#(l) -> c_29(insertionsort'1#(l))
          10: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          6: insert#(x,l) -> c_24(insert'1#(l,x))
          8: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          7: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
          4: 'less#(x,y) -> c_16('compare#(x,y))
          1: 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          3: 'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          2: 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
***** Step 6.a:3.b:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

** Step 6.b:1: PredecessorEstimation WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            'less#(x,y) -> c_16('compare#(x,y))
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimation {onSelection = all simple predecessor estimation selector}
    + Details:
        We estimate the number of application of
          {1}
        by application of
          Pre({1}) = {8}.
        Here rules are labelled as follows:
          1: 'less#(x,y) -> c_16('compare#(x,y))
          2: append#(l1,l2) -> c_17(append'1#(l1,l2))
          3: append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          4: flatten#(t) -> c_20(flatten'1#(t))
          5: flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                              ,append#(flatten(t1),flatten(t2))
                                              ,flatten#(t1)
                                              ,flatten#(t2))
          6: flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
          7: insert#(x,l) -> c_24(insert'1#(l,x))
          8: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
          9: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          10: insertionsort#(l) -> c_29(insertionsort'1#(l))
          11: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          12: 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
          13: 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          14: 'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
** Step 6.b:2: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
            'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
            'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
            'less#(x,y) -> c_16('compare#(x,y))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):2
          
          2:S:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
          
          3:S:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):4
          
          4:S:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
          
          5:S:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):9
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):3
          
          6:S:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x)):7
          
          7:S:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
             -->_2 'less#(x,y) -> c_16('compare#(x,y)):14
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):8
          
          8:S:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):6
          
          9:S:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):10
          
          10:S:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):9
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):6
          
          11:W:'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):13
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):12
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):11
          
          12:W:'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):13
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):12
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):11
          
          13:W:'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):13
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):12
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):11
          
          14:W:'less#(x,y) -> c_16('compare#(x,y))
             -->_1 'compare#('s(x),'s(y)) -> c_15('compare#(x,y)):13
             -->_1 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y)):12
             -->_1 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x)):11
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          14: 'less#(x,y) -> c_16('compare#(x,y))
          13: 'compare#('s(x),'s(y)) -> c_15('compare#(x,y))
          12: 'compare#('pos(x),'pos(y)) -> c_13('compare#(x,y))
          11: 'compare#('neg(x),'neg(y)) -> c_9('compare#(y,x))
** Step 6.b:3: SimplifyRHS WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/2,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):2
          
          2:S:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
          
          3:S:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):4
          
          4:S:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
          
          5:S:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):9
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):3
          
          6:S:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x)):7
          
          7:S:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys),'less#(y,x))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):8
          
          8:S:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):6
          
          9:S:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):10
          
          10:S:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):9
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):6
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
** Step 6.b:4: Decompose WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd}
    + Details:
        We analyse the complexity of following sub-problems (R) and (S).
        Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component.
        
        Problem (R)
          - Strict DPs:
              append#(l1,l2) -> c_17(append'1#(l1,l2))
              append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          - Weak DPs:
              flatten#(t) -> c_20(flatten'1#(t))
              flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
              flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
              insert#(x,l) -> c_24(insert'1#(l,x))
              insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
              insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
              insertionsort#(l) -> c_29(insertionsort'1#(l))
              insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          - Weak TRS:
              'cklt('EQ()) -> 'false()
              'cklt('GT()) -> 'false()
              'cklt('LT()) -> 'true()
              'compare('0(),'0()) -> 'EQ()
              'compare('0(),'neg(y)) -> 'GT()
              'compare('0(),'pos(y)) -> 'LT()
              'compare('0(),'s(y)) -> 'LT()
              'compare('neg(x),'0()) -> 'LT()
              'compare('neg(x),'neg(y)) -> 'compare(y,x)
              'compare('neg(x),'pos(y)) -> 'LT()
              'compare('pos(x),'0()) -> 'GT()
              'compare('pos(x),'neg(y)) -> 'GT()
              'compare('pos(x),'pos(y)) -> 'compare(x,y)
              'compare('s(x),'0()) -> 'GT()
              'compare('s(x),'s(y)) -> 'compare(x,y)
              'less(x,y) -> 'cklt('compare(x,y))
              append(l1,l2) -> append'1(l1,l2)
              append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
              append'1(nil(),l2) -> l2
              flatten(t) -> flatten'1(t)
              flatten'1(leaf()) -> nil()
              flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
              insert(x,l) -> insert'1(l,x)
              insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
              insert'1(nil(),x) -> dd(x,nil())
              insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
              insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
              insertionsort(l) -> insertionsort'1(l)
              insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
              insertionsort'1(nil()) -> nil()
          - Signature:
              {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
              ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2
              ,flatten#/1,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1
              ,insertionsort'1#/1} / {'0/0,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0
              ,node/3,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1
              ,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1,c_21/0,c_22/4,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2
              ,c_31/0}
          - Obligation:
              innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
              ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
              ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
        
        Problem (S)
          - Strict DPs:
              flatten#(t) -> c_20(flatten'1#(t))
              flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
              flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
              insert#(x,l) -> c_24(insert'1#(l,x))
              insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
              insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
              insertionsort#(l) -> c_29(insertionsort'1#(l))
              insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          - Weak DPs:
              append#(l1,l2) -> c_17(append'1#(l1,l2))
              append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          - Weak TRS:
              'cklt('EQ()) -> 'false()
              'cklt('GT()) -> 'false()
              'cklt('LT()) -> 'true()
              'compare('0(),'0()) -> 'EQ()
              'compare('0(),'neg(y)) -> 'GT()
              'compare('0(),'pos(y)) -> 'LT()
              'compare('0(),'s(y)) -> 'LT()
              'compare('neg(x),'0()) -> 'LT()
              'compare('neg(x),'neg(y)) -> 'compare(y,x)
              'compare('neg(x),'pos(y)) -> 'LT()
              'compare('pos(x),'0()) -> 'GT()
              'compare('pos(x),'neg(y)) -> 'GT()
              'compare('pos(x),'pos(y)) -> 'compare(x,y)
              'compare('s(x),'0()) -> 'GT()
              'compare('s(x),'s(y)) -> 'compare(x,y)
              'less(x,y) -> 'cklt('compare(x,y))
              append(l1,l2) -> append'1(l1,l2)
              append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
              append'1(nil(),l2) -> l2
              flatten(t) -> flatten'1(t)
              flatten'1(leaf()) -> nil()
              flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
              insert(x,l) -> insert'1(l,x)
              insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
              insert'1(nil(),x) -> dd(x,nil())
              insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
              insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
              insertionsort(l) -> insertionsort'1(l)
              insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
              insertionsort'1(nil()) -> nil()
          - Signature:
              {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
              ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2
              ,flatten#/1,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1
              ,insertionsort'1#/1} / {'0/0,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0
              ,node/3,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1
              ,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1,c_21/0,c_22/4,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2
              ,c_31/0}
          - Obligation:
              innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
              ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
              ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
*** Step 6.b:4.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
        - Weak DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):2
          
          2:S:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
          
          3:W:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):4
          
          4:W:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):3
          
          5:W:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):9
          
          6:W:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys)):7
          
          7:W:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):8
          
          8:W:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):6
          
          9:W:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):10
          
          10:W:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):6
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):9
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          9: insertionsort#(l) -> c_29(insertionsort'1#(l))
          10: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          6: insert#(x,l) -> c_24(insert'1#(l,x))
          8: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          7: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
*** Step 6.b:4.a:2: SimplifyRHS WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
        - Weak DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):2
          
          2:S:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
          
          3:W:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):4
          
          4:W:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):3
          
          5:W:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):3
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          flattensort#(t) -> c_23(flatten#(t))
*** Step 6.b:4.a:3: UsableRules WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
        - Weak DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        UsableRules
    + Details:
        We replace rewrite rules by usable rules:
          append(l1,l2) -> append'1(l1,l2)
          append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
          append'1(nil(),l2) -> l2
          flatten(t) -> flatten'1(t)
          flatten'1(leaf()) -> nil()
          flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
          append#(l1,l2) -> c_17(append'1#(l1,l2))
          append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          flatten#(t) -> c_20(flatten'1#(t))
          flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                           ,append#(flatten(t1),flatten(t2))
                                           ,flatten#(t1)
                                           ,flatten#(t2))
          flattensort#(t) -> c_23(flatten#(t))
*** Step 6.b:4.a:4: PredecessorEstimationCP WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
        - Weak DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          2: append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          
        Consider the set of all dependency pairs
          1: append#(l1,l2) -> c_17(append'1#(l1,l2))
          2: append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          3: flatten#(t) -> c_20(flatten'1#(t))
          4: flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                              ,append#(flatten(t1),flatten(t2))
                                              ,flatten#(t1)
                                              ,flatten#(t2))
          5: flattensort#(t) -> c_23(flatten#(t))
        Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2))
        SPACE(?,?)on application of the dependency pairs
          {2}
        These cover all (indirect) predecessors of dependency pairs
          {2,5}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
**** Step 6.b:4.a:4.a:1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
        - Weak DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(c_17) = {1},
          uargs(c_18) = {1},
          uargs(c_20) = {1},
          uargs(c_22) = {1,2,3,4},
          uargs(c_23) = {1}
        
        Following symbols are considered usable:
          {append,append'1,flatten,flatten'1,'cklt#,'compare#,'less#,append#,append'1#,flatten#,flatten'1#
          ,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = 0                
                       p('EQ) = 0                
                       p('GT) = 0                
                       p('LT) = 0                
                     p('cklt) = 0                
                  p('compare) = 0                
                    p('false) = 0                
                     p('less) = 0                
                      p('neg) = 0                
                      p('pos) = 0                
                        p('s) = 0                
                     p('true) = 0                
                    p(append) = x1 + x2          
                  p(append'1) = x1 + x2          
                        p(dd) = 1 + x2           
                   p(flatten) = x1               
                 p(flatten'1) = x1               
               p(flattensort) = 0                
                    p(insert) = 0                
                  p(insert'1) = 0                
                  p(insert'2) = 0                
             p(insertionsort) = 0                
           p(insertionsort'1) = 0                
                      p(leaf) = 0                
                       p(nil) = 0                
                      p(node) = 1 + x1 + x2 + x3 
                    p('cklt#) = 0                
                 p('compare#) = 0                
                    p('less#) = 0                
                   p(append#) = x1               
                 p(append'1#) = x1               
                  p(flatten#) = x1^2             
                p(flatten'1#) = x1^2             
              p(flattensort#) = 1 + x1 + x1^2    
                   p(insert#) = 0                
                 p(insert'1#) = 0                
                 p(insert'2#) = 0                
            p(insertionsort#) = 0                
          p(insertionsort'1#) = 0                
                       p(c_1) = 0                
                       p(c_2) = 0                
                       p(c_3) = 0                
                       p(c_4) = 0                
                       p(c_5) = 0                
                       p(c_6) = 0                
                       p(c_7) = 0                
                       p(c_8) = 0                
                       p(c_9) = 0                
                      p(c_10) = 0                
                      p(c_11) = 0                
                      p(c_12) = 0                
                      p(c_13) = 0                
                      p(c_14) = 0                
                      p(c_15) = 0                
                      p(c_16) = 0                
                      p(c_17) = x1               
                      p(c_18) = x1               
                      p(c_19) = 0                
                      p(c_20) = x1               
                      p(c_21) = 0                
                      p(c_22) = x1 + x2 + x3 + x4
                      p(c_23) = 1 + x1           
                      p(c_24) = 0                
                      p(c_25) = 0                
                      p(c_26) = 0                
                      p(c_27) = 0                
                      p(c_28) = 0                
                      p(c_29) = 0                
                      p(c_30) = 0                
                      p(c_31) = 0                
        
        Following rules are strictly oriented:
        append'1#(dd(x,xs),l2) = 1 + xs              
                               > xs                  
                               = c_18(append#(xs,l2))
        
        
        Following rules are (at-least) weakly oriented:
                   append#(l1,l2) =  l1                                                                                                         
                                  >= l1                                                                                                         
                                  =  c_17(append'1#(l1,l2))                                                                                     
        
                      flatten#(t) =  t^2                                                                                                        
                                  >= t^2                                                                                                        
                                  =  c_20(flatten'1#(t))                                                                                        
        
        flatten'1#(node(l,t1,t2)) =  1 + 2*l + 2*l*t1 + 2*l*t2 + l^2 + 2*t1 + 2*t1*t2 + t1^2 + 2*t2 + t2^2                                      
                                  >= l + t1 + t1^2 + t2^2                                                                                       
                                  =  c_22(append#(l,append(flatten(t1),flatten(t2))),append#(flatten(t1),flatten(t2)),flatten#(t1),flatten#(t2))
        
                  flattensort#(t) =  1 + t + t^2                                                                                                
                                  >= 1 + t^2                                                                                                    
                                  =  c_23(flatten#(t))                                                                                          
        
                    append(l1,l2) =  l1 + l2                                                                                                    
                                  >= l1 + l2                                                                                                    
                                  =  append'1(l1,l2)                                                                                            
        
            append'1(dd(x,xs),l2) =  1 + l2 + xs                                                                                                
                                  >= 1 + l2 + xs                                                                                                
                                  =  dd(x,append(xs,l2))                                                                                        
        
               append'1(nil(),l2) =  l2                                                                                                         
                                  >= l2                                                                                                         
                                  =  l2                                                                                                         
        
                       flatten(t) =  t                                                                                                          
                                  >= t                                                                                                          
                                  =  flatten'1(t)                                                                                               
        
                flatten'1(leaf()) =  0                                                                                                          
                                  >= 0                                                                                                          
                                  =  nil()                                                                                                      
        
         flatten'1(node(l,t1,t2)) =  1 + l + t1 + t2                                                                                            
                                  >= l + t1 + t2                                                                                                
                                  =  append(l,append(flatten(t1),flatten(t2)))                                                                  
        
**** Step 6.b:4.a:4.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
        - Weak DPs:
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

**** Step 6.b:4.a:4.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
        - Weak DPs:
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          1: append#(l1,l2) -> c_17(append'1#(l1,l2))
          
        Consider the set of all dependency pairs
          1: append#(l1,l2) -> c_17(append'1#(l1,l2))
          2: append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
          3: flatten#(t) -> c_20(flatten'1#(t))
          4: flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                              ,append#(flatten(t1),flatten(t2))
                                              ,flatten#(t1)
                                              ,flatten#(t2))
          5: flattensort#(t) -> c_23(flatten#(t))
        Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2))
        SPACE(?,?)on application of the dependency pairs
          {1}
        These cover all (indirect) predecessors of dependency pairs
          {1,2,5}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
***** Step 6.b:4.a:4.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
        - Weak DPs:
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(c_17) = {1},
          uargs(c_18) = {1},
          uargs(c_20) = {1},
          uargs(c_22) = {1,2,3,4},
          uargs(c_23) = {1}
        
        Following symbols are considered usable:
          {append,append'1,flatten,flatten'1,'cklt#,'compare#,'less#,append#,append'1#,flatten#,flatten'1#
          ,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = 0                
                       p('EQ) = 0                
                       p('GT) = 0                
                       p('LT) = 0                
                     p('cklt) = 0                
                  p('compare) = 0                
                    p('false) = 0                
                     p('less) = 0                
                      p('neg) = 0                
                      p('pos) = 0                
                        p('s) = 0                
                     p('true) = 0                
                    p(append) = x1 + x2          
                  p(append'1) = x1 + x2          
                        p(dd) = 1 + x2           
                   p(flatten) = x1               
                 p(flatten'1) = x1               
               p(flattensort) = 0                
                    p(insert) = 0                
                  p(insert'1) = 0                
                  p(insert'2) = 0                
             p(insertionsort) = 0                
           p(insertionsort'1) = 0                
                      p(leaf) = 0                
                       p(nil) = 0                
                      p(node) = 1 + x1 + x2 + x3 
                    p('cklt#) = 0                
                 p('compare#) = 0                
                    p('less#) = 0                
                   p(append#) = 1 + x1           
                 p(append'1#) = x1               
                  p(flatten#) = x1 + x1^2        
                p(flatten'1#) = x1 + x1^2        
              p(flattensort#) = x1 + x1^2        
                   p(insert#) = 0                
                 p(insert'1#) = 0                
                 p(insert'2#) = 0                
            p(insertionsort#) = 0                
          p(insertionsort'1#) = 0                
                       p(c_1) = 0                
                       p(c_2) = 0                
                       p(c_3) = 0                
                       p(c_4) = 0                
                       p(c_5) = 0                
                       p(c_6) = 0                
                       p(c_7) = 0                
                       p(c_8) = 0                
                       p(c_9) = 0                
                      p(c_10) = 0                
                      p(c_11) = 0                
                      p(c_12) = 0                
                      p(c_13) = 0                
                      p(c_14) = 0                
                      p(c_15) = 0                
                      p(c_16) = 0                
                      p(c_17) = x1               
                      p(c_18) = x1               
                      p(c_19) = 0                
                      p(c_20) = x1               
                      p(c_21) = 0                
                      p(c_22) = x1 + x2 + x3 + x4
                      p(c_23) = x1               
                      p(c_24) = 0                
                      p(c_25) = 0                
                      p(c_26) = 0                
                      p(c_27) = 0                
                      p(c_28) = 0                
                      p(c_29) = 0                
                      p(c_30) = 0                
                      p(c_31) = 0                
        
        Following rules are strictly oriented:
        append#(l1,l2) = 1 + l1                
                       > l1                    
                       = c_17(append'1#(l1,l2))
        
        
        Following rules are (at-least) weakly oriented:
           append'1#(dd(x,xs),l2) =  1 + xs                                                                                                     
                                  >= 1 + xs                                                                                                     
                                  =  c_18(append#(xs,l2))                                                                                       
        
                      flatten#(t) =  t + t^2                                                                                                    
                                  >= t + t^2                                                                                                    
                                  =  c_20(flatten'1#(t))                                                                                        
        
        flatten'1#(node(l,t1,t2)) =  2 + 3*l + 2*l*t1 + 2*l*t2 + l^2 + 3*t1 + 2*t1*t2 + t1^2 + 3*t2 + t2^2                                      
                                  >= 2 + l + 2*t1 + t1^2 + t2 + t2^2                                                                            
                                  =  c_22(append#(l,append(flatten(t1),flatten(t2))),append#(flatten(t1),flatten(t2)),flatten#(t1),flatten#(t2))
        
                  flattensort#(t) =  t + t^2                                                                                                    
                                  >= t + t^2                                                                                                    
                                  =  c_23(flatten#(t))                                                                                          
        
                    append(l1,l2) =  l1 + l2                                                                                                    
                                  >= l1 + l2                                                                                                    
                                  =  append'1(l1,l2)                                                                                            
        
            append'1(dd(x,xs),l2) =  1 + l2 + xs                                                                                                
                                  >= 1 + l2 + xs                                                                                                
                                  =  dd(x,append(xs,l2))                                                                                        
        
               append'1(nil(),l2) =  l2                                                                                                         
                                  >= l2                                                                                                         
                                  =  l2                                                                                                         
        
                       flatten(t) =  t                                                                                                          
                                  >= t                                                                                                          
                                  =  flatten'1(t)                                                                                               
        
                flatten'1(leaf()) =  0                                                                                                          
                                  >= 0                                                                                                          
                                  =  nil()                                                                                                      
        
         flatten'1(node(l,t1,t2)) =  1 + l + t1 + t2                                                                                            
                                  >= l + t1 + t2                                                                                                
                                  =  append(l,append(flatten(t1),flatten(t2)))                                                                  
        
***** Step 6.b:4.a:4.b:1.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

***** Step 6.b:4.a:4.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:W:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):2
          
          2:W:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
          
          3:W:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):4
          
          4:W:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):3
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):1
          
          5:W:flattensort#(t) -> c_23(flatten#(t))
             -->_1 flatten#(t) -> c_20(flatten'1#(t)):3
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          5: flattensort#(t) -> c_23(flatten#(t))
          3: flatten#(t) -> c_20(flatten'1#(t))
          4: flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                              ,append#(flatten(t1),flatten(t2))
                                              ,flatten#(t1)
                                              ,flatten#(t2))
          1: append#(l1,l2) -> c_17(append'1#(l1,l2))
          2: append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
***** Step 6.b:4.a:4.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

*** Step 6.b:4.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            append#(l1,l2) -> c_17(append'1#(l1,l2))
            append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):2
          
          2:S:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_2 append#(l1,l2) -> c_17(append'1#(l1,l2)):9
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):9
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):1
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):1
          
          3:S:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):7
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):1
          
          4:S:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys)):5
          
          5:S:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):6
          
          6:S:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):4
          
          7:S:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):8
          
          8:S:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):7
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):4
          
          9:W:append#(l1,l2) -> c_17(append'1#(l1,l2))
             -->_1 append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2)):10
          
          10:W:append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
             -->_1 append#(l1,l2) -> c_17(append'1#(l1,l2)):9
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          9: append#(l1,l2) -> c_17(append'1#(l1,l2))
          10: append'1#(dd(x,xs),l2) -> c_18(append#(xs,l2))
*** Step 6.b:4.b:2: SimplifyRHS WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                             ,append#(flatten(t1),flatten(t2))
                                             ,flatten#(t1)
                                             ,flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/4,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                                    ,append#(flatten(t1),flatten(t2))
                                                    ,flatten#(t1)
                                                    ,flatten#(t2)):2
          
          2:S:flatten'1#(node(l,t1,t2)) -> c_22(append#(l,append(flatten(t1),flatten(t2)))
                                               ,append#(flatten(t1),flatten(t2))
                                               ,flatten#(t1)
                                               ,flatten#(t2))
             -->_4 flatten#(t) -> c_20(flatten'1#(t)):1
             -->_3 flatten#(t) -> c_20(flatten'1#(t)):1
          
          3:S:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):7
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):1
          
          4:S:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys)):5
          
          5:S:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):6
          
          6:S:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):4
          
          7:S:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):8
          
          8:S:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):7
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):4
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
*** Step 6.b:4.b:3: Decompose WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd}
    + Details:
        We analyse the complexity of following sub-problems (R) and (S).
        Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component.
        
        Problem (R)
          - Strict DPs:
              flatten#(t) -> c_20(flatten'1#(t))
              flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
          - Weak DPs:
              flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
              insert#(x,l) -> c_24(insert'1#(l,x))
              insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
              insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
              insertionsort#(l) -> c_29(insertionsort'1#(l))
              insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          - Weak TRS:
              'cklt('EQ()) -> 'false()
              'cklt('GT()) -> 'false()
              'cklt('LT()) -> 'true()
              'compare('0(),'0()) -> 'EQ()
              'compare('0(),'neg(y)) -> 'GT()
              'compare('0(),'pos(y)) -> 'LT()
              'compare('0(),'s(y)) -> 'LT()
              'compare('neg(x),'0()) -> 'LT()
              'compare('neg(x),'neg(y)) -> 'compare(y,x)
              'compare('neg(x),'pos(y)) -> 'LT()
              'compare('pos(x),'0()) -> 'GT()
              'compare('pos(x),'neg(y)) -> 'GT()
              'compare('pos(x),'pos(y)) -> 'compare(x,y)
              'compare('s(x),'0()) -> 'GT()
              'compare('s(x),'s(y)) -> 'compare(x,y)
              'less(x,y) -> 'cklt('compare(x,y))
              append(l1,l2) -> append'1(l1,l2)
              append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
              append'1(nil(),l2) -> l2
              flatten(t) -> flatten'1(t)
              flatten'1(leaf()) -> nil()
              flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
              insert(x,l) -> insert'1(l,x)
              insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
              insert'1(nil(),x) -> dd(x,nil())
              insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
              insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
              insertionsort(l) -> insertionsort'1(l)
              insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
              insertionsort'1(nil()) -> nil()
          - Signature:
              {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
              ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2
              ,flatten#/1,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1
              ,insertionsort'1#/1} / {'0/0,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0
              ,node/3,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1
              ,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1,c_21/0,c_22/2,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2
              ,c_31/0}
          - Obligation:
              innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
              ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
              ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
        
        Problem (S)
          - Strict DPs:
              flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
              insert#(x,l) -> c_24(insert'1#(l,x))
              insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
              insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
              insertionsort#(l) -> c_29(insertionsort'1#(l))
              insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          - Weak DPs:
              flatten#(t) -> c_20(flatten'1#(t))
              flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
          - Weak TRS:
              'cklt('EQ()) -> 'false()
              'cklt('GT()) -> 'false()
              'cklt('LT()) -> 'true()
              'compare('0(),'0()) -> 'EQ()
              'compare('0(),'neg(y)) -> 'GT()
              'compare('0(),'pos(y)) -> 'LT()
              'compare('0(),'s(y)) -> 'LT()
              'compare('neg(x),'0()) -> 'LT()
              'compare('neg(x),'neg(y)) -> 'compare(y,x)
              'compare('neg(x),'pos(y)) -> 'LT()
              'compare('pos(x),'0()) -> 'GT()
              'compare('pos(x),'neg(y)) -> 'GT()
              'compare('pos(x),'pos(y)) -> 'compare(x,y)
              'compare('s(x),'0()) -> 'GT()
              'compare('s(x),'s(y)) -> 'compare(x,y)
              'less(x,y) -> 'cklt('compare(x,y))
              append(l1,l2) -> append'1(l1,l2)
              append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
              append'1(nil(),l2) -> l2
              flatten(t) -> flatten'1(t)
              flatten'1(leaf()) -> nil()
              flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
              insert(x,l) -> insert'1(l,x)
              insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
              insert'1(nil(),x) -> dd(x,nil())
              insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
              insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
              insertionsort(l) -> insertionsort'1(l)
              insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
              insertionsort'1(nil()) -> nil()
          - Signature:
              {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
              ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2
              ,flatten#/1,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1
              ,insertionsort'1#/1} / {'0/0,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0
              ,node/3,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1
              ,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1,c_21/0,c_22/2,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2
              ,c_31/0}
          - Obligation:
              innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
              ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
              ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
**** Step 6.b:4.b:3.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2)):2
          
          2:S:flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):1
             -->_1 flatten#(t) -> c_20(flatten'1#(t)):1
          
          3:W:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):1
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):7
          
          4:W:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys)):5
          
          5:W:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):6
          
          6:W:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):4
          
          7:W:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):8
          
          8:W:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):4
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):7
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          7: insertionsort#(l) -> c_29(insertionsort'1#(l))
          8: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          4: insert#(x,l) -> c_24(insert'1#(l,x))
          6: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          5: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
**** Step 6.b:4.b:3.a:2: SimplifyRHS WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2)):2
          
          2:S:flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):1
             -->_1 flatten#(t) -> c_20(flatten'1#(t)):1
          
          3:W:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):1
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          flattensort#(t) -> c_23(flatten#(t))
**** Step 6.b:4.b:3.a:3: UsableRules WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
        - Weak DPs:
            flattensort#(t) -> c_23(flatten#(t))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        UsableRules
    + Details:
        We replace rewrite rules by usable rules:
          flatten#(t) -> c_20(flatten'1#(t))
          flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
          flattensort#(t) -> c_23(flatten#(t))
**** Step 6.b:4.b:3.a:4: PredecessorEstimationCP WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
        - Weak DPs:
            flattensort#(t) -> c_23(flatten#(t))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          2: flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
          
        Consider the set of all dependency pairs
          1: flatten#(t) -> c_20(flatten'1#(t))
          2: flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
          3: flattensort#(t) -> c_23(flatten#(t))
        Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1))
        SPACE(?,?)on application of the dependency pairs
          {2}
        These cover all (indirect) predecessors of dependency pairs
          {1,2,3}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
***** Step 6.b:4.b:3.a:4.a:1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
        - Weak DPs:
            flattensort#(t) -> c_23(flatten#(t))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          uargs(c_20) = {1},
          uargs(c_22) = {1,2},
          uargs(c_23) = {1}
        
        Following symbols are considered usable:
          {'cklt#,'compare#,'less#,append#,append'1#,flatten#,flatten'1#,flattensort#,insert#,insert'1#,insert'2#
          ,insertionsort#,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = [0]                           
                       p('EQ) = [0]                           
                       p('GT) = [0]                           
                       p('LT) = [0]                           
                     p('cklt) = [0]                           
                  p('compare) = [0]                           
                    p('false) = [0]                           
                     p('less) = [0]                           
                      p('neg) = [1] x1 + [0]                  
                      p('pos) = [1] x1 + [0]                  
                        p('s) = [1] x1 + [0]                  
                     p('true) = [1]                           
                    p(append) = [1]                           
                  p(append'1) = [2] x1 + [4]                  
                        p(dd) = [1] x2 + [0]                  
                   p(flatten) = [1]                           
                 p(flatten'1) = [1] x1 + [1]                  
               p(flattensort) = [8] x1 + [1]                  
                    p(insert) = [1] x1 + [1]                  
                  p(insert'1) = [2] x2 + [0]                  
                  p(insert'2) = [1] x1 + [1] x2 + [2] x3 + [2]
             p(insertionsort) = [0]                           
           p(insertionsort'1) = [2] x1 + [2]                  
                      p(leaf) = [2]                           
                       p(nil) = [1]                           
                      p(node) = [1] x2 + [1] x3 + [2]         
                    p('cklt#) = [0]                           
                 p('compare#) = [1] x2 + [0]                  
                    p('less#) = [2] x1 + [2] x2 + [4]         
                   p(append#) = [0]                           
                 p(append'1#) = [8] x1 + [0]                  
                  p(flatten#) = [8] x1 + [2]                  
                p(flatten'1#) = [8] x1 + [2]                  
              p(flattensort#) = [8] x1 + [3]                  
                   p(insert#) = [4] x1 + [1] x2 + [0]         
                 p(insert'1#) = [0]                           
                 p(insert'2#) = [1] x1 + [1] x2 + [4] x4 + [0]
            p(insertionsort#) = [1]                           
          p(insertionsort'1#) = [2] x1 + [1]                  
                       p(c_1) = [0]                           
                       p(c_2) = [1]                           
                       p(c_3) = [8]                           
                       p(c_4) = [1]                           
                       p(c_5) = [2]                           
                       p(c_6) = [0]                           
                       p(c_7) = [2]                           
                       p(c_8) = [1]                           
                       p(c_9) = [2]                           
                      p(c_10) = [1]                           
                      p(c_11) = [0]                           
                      p(c_12) = [0]                           
                      p(c_13) = [1] x1 + [2]                  
                      p(c_14) = [8]                           
                      p(c_15) = [2]                           
                      p(c_16) = [1]                           
                      p(c_17) = [1] x1 + [1]                  
                      p(c_18) = [1]                           
                      p(c_19) = [0]                           
                      p(c_20) = [1] x1 + [0]                  
                      p(c_21) = [0]                           
                      p(c_22) = [1] x1 + [1] x2 + [6]         
                      p(c_23) = [1] x1 + [1]                  
                      p(c_24) = [1]                           
                      p(c_25) = [8]                           
                      p(c_26) = [1]                           
                      p(c_27) = [2]                           
                      p(c_28) = [2]                           
                      p(c_29) = [8] x1 + [1]                  
                      p(c_30) = [2] x1 + [1] x2 + [1]         
                      p(c_31) = [1]                           
        
        Following rules are strictly oriented:
        flatten'1#(node(l,t1,t2)) = [8] t1 + [8] t2 + [18]         
                                  > [8] t1 + [8] t2 + [10]         
                                  = c_22(flatten#(t1),flatten#(t2))
        
        
        Following rules are (at-least) weakly oriented:
            flatten#(t) =  [8] t + [2]        
                        >= [8] t + [2]        
                        =  c_20(flatten'1#(t))
        
        flattensort#(t) =  [8] t + [3]        
                        >= [8] t + [3]        
                        =  c_23(flatten#(t))  
        
***** Step 6.b:4.b:3.a:4.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Strict DPs:
            flatten#(t) -> c_20(flatten'1#(t))
        - Weak DPs:
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

***** Step 6.b:4.b:3.a:4.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
            flattensort#(t) -> c_23(flatten#(t))
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:W:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2)):2
          
          2:W:flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):1
             -->_1 flatten#(t) -> c_20(flatten'1#(t)):1
          
          3:W:flattensort#(t) -> c_23(flatten#(t))
             -->_1 flatten#(t) -> c_20(flatten'1#(t)):1
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          3: flattensort#(t) -> c_23(flatten#(t))
          1: flatten#(t) -> c_20(flatten'1#(t))
          2: flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
***** Step 6.b:4.b:3.a:4.b:2: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

**** Step 6.b:4.b:3.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            flatten#(t) -> c_20(flatten'1#(t))
            flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):7
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):5
          
          2:S:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys)):3
          
          3:S:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):4
          
          4:S:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):2
          
          5:S:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):6
          
          6:S:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):5
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):2
          
          7:W:flatten#(t) -> c_20(flatten'1#(t))
             -->_1 flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2)):8
          
          8:W:flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
             -->_2 flatten#(t) -> c_20(flatten'1#(t)):7
             -->_1 flatten#(t) -> c_20(flatten'1#(t)):7
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          7: flatten#(t) -> c_20(flatten'1#(t))
          8: flatten'1#(node(l,t1,t2)) -> c_22(flatten#(t1),flatten#(t2))
**** Step 6.b:4.b:3.b:2: SimplifyRHS WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:flattensort#(t) -> c_23(insertionsort#(flatten(t)),flatten#(t))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):5
          
          2:S:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys)):3
          
          3:S:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):4
          
          4:S:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):2
          
          5:S:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):6
          
          6:S:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):5
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):2
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          flattensort#(t) -> c_23(insertionsort#(flatten(t)))
**** Step 6.b:4.b:3.b:3: PredecessorEstimationCP WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          3: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
          
        Consider the set of all dependency pairs
          1: flattensort#(t) -> c_23(insertionsort#(flatten(t)))
          2: insert#(x,l) -> c_24(insert'1#(l,x))
          3: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
          4: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          5: insertionsort#(l) -> c_29(insertionsort'1#(l))
          6: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2))
        SPACE(?,?)on application of the dependency pairs
          {3}
        These cover all (indirect) predecessors of dependency pairs
          {1,3,4}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
***** Step 6.b:4.b:3.b:3.a:1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(c_23) = {1},
          uargs(c_24) = {1},
          uargs(c_25) = {1},
          uargs(c_28) = {1},
          uargs(c_29) = {1},
          uargs(c_30) = {1,2}
        
        Following symbols are considered usable:
          {'cklt,'compare,'less,append,append'1,flatten,flatten'1,insert,insert'1,insert'2,insertionsort
          ,insertionsort'1,'cklt#,'compare#,'less#,append#,append'1#,flatten#,flatten'1#,flattensort#,insert#
          ,insert'1#,insert'2#,insertionsort#,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = 0               
                       p('EQ) = 1               
                       p('GT) = 1               
                       p('LT) = 1               
                     p('cklt) = x1^2            
                  p('compare) = 1               
                    p('false) = 1               
                     p('less) = 1               
                      p('neg) = 0               
                      p('pos) = 0               
                        p('s) = 0               
                     p('true) = 1               
                    p(append) = x1 + x2         
                  p(append'1) = x1 + x2         
                        p(dd) = 1 + x2          
                   p(flatten) = x1              
                 p(flatten'1) = x1              
               p(flattensort) = 0               
                    p(insert) = 1 + x2          
                  p(insert'1) = 1 + x1          
                  p(insert'2) = 1 + x1*x4 + x1^2
             p(insertionsort) = x1              
           p(insertionsort'1) = x1              
                      p(leaf) = 1               
                       p(nil) = 0               
                      p(node) = x1 + x2 + x3    
                    p('cklt#) = 0               
                 p('compare#) = 0               
                    p('less#) = 0               
                   p(append#) = 0               
                 p(append'1#) = 0               
                  p(flatten#) = 0               
                p(flatten'1#) = 0               
              p(flattensort#) = 1 + x1^2        
                   p(insert#) = x2              
                 p(insert'1#) = x1              
                 p(insert'2#) = x4              
            p(insertionsort#) = 1 + x1^2        
          p(insertionsort'1#) = x1^2            
                       p(c_1) = 0               
                       p(c_2) = 0               
                       p(c_3) = 0               
                       p(c_4) = 0               
                       p(c_5) = 0               
                       p(c_6) = 0               
                       p(c_7) = 0               
                       p(c_8) = 0               
                       p(c_9) = 0               
                      p(c_10) = 0               
                      p(c_11) = 0               
                      p(c_12) = 0               
                      p(c_13) = 0               
                      p(c_14) = 0               
                      p(c_15) = 0               
                      p(c_16) = 0               
                      p(c_17) = 0               
                      p(c_18) = 0               
                      p(c_19) = 0               
                      p(c_20) = 0               
                      p(c_21) = 0               
                      p(c_22) = 0               
                      p(c_23) = x1              
                      p(c_24) = x1              
                      p(c_25) = x1              
                      p(c_26) = 0               
                      p(c_27) = 0               
                      p(c_28) = x1              
                      p(c_29) = 1 + x1          
                      p(c_30) = x1 + x2         
                      p(c_31) = 0               
        
        Following rules are strictly oriented:
        insert'1#(dd(y,ys),x) = 1 + ys                            
                              > ys                                
                              = c_25(insert'2#('less(y,x),x,y,ys))
        
        
        Following rules are (at-least) weakly oriented:
                   flattensort#(t) =  1 + t^2                                              
                                   >= 1 + t^2                                              
                                   =  c_23(insertionsort#(flatten(t)))                     
        
                      insert#(x,l) =  l                                                    
                                   >= l                                                    
                                   =  c_24(insert'1#(l,x))                                 
        
         insert'2#('true(),x,y,ys) =  ys                                                   
                                   >= ys                                                   
                                   =  c_28(insert#(x,ys))                                  
        
                 insertionsort#(l) =  1 + l^2                                              
                                   >= 1 + l^2                                              
                                   =  c_29(insertionsort'1#(l))                            
        
        insertionsort'1#(dd(x,xs)) =  1 + 2*xs + xs^2                                      
                                   >= 1 + xs + xs^2                                        
                                   =  c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        
                      'cklt('EQ()) =  1                                                    
                                   >= 1                                                    
                                   =  'false()                                             
        
                      'cklt('GT()) =  1                                                    
                                   >= 1                                                    
                                   =  'false()                                             
        
                      'cklt('LT()) =  1                                                    
                                   >= 1                                                    
                                   =  'true()                                              
        
               'compare('0(),'0()) =  1                                                    
                                   >= 1                                                    
                                   =  'EQ()                                                
        
            'compare('0(),'neg(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'GT()                                                
        
            'compare('0(),'pos(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'LT()                                                
        
              'compare('0(),'s(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'LT()                                                
        
            'compare('neg(x),'0()) =  1                                                    
                                   >= 1                                                    
                                   =  'LT()                                                
        
         'compare('neg(x),'neg(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'compare(y,x)                                        
        
         'compare('neg(x),'pos(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'LT()                                                
        
            'compare('pos(x),'0()) =  1                                                    
                                   >= 1                                                    
                                   =  'GT()                                                
        
         'compare('pos(x),'neg(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'GT()                                                
        
         'compare('pos(x),'pos(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'compare(x,y)                                        
        
              'compare('s(x),'0()) =  1                                                    
                                   >= 1                                                    
                                   =  'GT()                                                
        
             'compare('s(x),'s(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'compare(x,y)                                        
        
                        'less(x,y) =  1                                                    
                                   >= 1                                                    
                                   =  'cklt('compare(x,y))                                 
        
                     append(l1,l2) =  l1 + l2                                              
                                   >= l1 + l2                                              
                                   =  append'1(l1,l2)                                      
        
             append'1(dd(x,xs),l2) =  1 + l2 + xs                                          
                                   >= 1 + l2 + xs                                          
                                   =  dd(x,append(xs,l2))                                  
        
                append'1(nil(),l2) =  l2                                                   
                                   >= l2                                                   
                                   =  l2                                                   
        
                        flatten(t) =  t                                                    
                                   >= t                                                    
                                   =  flatten'1(t)                                         
        
                 flatten'1(leaf()) =  1                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
          flatten'1(node(l,t1,t2)) =  l + t1 + t2                                          
                                   >= l + t1 + t2                                          
                                   =  append(l,append(flatten(t1),flatten(t2)))            
        
                       insert(x,l) =  1 + l                                                
                                   >= 1 + l                                                
                                   =  insert'1(l,x)                                        
        
              insert'1(dd(y,ys),x) =  2 + ys                                               
                                   >= 2 + ys                                               
                                   =  insert'2('less(y,x),x,y,ys)                          
        
                 insert'1(nil(),x) =  1                                                    
                                   >= 1                                                    
                                   =  dd(x,nil())                                          
        
         insert'2('false(),x,y,ys) =  2 + ys                                               
                                   >= 2 + ys                                               
                                   =  dd(x,dd(y,ys))                                       
        
          insert'2('true(),x,y,ys) =  2 + ys                                               
                                   >= 2 + ys                                               
                                   =  dd(y,insert(x,ys))                                   
        
                  insertionsort(l) =  l                                                    
                                   >= l                                                    
                                   =  insertionsort'1(l)                                   
        
         insertionsort'1(dd(x,xs)) =  1 + xs                                               
                                   >= 1 + xs                                               
                                   =  insert(x,insertionsort(xs))                          
        
            insertionsort'1(nil()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
***** Step 6.b:4.b:3.b:3.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Strict DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

***** Step 6.b:4.b:3.b:3.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            insert#(x,l) -> c_24(insert'1#(l,x))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          2: insertionsort#(l) -> c_29(insertionsort'1#(l))
          
        Consider the set of all dependency pairs
          1: insert#(x,l) -> c_24(insert'1#(l,x))
          2: insertionsort#(l) -> c_29(insertionsort'1#(l))
          3: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          4: flattensort#(t) -> c_23(insertionsort#(flatten(t)))
          5: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
          6: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
        Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1))
        SPACE(?,?)on application of the dependency pairs
          {2}
        These cover all (indirect) predecessors of dependency pairs
          {2,3,4}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
****** Step 6.b:4.b:3.b:3.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            insert#(x,l) -> c_24(insert'1#(l,x))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          uargs(c_23) = {1},
          uargs(c_24) = {1},
          uargs(c_25) = {1},
          uargs(c_28) = {1},
          uargs(c_29) = {1},
          uargs(c_30) = {1,2}
        
        Following symbols are considered usable:
          {append,append'1,flatten,flatten'1,'cklt#,'compare#,'less#,append#,append'1#,flatten#,flatten'1#
          ,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = [2]                           
                       p('EQ) = [0]                           
                       p('GT) = [4]                           
                       p('LT) = [1]                           
                     p('cklt) = [0]                           
                  p('compare) = [4] x1 + [1]                  
                    p('false) = [0]                           
                     p('less) = [3] x1 + [4] x2 + [0]         
                      p('neg) = [0]                           
                      p('pos) = [3]                           
                        p('s) = [3]                           
                     p('true) = [0]                           
                    p(append) = [1] x1 + [1] x2 + [0]         
                  p(append'1) = [1] x1 + [1] x2 + [0]         
                        p(dd) = [1] x2 + [2]                  
                   p(flatten) = [4] x1 + [0]                  
                 p(flatten'1) = [4] x1 + [0]                  
               p(flattensort) = [0]                           
                    p(insert) = [2]                           
                  p(insert'1) = [0]                           
                  p(insert'2) = [2] x1 + [1] x2 + [2] x3 + [4]
             p(insertionsort) = [0]                           
           p(insertionsort'1) = [0]                           
                      p(leaf) = [2]                           
                       p(nil) = [0]                           
                      p(node) = [1] x1 + [1] x2 + [1] x3 + [0]
                    p('cklt#) = [1] x1 + [1]                  
                 p('compare#) = [0]                           
                    p('less#) = [0]                           
                   p(append#) = [1] x1 + [4] x2 + [4]         
                 p(append'1#) = [4] x1 + [2] x2 + [2]         
                  p(flatten#) = [1] x1 + [0]                  
                p(flatten'1#) = [4]                           
              p(flattensort#) = [5] x1 + [4]                  
                   p(insert#) = [0]                           
                 p(insert'1#) = [0]                           
                 p(insert'2#) = [0]                           
            p(insertionsort#) = [1] x1 + [1]                  
          p(insertionsort'1#) = [1] x1 + [0]                  
                       p(c_1) = [0]                           
                       p(c_2) = [0]                           
                       p(c_3) = [1]                           
                       p(c_4) = [0]                           
                       p(c_5) = [0]                           
                       p(c_6) = [0]                           
                       p(c_7) = [4]                           
                       p(c_8) = [1]                           
                       p(c_9) = [0]                           
                      p(c_10) = [1]                           
                      p(c_11) = [1]                           
                      p(c_12) = [4]                           
                      p(c_13) = [2] x1 + [1]                  
                      p(c_14) = [4]                           
                      p(c_15) = [2] x1 + [0]                  
                      p(c_16) = [0]                           
                      p(c_17) = [1] x1 + [0]                  
                      p(c_18) = [2] x1 + [4]                  
                      p(c_19) = [1]                           
                      p(c_20) = [1]                           
                      p(c_21) = [1]                           
                      p(c_22) = [4]                           
                      p(c_23) = [1] x1 + [3]                  
                      p(c_24) = [2] x1 + [0]                  
                      p(c_25) = [1] x1 + [0]                  
                      p(c_26) = [1]                           
                      p(c_27) = [1]                           
                      p(c_28) = [1] x1 + [0]                  
                      p(c_29) = [1] x1 + [0]                  
                      p(c_30) = [4] x1 + [1] x2 + [1]         
                      p(c_31) = [4]                           
        
        Following rules are strictly oriented:
        insertionsort#(l) = [1] l + [1]              
                          > [1] l + [0]              
                          = c_29(insertionsort'1#(l))
        
        
        Following rules are (at-least) weakly oriented:
                   flattensort#(t) =  [5] t + [4]                                          
                                   >= [4] t + [4]                                          
                                   =  c_23(insertionsort#(flatten(t)))                     
        
                      insert#(x,l) =  [0]                                                  
                                   >= [0]                                                  
                                   =  c_24(insert'1#(l,x))                                 
        
             insert'1#(dd(y,ys),x) =  [0]                                                  
                                   >= [0]                                                  
                                   =  c_25(insert'2#('less(y,x),x,y,ys))                   
        
         insert'2#('true(),x,y,ys) =  [0]                                                  
                                   >= [0]                                                  
                                   =  c_28(insert#(x,ys))                                  
        
        insertionsort'1#(dd(x,xs)) =  [1] xs + [2]                                         
                                   >= [1] xs + [2]                                         
                                   =  c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        
                     append(l1,l2) =  [1] l1 + [1] l2 + [0]                                
                                   >= [1] l1 + [1] l2 + [0]                                
                                   =  append'1(l1,l2)                                      
        
             append'1(dd(x,xs),l2) =  [1] l2 + [1] xs + [2]                                
                                   >= [1] l2 + [1] xs + [2]                                
                                   =  dd(x,append(xs,l2))                                  
        
                append'1(nil(),l2) =  [1] l2 + [0]                                         
                                   >= [1] l2 + [0]                                         
                                   =  l2                                                   
        
                        flatten(t) =  [4] t + [0]                                          
                                   >= [4] t + [0]                                          
                                   =  flatten'1(t)                                         
        
                 flatten'1(leaf()) =  [8]                                                  
                                   >= [0]                                                  
                                   =  nil()                                                
        
          flatten'1(node(l,t1,t2)) =  [4] l + [4] t1 + [4] t2 + [0]                        
                                   >= [1] l + [4] t1 + [4] t2 + [0]                        
                                   =  append(l,append(flatten(t1),flatten(t2)))            
        
****** Step 6.b:4.b:3.b:3.b:1.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Strict DPs:
            insert#(x,l) -> c_24(insert'1#(l,x))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

****** Step 6.b:4.b:3.b:3.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            insert#(x,l) -> c_24(insert'1#(l,x))
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
    + Details:
        We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
          1: insert#(x,l) -> c_24(insert'1#(l,x))
          
        Consider the set of all dependency pairs
          1: insert#(x,l) -> c_24(insert'1#(l,x))
          2: flattensort#(t) -> c_23(insertionsort#(flatten(t)))
          3: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
          4: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          5: insertionsort#(l) -> c_29(insertionsort'1#(l))
          6: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2))
        SPACE(?,?)on application of the dependency pairs
          {1}
        These cover all (indirect) predecessors of dependency pairs
          {1,2,3,4}
        their number of applications is equally bounded.
        The dependency pairs are shifted into the weak component.
******* Step 6.b:4.b:3.b:3.b:1.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            insert#(x,l) -> c_24(insert'1#(l,x))
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(c_23) = {1},
          uargs(c_24) = {1},
          uargs(c_25) = {1},
          uargs(c_28) = {1},
          uargs(c_29) = {1},
          uargs(c_30) = {1,2}
        
        Following symbols are considered usable:
          {'cklt,'compare,'less,append,append'1,flatten,flatten'1,insert,insert'1,insert'2,insertionsort
          ,insertionsort'1,'cklt#,'compare#,'less#,append#,append'1#,flatten#,flatten'1#,flattensort#,insert#
          ,insert'1#,insert'2#,insertionsort#,insertionsort'1#}
        TcT has computed the following interpretation:
                        p('0) = 0            
                       p('EQ) = 1            
                       p('GT) = 1            
                       p('LT) = 1            
                     p('cklt) = x1^2         
                  p('compare) = 1            
                    p('false) = 1            
                     p('less) = 1            
                      p('neg) = 0            
                      p('pos) = 0            
                        p('s) = 0            
                     p('true) = 1            
                    p(append) = x1 + x2      
                  p(append'1) = x1 + x2      
                        p(dd) = 1 + x2       
                   p(flatten) = x1           
                 p(flatten'1) = x1           
               p(flattensort) = 0            
                    p(insert) = 1 + x2       
                  p(insert'1) = 1 + x1       
                  p(insert'2) = 1 + x1^2 + x4
             p(insertionsort) = x1           
           p(insertionsort'1) = x1           
                      p(leaf) = 0            
                       p(nil) = 0            
                      p(node) = x1 + x2 + x3 
                    p('cklt#) = 0            
                 p('compare#) = 0            
                    p('less#) = 0            
                   p(append#) = 0            
                 p(append'1#) = 0            
                  p(flatten#) = 0            
                p(flatten'1#) = 0            
              p(flattensort#) = x1 + x1^2    
                   p(insert#) = 1 + x2       
                 p(insert'1#) = x1           
                 p(insert'2#) = x1*x4 + x1^2 
            p(insertionsort#) = x1 + x1^2    
          p(insertionsort'1#) = x1 + x1^2    
                       p(c_1) = 0            
                       p(c_2) = 0            
                       p(c_3) = 0            
                       p(c_4) = 0            
                       p(c_5) = 0            
                       p(c_6) = 0            
                       p(c_7) = 0            
                       p(c_8) = 0            
                       p(c_9) = 0            
                      p(c_10) = 0            
                      p(c_11) = 0            
                      p(c_12) = 0            
                      p(c_13) = 0            
                      p(c_14) = 0            
                      p(c_15) = 0            
                      p(c_16) = 0            
                      p(c_17) = 0            
                      p(c_18) = 0            
                      p(c_19) = 0            
                      p(c_20) = 0            
                      p(c_21) = 0            
                      p(c_22) = 0            
                      p(c_23) = x1           
                      p(c_24) = x1           
                      p(c_25) = x1           
                      p(c_26) = 0            
                      p(c_27) = 0            
                      p(c_28) = x1           
                      p(c_29) = x1           
                      p(c_30) = x1 + x2      
                      p(c_31) = 0            
        
        Following rules are strictly oriented:
        insert#(x,l) = 1 + l               
                     > l                   
                     = c_24(insert'1#(l,x))
        
        
        Following rules are (at-least) weakly oriented:
                   flattensort#(t) =  t + t^2                                              
                                   >= t + t^2                                              
                                   =  c_23(insertionsort#(flatten(t)))                     
        
             insert'1#(dd(y,ys),x) =  1 + ys                                               
                                   >= 1 + ys                                               
                                   =  c_25(insert'2#('less(y,x),x,y,ys))                   
        
         insert'2#('true(),x,y,ys) =  1 + ys                                               
                                   >= 1 + ys                                               
                                   =  c_28(insert#(x,ys))                                  
        
                 insertionsort#(l) =  l + l^2                                              
                                   >= l + l^2                                              
                                   =  c_29(insertionsort'1#(l))                            
        
        insertionsort'1#(dd(x,xs)) =  2 + 3*xs + xs^2                                      
                                   >= 1 + 2*xs + xs^2                                      
                                   =  c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        
                      'cklt('EQ()) =  1                                                    
                                   >= 1                                                    
                                   =  'false()                                             
        
                      'cklt('GT()) =  1                                                    
                                   >= 1                                                    
                                   =  'false()                                             
        
                      'cklt('LT()) =  1                                                    
                                   >= 1                                                    
                                   =  'true()                                              
        
               'compare('0(),'0()) =  1                                                    
                                   >= 1                                                    
                                   =  'EQ()                                                
        
            'compare('0(),'neg(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'GT()                                                
        
            'compare('0(),'pos(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'LT()                                                
        
              'compare('0(),'s(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'LT()                                                
        
            'compare('neg(x),'0()) =  1                                                    
                                   >= 1                                                    
                                   =  'LT()                                                
        
         'compare('neg(x),'neg(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'compare(y,x)                                        
        
         'compare('neg(x),'pos(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'LT()                                                
        
            'compare('pos(x),'0()) =  1                                                    
                                   >= 1                                                    
                                   =  'GT()                                                
        
         'compare('pos(x),'neg(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'GT()                                                
        
         'compare('pos(x),'pos(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'compare(x,y)                                        
        
              'compare('s(x),'0()) =  1                                                    
                                   >= 1                                                    
                                   =  'GT()                                                
        
             'compare('s(x),'s(y)) =  1                                                    
                                   >= 1                                                    
                                   =  'compare(x,y)                                        
        
                        'less(x,y) =  1                                                    
                                   >= 1                                                    
                                   =  'cklt('compare(x,y))                                 
        
                     append(l1,l2) =  l1 + l2                                              
                                   >= l1 + l2                                              
                                   =  append'1(l1,l2)                                      
        
             append'1(dd(x,xs),l2) =  1 + l2 + xs                                          
                                   >= 1 + l2 + xs                                          
                                   =  dd(x,append(xs,l2))                                  
        
                append'1(nil(),l2) =  l2                                                   
                                   >= l2                                                   
                                   =  l2                                                   
        
                        flatten(t) =  t                                                    
                                   >= t                                                    
                                   =  flatten'1(t)                                         
        
                 flatten'1(leaf()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
          flatten'1(node(l,t1,t2)) =  l + t1 + t2                                          
                                   >= l + t1 + t2                                          
                                   =  append(l,append(flatten(t1),flatten(t2)))            
        
                       insert(x,l) =  1 + l                                                
                                   >= 1 + l                                                
                                   =  insert'1(l,x)                                        
        
              insert'1(dd(y,ys),x) =  2 + ys                                               
                                   >= 2 + ys                                               
                                   =  insert'2('less(y,x),x,y,ys)                          
        
                 insert'1(nil(),x) =  1                                                    
                                   >= 1                                                    
                                   =  dd(x,nil())                                          
        
         insert'2('false(),x,y,ys) =  2 + ys                                               
                                   >= 2 + ys                                               
                                   =  dd(x,dd(y,ys))                                       
        
          insert'2('true(),x,y,ys) =  2 + ys                                               
                                   >= 2 + ys                                               
                                   =  dd(y,insert(x,ys))                                   
        
                  insertionsort(l) =  l                                                    
                                   >= l                                                    
                                   =  insertionsort'1(l)                                   
        
         insertionsort'1(dd(x,xs)) =  1 + xs                                               
                                   >= 1 + xs                                               
                                   =  insert(x,insertionsort(xs))                          
        
            insertionsort'1(nil()) =  0                                                    
                                   >= 0                                                    
                                   =  nil()                                                
        
******* Step 6.b:4.b:3.b:3.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
    + Details:
        ()

******* Step 6.b:4.b:3.b:3.b:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            flattensort#(t) -> c_23(insertionsort#(flatten(t)))
            insert#(x,l) -> c_24(insert'1#(l,x))
            insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
            insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
            insertionsort#(l) -> c_29(insertionsort'1#(l))
            insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:W:flattensort#(t) -> c_23(insertionsort#(flatten(t)))
             -->_1 insertionsort#(l) -> c_29(insertionsort'1#(l)):5
          
          2:W:insert#(x,l) -> c_24(insert'1#(l,x))
             -->_1 insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys)):3
          
          3:W:insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
             -->_1 insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys)):4
          
          4:W:insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):2
          
          5:W:insertionsort#(l) -> c_29(insertionsort'1#(l))
             -->_1 insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs)):6
          
          6:W:insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
             -->_2 insertionsort#(l) -> c_29(insertionsort'1#(l)):5
             -->_1 insert#(x,l) -> c_24(insert'1#(l,x)):2
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          1: flattensort#(t) -> c_23(insertionsort#(flatten(t)))
          5: insertionsort#(l) -> c_29(insertionsort'1#(l))
          6: insertionsort'1#(dd(x,xs)) -> c_30(insert#(x,insertionsort(xs)),insertionsort#(xs))
          2: insert#(x,l) -> c_24(insert'1#(l,x))
          4: insert'2#('true(),x,y,ys) -> c_28(insert#(x,ys))
          3: insert'1#(dd(y,ys),x) -> c_25(insert'2#('less(y,x),x,y,ys))
******* Step 6.b:4.b:3.b:3.b:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            'cklt('EQ()) -> 'false()
            'cklt('GT()) -> 'false()
            'cklt('LT()) -> 'true()
            'compare('0(),'0()) -> 'EQ()
            'compare('0(),'neg(y)) -> 'GT()
            'compare('0(),'pos(y)) -> 'LT()
            'compare('0(),'s(y)) -> 'LT()
            'compare('neg(x),'0()) -> 'LT()
            'compare('neg(x),'neg(y)) -> 'compare(y,x)
            'compare('neg(x),'pos(y)) -> 'LT()
            'compare('pos(x),'0()) -> 'GT()
            'compare('pos(x),'neg(y)) -> 'GT()
            'compare('pos(x),'pos(y)) -> 'compare(x,y)
            'compare('s(x),'0()) -> 'GT()
            'compare('s(x),'s(y)) -> 'compare(x,y)
            'less(x,y) -> 'cklt('compare(x,y))
            append(l1,l2) -> append'1(l1,l2)
            append'1(dd(x,xs),l2) -> dd(x,append(xs,l2))
            append'1(nil(),l2) -> l2
            flatten(t) -> flatten'1(t)
            flatten'1(leaf()) -> nil()
            flatten'1(node(l,t1,t2)) -> append(l,append(flatten(t1),flatten(t2)))
            insert(x,l) -> insert'1(l,x)
            insert'1(dd(y,ys),x) -> insert'2('less(y,x),x,y,ys)
            insert'1(nil(),x) -> dd(x,nil())
            insert'2('false(),x,y,ys) -> dd(x,dd(y,ys))
            insert'2('true(),x,y,ys) -> dd(y,insert(x,ys))
            insertionsort(l) -> insertionsort'1(l)
            insertionsort'1(dd(x,xs)) -> insert(x,insertionsort(xs))
            insertionsort'1(nil()) -> nil()
        - Signature:
            {'cklt/1,'compare/2,'less/2,append/2,append'1/2,flatten/1,flatten'1/1,flattensort/1,insert/2,insert'1/2
            ,insert'2/4,insertionsort/1,insertionsort'1/1,'cklt#/1,'compare#/2,'less#/2,append#/2,append'1#/2,flatten#/1
            ,flatten'1#/1,flattensort#/1,insert#/2,insert'1#/2,insert'2#/4,insertionsort#/1,insertionsort'1#/1} / {'0/0
            ,'EQ/0,'GT/0,'LT/0,'false/0,'neg/1,'pos/1,'s/1,'true/0,dd/2,leaf/0,nil/0,node/3,c_1/0,c_2/0,c_3/0,c_4/0
            ,c_5/0,c_6/0,c_7/0,c_8/0,c_9/1,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/1,c_16/1,c_17/1,c_18/1,c_19/0,c_20/1
            ,c_21/0,c_22/2,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/1,c_29/1,c_30/2,c_31/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {'cklt#,'compare#,'less#,append#,append'1#,flatten#
            ,flatten'1#,flattensort#,insert#,insert'1#,insert'2#,insertionsort#,insertionsort'1#} and constructors {'0
            ,'EQ,'GT,'LT,'false,'neg,'pos,'s,'true,dd,leaf,nil,node}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^2))