We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^6)).

Strict Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , splitAndSort(@l) -> sortAll(split(@l))
  , sortAll#2(tuple#2(@vals, @key), @xs) ->
    ::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
  , quicksort#2(tuple#2(@xs, @ys), @z) ->
    append(quicksort(@xs), ::(@z, quicksort(@ys)))
  , split(@l) -> split#1(@l)
  , append(@l, @ys) -> append#1(@l, @ys)
  , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
  , insert(@x, @l) -> insert#1(@x, @l, @x)
  , sortAll(@l) -> sortAll#1(@l)
  , insert#2(nil(), @keyX, @valX, @x) ->
    ::(tuple#2(::(@valX, nil()), @keyX), nil())
  , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
    insert#3(@l1, @keyX, @ls, @valX, @x)
  , sortAll#1(nil()) -> nil()
  , sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
  , split#1(nil()) -> nil()
  , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
  , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
  , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(::(@valX, @vals1), @key1), @ls)
  , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(@vals1, @key1), insert(@x, @ls))
  , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
    insert#2(@l, @keyX, @valX, @x)
  , quicksort#1(nil()) -> nil()
  , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
  , append#1(nil(), @ys) -> @ys
  , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
  , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
  , quicksort(@l) -> quicksort#1(@l)
  , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
  , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
  , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
    splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
  , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
  , splitqs#1(::(@x, @xs), @pivot) ->
    splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
Weak Trs:
  { #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
  , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , #ckgt(#EQ()) -> #false()
  , #ckgt(#LT()) -> #false()
  , #ckgt(#GT()) -> #true()
  , #and(#true(), #true()) -> #true()
  , #and(#true(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#false(), #false()) -> #false()
  , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
  , #compare(#pos(@x), #0()) -> #GT()
  , #compare(#pos(@x), #neg(@y)) -> #GT()
  , #compare(#0(), #pos(@y)) -> #LT()
  , #compare(#0(), #0()) -> #EQ()
  , #compare(#0(), #neg(@y)) -> #GT()
  , #compare(#0(), #s(@y)) -> #LT()
  , #compare(#neg(@x), #pos(@y)) -> #LT()
  , #compare(#neg(@x), #0()) -> #LT()
  , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
  , #compare(#s(@x), #0()) -> #GT()
  , #compare(#s(@x), #s(@y)) -> #compare(@x, @y) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^6))

We add the following dependency tuples:

Strict DPs:
  { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
  , splitAndSort^#(@l) -> c_2(sortAll^#(split(@l)), split^#(@l))
  , sortAll^#(@l) -> c_9(sortAll#1^#(@l))
  , split^#(@l) -> c_5(split#1^#(@l))
  , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
    c_3(quicksort^#(@vals), sortAll^#(@xs))
  , quicksort^#(@l) -> c_25(quicksort#1^#(@l))
  , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
    c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
        quicksort^#(@xs),
        quicksort^#(@ys))
  , append^#(@l, @ys) -> c_6(append#1^#(@l, @ys))
  , split#1^#(nil()) -> c_14()
  , split#1^#(::(@x, @xs)) ->
    c_15(insert^#(@x, split(@xs)), split^#(@xs))
  , append#1^#(nil(), @ys) -> c_22()
  , append#1^#(::(@x, @xs), @ys) -> c_23(append^#(@xs, @ys))
  , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    c_7(insert#4^#(#equal(@key1, @keyX),
                   @key1,
                   @ls,
                   @valX,
                   @vals1,
                   @x),
        #equal^#(@key1, @keyX))
  , insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_17()
  , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
    c_18(insert^#(@x, @ls))
  , insert^#(@x, @l) -> c_8(insert#1^#(@x, @l, @x))
  , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
    c_19(insert#2^#(@l, @keyX, @valX, @x))
  , sortAll#1^#(nil()) -> c_12()
  , sortAll#1^#(::(@x, @xs)) -> c_13(sortAll#2^#(@x, @xs))
  , insert#2^#(nil(), @keyX, @valX, @x) -> c_10()
  , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
    c_11(insert#3^#(@l1, @keyX, @ls, @valX, @x))
  , #greater^#(@x, @y) ->
    c_16(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
  , quicksort#1^#(nil()) -> c_20()
  , quicksort#1^#(::(@z, @zs)) ->
    c_21(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
  , splitqs^#(@pivot, @l) -> c_24(splitqs#1^#(@l, @pivot))
  , splitqs#1^#(nil(), @pivot) -> c_29()
  , splitqs#1^#(::(@x, @xs), @pivot) ->
    c_30(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
         splitqs^#(@pivot, @xs))
  , splitqs#3^#(#true(), @ls, @rs, @x) -> c_26()
  , splitqs#3^#(#false(), @ls, @rs, @x) -> c_27()
  , splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
    c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
         #greater^#(@x, @pivot)) }
Weak DPs:
  { #eq^#(#pos(@x), #pos(@y)) -> c_31(#eq^#(@x, @y))
  , #eq^#(#pos(@x), #0()) -> c_32()
  , #eq^#(#pos(@x), #neg(@y)) -> c_33()
  , #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    c_34(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_35()
  , #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_36()
  , #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_37()
  , #eq^#(nil(), nil()) -> c_38()
  , #eq^#(nil(), ::(@y_1, @y_2)) -> c_39()
  , #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_40()
  , #eq^#(::(@x_1, @x_2), nil()) -> c_41()
  , #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    c_42(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(#0(), #pos(@y)) -> c_43()
  , #eq^#(#0(), #0()) -> c_44()
  , #eq^#(#0(), #neg(@y)) -> c_45()
  , #eq^#(#0(), #s(@y)) -> c_46()
  , #eq^#(#neg(@x), #pos(@y)) -> c_47()
  , #eq^#(#neg(@x), #0()) -> c_48()
  , #eq^#(#neg(@x), #neg(@y)) -> c_49(#eq^#(@x, @y))
  , #eq^#(#s(@x), #0()) -> c_50()
  , #eq^#(#s(@x), #s(@y)) -> c_51(#eq^#(@x, @y))
  , #ckgt^#(#EQ()) -> c_52()
  , #ckgt^#(#LT()) -> c_53()
  , #ckgt^#(#GT()) -> c_54()
  , #compare^#(#pos(@x), #pos(@y)) -> c_59(#compare^#(@x, @y))
  , #compare^#(#pos(@x), #0()) -> c_60()
  , #compare^#(#pos(@x), #neg(@y)) -> c_61()
  , #compare^#(#0(), #pos(@y)) -> c_62()
  , #compare^#(#0(), #0()) -> c_63()
  , #compare^#(#0(), #neg(@y)) -> c_64()
  , #compare^#(#0(), #s(@y)) -> c_65()
  , #compare^#(#neg(@x), #pos(@y)) -> c_66()
  , #compare^#(#neg(@x), #0()) -> c_67()
  , #compare^#(#neg(@x), #neg(@y)) -> c_68(#compare^#(@y, @x))
  , #compare^#(#s(@x), #0()) -> c_69()
  , #compare^#(#s(@x), #s(@y)) -> c_70(#compare^#(@x, @y))
  , #and^#(#true(), #true()) -> c_55()
  , #and^#(#true(), #false()) -> c_56()
  , #and^#(#false(), #true()) -> c_57()
  , #and^#(#false(), #false()) -> c_58() }

and mark the set of starting terms.

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^6)).

Strict DPs:
  { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
  , splitAndSort^#(@l) -> c_2(sortAll^#(split(@l)), split^#(@l))
  , sortAll^#(@l) -> c_9(sortAll#1^#(@l))
  , split^#(@l) -> c_5(split#1^#(@l))
  , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
    c_3(quicksort^#(@vals), sortAll^#(@xs))
  , quicksort^#(@l) -> c_25(quicksort#1^#(@l))
  , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
    c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
        quicksort^#(@xs),
        quicksort^#(@ys))
  , append^#(@l, @ys) -> c_6(append#1^#(@l, @ys))
  , split#1^#(nil()) -> c_14()
  , split#1^#(::(@x, @xs)) ->
    c_15(insert^#(@x, split(@xs)), split^#(@xs))
  , append#1^#(nil(), @ys) -> c_22()
  , append#1^#(::(@x, @xs), @ys) -> c_23(append^#(@xs, @ys))
  , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    c_7(insert#4^#(#equal(@key1, @keyX),
                   @key1,
                   @ls,
                   @valX,
                   @vals1,
                   @x),
        #equal^#(@key1, @keyX))
  , insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_17()
  , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
    c_18(insert^#(@x, @ls))
  , insert^#(@x, @l) -> c_8(insert#1^#(@x, @l, @x))
  , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
    c_19(insert#2^#(@l, @keyX, @valX, @x))
  , sortAll#1^#(nil()) -> c_12()
  , sortAll#1^#(::(@x, @xs)) -> c_13(sortAll#2^#(@x, @xs))
  , insert#2^#(nil(), @keyX, @valX, @x) -> c_10()
  , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
    c_11(insert#3^#(@l1, @keyX, @ls, @valX, @x))
  , #greater^#(@x, @y) ->
    c_16(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
  , quicksort#1^#(nil()) -> c_20()
  , quicksort#1^#(::(@z, @zs)) ->
    c_21(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
  , splitqs^#(@pivot, @l) -> c_24(splitqs#1^#(@l, @pivot))
  , splitqs#1^#(nil(), @pivot) -> c_29()
  , splitqs#1^#(::(@x, @xs), @pivot) ->
    c_30(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
         splitqs^#(@pivot, @xs))
  , splitqs#3^#(#true(), @ls, @rs, @x) -> c_26()
  , splitqs#3^#(#false(), @ls, @rs, @x) -> c_27()
  , splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
    c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
         #greater^#(@x, @pivot)) }
Weak DPs:
  { #eq^#(#pos(@x), #pos(@y)) -> c_31(#eq^#(@x, @y))
  , #eq^#(#pos(@x), #0()) -> c_32()
  , #eq^#(#pos(@x), #neg(@y)) -> c_33()
  , #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    c_34(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_35()
  , #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_36()
  , #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_37()
  , #eq^#(nil(), nil()) -> c_38()
  , #eq^#(nil(), ::(@y_1, @y_2)) -> c_39()
  , #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_40()
  , #eq^#(::(@x_1, @x_2), nil()) -> c_41()
  , #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    c_42(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(#0(), #pos(@y)) -> c_43()
  , #eq^#(#0(), #0()) -> c_44()
  , #eq^#(#0(), #neg(@y)) -> c_45()
  , #eq^#(#0(), #s(@y)) -> c_46()
  , #eq^#(#neg(@x), #pos(@y)) -> c_47()
  , #eq^#(#neg(@x), #0()) -> c_48()
  , #eq^#(#neg(@x), #neg(@y)) -> c_49(#eq^#(@x, @y))
  , #eq^#(#s(@x), #0()) -> c_50()
  , #eq^#(#s(@x), #s(@y)) -> c_51(#eq^#(@x, @y))
  , #ckgt^#(#EQ()) -> c_52()
  , #ckgt^#(#LT()) -> c_53()
  , #ckgt^#(#GT()) -> c_54()
  , #compare^#(#pos(@x), #pos(@y)) -> c_59(#compare^#(@x, @y))
  , #compare^#(#pos(@x), #0()) -> c_60()
  , #compare^#(#pos(@x), #neg(@y)) -> c_61()
  , #compare^#(#0(), #pos(@y)) -> c_62()
  , #compare^#(#0(), #0()) -> c_63()
  , #compare^#(#0(), #neg(@y)) -> c_64()
  , #compare^#(#0(), #s(@y)) -> c_65()
  , #compare^#(#neg(@x), #pos(@y)) -> c_66()
  , #compare^#(#neg(@x), #0()) -> c_67()
  , #compare^#(#neg(@x), #neg(@y)) -> c_68(#compare^#(@y, @x))
  , #compare^#(#s(@x), #0()) -> c_69()
  , #compare^#(#s(@x), #s(@y)) -> c_70(#compare^#(@x, @y))
  , #and^#(#true(), #true()) -> c_55()
  , #and^#(#true(), #false()) -> c_56()
  , #and^#(#false(), #true()) -> c_57()
  , #and^#(#false(), #false()) -> c_58() }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
  , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , splitAndSort(@l) -> sortAll(split(@l))
  , sortAll#2(tuple#2(@vals, @key), @xs) ->
    ::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
  , quicksort#2(tuple#2(@xs, @ys), @z) ->
    append(quicksort(@xs), ::(@z, quicksort(@ys)))
  , split(@l) -> split#1(@l)
  , append(@l, @ys) -> append#1(@l, @ys)
  , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
  , #ckgt(#EQ()) -> #false()
  , #ckgt(#LT()) -> #false()
  , #ckgt(#GT()) -> #true()
  , insert(@x, @l) -> insert#1(@x, @l, @x)
  , sortAll(@l) -> sortAll#1(@l)
  , insert#2(nil(), @keyX, @valX, @x) ->
    ::(tuple#2(::(@valX, nil()), @keyX), nil())
  , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
    insert#3(@l1, @keyX, @ls, @valX, @x)
  , #and(#true(), #true()) -> #true()
  , #and(#true(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#false(), #false()) -> #false()
  , sortAll#1(nil()) -> nil()
  , sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
  , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
  , #compare(#pos(@x), #0()) -> #GT()
  , #compare(#pos(@x), #neg(@y)) -> #GT()
  , #compare(#0(), #pos(@y)) -> #LT()
  , #compare(#0(), #0()) -> #EQ()
  , #compare(#0(), #neg(@y)) -> #GT()
  , #compare(#0(), #s(@y)) -> #LT()
  , #compare(#neg(@x), #pos(@y)) -> #LT()
  , #compare(#neg(@x), #0()) -> #LT()
  , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
  , #compare(#s(@x), #0()) -> #GT()
  , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
  , split#1(nil()) -> nil()
  , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
  , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
  , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(::(@valX, @vals1), @key1), @ls)
  , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(@vals1, @key1), insert(@x, @ls))
  , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
    insert#2(@l, @keyX, @valX, @x)
  , quicksort#1(nil()) -> nil()
  , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
  , append#1(nil(), @ys) -> @ys
  , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
  , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
  , quicksort(@l) -> quicksort#1(@l)
  , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
  , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
  , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
    splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
  , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
  , splitqs#1(::(@x, @xs), @pivot) ->
    splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^6))

We estimate the number of application of
{1,9,11,14,18,20,22,23,26,28,29} by applications of
Pre({1,9,11,14,18,20,22,23,26,28,29}) = {3,4,6,8,13,17,25,30}. Here
rules are labeled as follows:

  DPs:
    { 1: #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
    , 2: splitAndSort^#(@l) -> c_2(sortAll^#(split(@l)), split^#(@l))
    , 3: sortAll^#(@l) -> c_9(sortAll#1^#(@l))
    , 4: split^#(@l) -> c_5(split#1^#(@l))
    , 5: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
         c_3(quicksort^#(@vals), sortAll^#(@xs))
    , 6: quicksort^#(@l) -> c_25(quicksort#1^#(@l))
    , 7: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
         c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
             quicksort^#(@xs),
             quicksort^#(@ys))
    , 8: append^#(@l, @ys) -> c_6(append#1^#(@l, @ys))
    , 9: split#1^#(nil()) -> c_14()
    , 10: split#1^#(::(@x, @xs)) ->
          c_15(insert^#(@x, split(@xs)), split^#(@xs))
    , 11: append#1^#(nil(), @ys) -> c_22()
    , 12: append#1^#(::(@x, @xs), @ys) -> c_23(append^#(@xs, @ys))
    , 13: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
          c_7(insert#4^#(#equal(@key1, @keyX),
                         @key1,
                         @ls,
                         @valX,
                         @vals1,
                         @x),
              #equal^#(@key1, @keyX))
    , 14: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_17()
    , 15: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
          c_18(insert^#(@x, @ls))
    , 16: insert^#(@x, @l) -> c_8(insert#1^#(@x, @l, @x))
    , 17: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
          c_19(insert#2^#(@l, @keyX, @valX, @x))
    , 18: sortAll#1^#(nil()) -> c_12()
    , 19: sortAll#1^#(::(@x, @xs)) -> c_13(sortAll#2^#(@x, @xs))
    , 20: insert#2^#(nil(), @keyX, @valX, @x) -> c_10()
    , 21: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
          c_11(insert#3^#(@l1, @keyX, @ls, @valX, @x))
    , 22: #greater^#(@x, @y) ->
          c_16(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
    , 23: quicksort#1^#(nil()) -> c_20()
    , 24: quicksort#1^#(::(@z, @zs)) ->
          c_21(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
    , 25: splitqs^#(@pivot, @l) -> c_24(splitqs#1^#(@l, @pivot))
    , 26: splitqs#1^#(nil(), @pivot) -> c_29()
    , 27: splitqs#1^#(::(@x, @xs), @pivot) ->
          c_30(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
               splitqs^#(@pivot, @xs))
    , 28: splitqs#3^#(#true(), @ls, @rs, @x) -> c_26()
    , 29: splitqs#3^#(#false(), @ls, @rs, @x) -> c_27()
    , 30: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
          c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
               #greater^#(@x, @pivot))
    , 31: #eq^#(#pos(@x), #pos(@y)) -> c_31(#eq^#(@x, @y))
    , 32: #eq^#(#pos(@x), #0()) -> c_32()
    , 33: #eq^#(#pos(@x), #neg(@y)) -> c_33()
    , 34: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
          c_34(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
               #eq^#(@x_1, @y_1),
               #eq^#(@x_2, @y_2))
    , 35: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_35()
    , 36: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_36()
    , 37: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_37()
    , 38: #eq^#(nil(), nil()) -> c_38()
    , 39: #eq^#(nil(), ::(@y_1, @y_2)) -> c_39()
    , 40: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_40()
    , 41: #eq^#(::(@x_1, @x_2), nil()) -> c_41()
    , 42: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
          c_42(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
               #eq^#(@x_1, @y_1),
               #eq^#(@x_2, @y_2))
    , 43: #eq^#(#0(), #pos(@y)) -> c_43()
    , 44: #eq^#(#0(), #0()) -> c_44()
    , 45: #eq^#(#0(), #neg(@y)) -> c_45()
    , 46: #eq^#(#0(), #s(@y)) -> c_46()
    , 47: #eq^#(#neg(@x), #pos(@y)) -> c_47()
    , 48: #eq^#(#neg(@x), #0()) -> c_48()
    , 49: #eq^#(#neg(@x), #neg(@y)) -> c_49(#eq^#(@x, @y))
    , 50: #eq^#(#s(@x), #0()) -> c_50()
    , 51: #eq^#(#s(@x), #s(@y)) -> c_51(#eq^#(@x, @y))
    , 52: #ckgt^#(#EQ()) -> c_52()
    , 53: #ckgt^#(#LT()) -> c_53()
    , 54: #ckgt^#(#GT()) -> c_54()
    , 55: #compare^#(#pos(@x), #pos(@y)) -> c_59(#compare^#(@x, @y))
    , 56: #compare^#(#pos(@x), #0()) -> c_60()
    , 57: #compare^#(#pos(@x), #neg(@y)) -> c_61()
    , 58: #compare^#(#0(), #pos(@y)) -> c_62()
    , 59: #compare^#(#0(), #0()) -> c_63()
    , 60: #compare^#(#0(), #neg(@y)) -> c_64()
    , 61: #compare^#(#0(), #s(@y)) -> c_65()
    , 62: #compare^#(#neg(@x), #pos(@y)) -> c_66()
    , 63: #compare^#(#neg(@x), #0()) -> c_67()
    , 64: #compare^#(#neg(@x), #neg(@y)) -> c_68(#compare^#(@y, @x))
    , 65: #compare^#(#s(@x), #0()) -> c_69()
    , 66: #compare^#(#s(@x), #s(@y)) -> c_70(#compare^#(@x, @y))
    , 67: #and^#(#true(), #true()) -> c_55()
    , 68: #and^#(#true(), #false()) -> c_56()
    , 69: #and^#(#false(), #true()) -> c_57()
    , 70: #and^#(#false(), #false()) -> c_58() }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^6)).

Strict DPs:
  { splitAndSort^#(@l) -> c_2(sortAll^#(split(@l)), split^#(@l))
  , sortAll^#(@l) -> c_9(sortAll#1^#(@l))
  , split^#(@l) -> c_5(split#1^#(@l))
  , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
    c_3(quicksort^#(@vals), sortAll^#(@xs))
  , quicksort^#(@l) -> c_25(quicksort#1^#(@l))
  , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
    c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
        quicksort^#(@xs),
        quicksort^#(@ys))
  , append^#(@l, @ys) -> c_6(append#1^#(@l, @ys))
  , split#1^#(::(@x, @xs)) ->
    c_15(insert^#(@x, split(@xs)), split^#(@xs))
  , append#1^#(::(@x, @xs), @ys) -> c_23(append^#(@xs, @ys))
  , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    c_7(insert#4^#(#equal(@key1, @keyX),
                   @key1,
                   @ls,
                   @valX,
                   @vals1,
                   @x),
        #equal^#(@key1, @keyX))
  , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
    c_18(insert^#(@x, @ls))
  , insert^#(@x, @l) -> c_8(insert#1^#(@x, @l, @x))
  , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
    c_19(insert#2^#(@l, @keyX, @valX, @x))
  , sortAll#1^#(::(@x, @xs)) -> c_13(sortAll#2^#(@x, @xs))
  , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
    c_11(insert#3^#(@l1, @keyX, @ls, @valX, @x))
  , quicksort#1^#(::(@z, @zs)) ->
    c_21(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
  , splitqs^#(@pivot, @l) -> c_24(splitqs#1^#(@l, @pivot))
  , splitqs#1^#(::(@x, @xs), @pivot) ->
    c_30(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
         splitqs^#(@pivot, @xs))
  , splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
    c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
         #greater^#(@x, @pivot)) }
Weak DPs:
  { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
  , #eq^#(#pos(@x), #pos(@y)) -> c_31(#eq^#(@x, @y))
  , #eq^#(#pos(@x), #0()) -> c_32()
  , #eq^#(#pos(@x), #neg(@y)) -> c_33()
  , #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    c_34(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_35()
  , #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_36()
  , #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_37()
  , #eq^#(nil(), nil()) -> c_38()
  , #eq^#(nil(), ::(@y_1, @y_2)) -> c_39()
  , #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_40()
  , #eq^#(::(@x_1, @x_2), nil()) -> c_41()
  , #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    c_42(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(#0(), #pos(@y)) -> c_43()
  , #eq^#(#0(), #0()) -> c_44()
  , #eq^#(#0(), #neg(@y)) -> c_45()
  , #eq^#(#0(), #s(@y)) -> c_46()
  , #eq^#(#neg(@x), #pos(@y)) -> c_47()
  , #eq^#(#neg(@x), #0()) -> c_48()
  , #eq^#(#neg(@x), #neg(@y)) -> c_49(#eq^#(@x, @y))
  , #eq^#(#s(@x), #0()) -> c_50()
  , #eq^#(#s(@x), #s(@y)) -> c_51(#eq^#(@x, @y))
  , split#1^#(nil()) -> c_14()
  , append#1^#(nil(), @ys) -> c_22()
  , insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_17()
  , sortAll#1^#(nil()) -> c_12()
  , insert#2^#(nil(), @keyX, @valX, @x) -> c_10()
  , #greater^#(@x, @y) ->
    c_16(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
  , #ckgt^#(#EQ()) -> c_52()
  , #ckgt^#(#LT()) -> c_53()
  , #ckgt^#(#GT()) -> c_54()
  , #compare^#(#pos(@x), #pos(@y)) -> c_59(#compare^#(@x, @y))
  , #compare^#(#pos(@x), #0()) -> c_60()
  , #compare^#(#pos(@x), #neg(@y)) -> c_61()
  , #compare^#(#0(), #pos(@y)) -> c_62()
  , #compare^#(#0(), #0()) -> c_63()
  , #compare^#(#0(), #neg(@y)) -> c_64()
  , #compare^#(#0(), #s(@y)) -> c_65()
  , #compare^#(#neg(@x), #pos(@y)) -> c_66()
  , #compare^#(#neg(@x), #0()) -> c_67()
  , #compare^#(#neg(@x), #neg(@y)) -> c_68(#compare^#(@y, @x))
  , #compare^#(#s(@x), #0()) -> c_69()
  , #compare^#(#s(@x), #s(@y)) -> c_70(#compare^#(@x, @y))
  , quicksort#1^#(nil()) -> c_20()
  , splitqs#1^#(nil(), @pivot) -> c_29()
  , splitqs#3^#(#true(), @ls, @rs, @x) -> c_26()
  , splitqs#3^#(#false(), @ls, @rs, @x) -> c_27()
  , #and^#(#true(), #true()) -> c_55()
  , #and^#(#true(), #false()) -> c_56()
  , #and^#(#false(), #true()) -> c_57()
  , #and^#(#false(), #false()) -> c_58() }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
  , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , splitAndSort(@l) -> sortAll(split(@l))
  , sortAll#2(tuple#2(@vals, @key), @xs) ->
    ::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
  , quicksort#2(tuple#2(@xs, @ys), @z) ->
    append(quicksort(@xs), ::(@z, quicksort(@ys)))
  , split(@l) -> split#1(@l)
  , append(@l, @ys) -> append#1(@l, @ys)
  , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
  , #ckgt(#EQ()) -> #false()
  , #ckgt(#LT()) -> #false()
  , #ckgt(#GT()) -> #true()
  , insert(@x, @l) -> insert#1(@x, @l, @x)
  , sortAll(@l) -> sortAll#1(@l)
  , insert#2(nil(), @keyX, @valX, @x) ->
    ::(tuple#2(::(@valX, nil()), @keyX), nil())
  , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
    insert#3(@l1, @keyX, @ls, @valX, @x)
  , #and(#true(), #true()) -> #true()
  , #and(#true(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#false(), #false()) -> #false()
  , sortAll#1(nil()) -> nil()
  , sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
  , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
  , #compare(#pos(@x), #0()) -> #GT()
  , #compare(#pos(@x), #neg(@y)) -> #GT()
  , #compare(#0(), #pos(@y)) -> #LT()
  , #compare(#0(), #0()) -> #EQ()
  , #compare(#0(), #neg(@y)) -> #GT()
  , #compare(#0(), #s(@y)) -> #LT()
  , #compare(#neg(@x), #pos(@y)) -> #LT()
  , #compare(#neg(@x), #0()) -> #LT()
  , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
  , #compare(#s(@x), #0()) -> #GT()
  , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
  , split#1(nil()) -> nil()
  , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
  , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
  , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(::(@valX, @vals1), @key1), @ls)
  , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(@vals1, @key1), insert(@x, @ls))
  , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
    insert#2(@l, @keyX, @valX, @x)
  , quicksort#1(nil()) -> nil()
  , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
  , append#1(nil(), @ys) -> @ys
  , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
  , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
  , quicksort(@l) -> quicksort#1(@l)
  , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
  , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
  , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
    splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
  , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
  , splitqs#1(::(@x, @xs), @pivot) ->
    splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^6))

We estimate the number of application of {19} by applications of
Pre({19}) = {18}. Here rules are labeled as follows:

  DPs:
    { 1: splitAndSort^#(@l) -> c_2(sortAll^#(split(@l)), split^#(@l))
    , 2: sortAll^#(@l) -> c_9(sortAll#1^#(@l))
    , 3: split^#(@l) -> c_5(split#1^#(@l))
    , 4: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
         c_3(quicksort^#(@vals), sortAll^#(@xs))
    , 5: quicksort^#(@l) -> c_25(quicksort#1^#(@l))
    , 6: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
         c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
             quicksort^#(@xs),
             quicksort^#(@ys))
    , 7: append^#(@l, @ys) -> c_6(append#1^#(@l, @ys))
    , 8: split#1^#(::(@x, @xs)) ->
         c_15(insert^#(@x, split(@xs)), split^#(@xs))
    , 9: append#1^#(::(@x, @xs), @ys) -> c_23(append^#(@xs, @ys))
    , 10: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
          c_7(insert#4^#(#equal(@key1, @keyX),
                         @key1,
                         @ls,
                         @valX,
                         @vals1,
                         @x),
              #equal^#(@key1, @keyX))
    , 11: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
          c_18(insert^#(@x, @ls))
    , 12: insert^#(@x, @l) -> c_8(insert#1^#(@x, @l, @x))
    , 13: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
          c_19(insert#2^#(@l, @keyX, @valX, @x))
    , 14: sortAll#1^#(::(@x, @xs)) -> c_13(sortAll#2^#(@x, @xs))
    , 15: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
          c_11(insert#3^#(@l1, @keyX, @ls, @valX, @x))
    , 16: quicksort#1^#(::(@z, @zs)) ->
          c_21(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
    , 17: splitqs^#(@pivot, @l) -> c_24(splitqs#1^#(@l, @pivot))
    , 18: splitqs#1^#(::(@x, @xs), @pivot) ->
          c_30(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
               splitqs^#(@pivot, @xs))
    , 19: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
          c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
               #greater^#(@x, @pivot))
    , 20: #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
    , 21: #eq^#(#pos(@x), #pos(@y)) -> c_31(#eq^#(@x, @y))
    , 22: #eq^#(#pos(@x), #0()) -> c_32()
    , 23: #eq^#(#pos(@x), #neg(@y)) -> c_33()
    , 24: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
          c_34(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
               #eq^#(@x_1, @y_1),
               #eq^#(@x_2, @y_2))
    , 25: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_35()
    , 26: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_36()
    , 27: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_37()
    , 28: #eq^#(nil(), nil()) -> c_38()
    , 29: #eq^#(nil(), ::(@y_1, @y_2)) -> c_39()
    , 30: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_40()
    , 31: #eq^#(::(@x_1, @x_2), nil()) -> c_41()
    , 32: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
          c_42(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
               #eq^#(@x_1, @y_1),
               #eq^#(@x_2, @y_2))
    , 33: #eq^#(#0(), #pos(@y)) -> c_43()
    , 34: #eq^#(#0(), #0()) -> c_44()
    , 35: #eq^#(#0(), #neg(@y)) -> c_45()
    , 36: #eq^#(#0(), #s(@y)) -> c_46()
    , 37: #eq^#(#neg(@x), #pos(@y)) -> c_47()
    , 38: #eq^#(#neg(@x), #0()) -> c_48()
    , 39: #eq^#(#neg(@x), #neg(@y)) -> c_49(#eq^#(@x, @y))
    , 40: #eq^#(#s(@x), #0()) -> c_50()
    , 41: #eq^#(#s(@x), #s(@y)) -> c_51(#eq^#(@x, @y))
    , 42: split#1^#(nil()) -> c_14()
    , 43: append#1^#(nil(), @ys) -> c_22()
    , 44: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_17()
    , 45: sortAll#1^#(nil()) -> c_12()
    , 46: insert#2^#(nil(), @keyX, @valX, @x) -> c_10()
    , 47: #greater^#(@x, @y) ->
          c_16(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
    , 48: #ckgt^#(#EQ()) -> c_52()
    , 49: #ckgt^#(#LT()) -> c_53()
    , 50: #ckgt^#(#GT()) -> c_54()
    , 51: #compare^#(#pos(@x), #pos(@y)) -> c_59(#compare^#(@x, @y))
    , 52: #compare^#(#pos(@x), #0()) -> c_60()
    , 53: #compare^#(#pos(@x), #neg(@y)) -> c_61()
    , 54: #compare^#(#0(), #pos(@y)) -> c_62()
    , 55: #compare^#(#0(), #0()) -> c_63()
    , 56: #compare^#(#0(), #neg(@y)) -> c_64()
    , 57: #compare^#(#0(), #s(@y)) -> c_65()
    , 58: #compare^#(#neg(@x), #pos(@y)) -> c_66()
    , 59: #compare^#(#neg(@x), #0()) -> c_67()
    , 60: #compare^#(#neg(@x), #neg(@y)) -> c_68(#compare^#(@y, @x))
    , 61: #compare^#(#s(@x), #0()) -> c_69()
    , 62: #compare^#(#s(@x), #s(@y)) -> c_70(#compare^#(@x, @y))
    , 63: quicksort#1^#(nil()) -> c_20()
    , 64: splitqs#1^#(nil(), @pivot) -> c_29()
    , 65: splitqs#3^#(#true(), @ls, @rs, @x) -> c_26()
    , 66: splitqs#3^#(#false(), @ls, @rs, @x) -> c_27()
    , 67: #and^#(#true(), #true()) -> c_55()
    , 68: #and^#(#true(), #false()) -> c_56()
    , 69: #and^#(#false(), #true()) -> c_57()
    , 70: #and^#(#false(), #false()) -> c_58() }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^6)).

Strict DPs:
  { splitAndSort^#(@l) -> c_2(sortAll^#(split(@l)), split^#(@l))
  , sortAll^#(@l) -> c_9(sortAll#1^#(@l))
  , split^#(@l) -> c_5(split#1^#(@l))
  , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
    c_3(quicksort^#(@vals), sortAll^#(@xs))
  , quicksort^#(@l) -> c_25(quicksort#1^#(@l))
  , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
    c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
        quicksort^#(@xs),
        quicksort^#(@ys))
  , append^#(@l, @ys) -> c_6(append#1^#(@l, @ys))
  , split#1^#(::(@x, @xs)) ->
    c_15(insert^#(@x, split(@xs)), split^#(@xs))
  , append#1^#(::(@x, @xs), @ys) -> c_23(append^#(@xs, @ys))
  , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    c_7(insert#4^#(#equal(@key1, @keyX),
                   @key1,
                   @ls,
                   @valX,
                   @vals1,
                   @x),
        #equal^#(@key1, @keyX))
  , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
    c_18(insert^#(@x, @ls))
  , insert^#(@x, @l) -> c_8(insert#1^#(@x, @l, @x))
  , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
    c_19(insert#2^#(@l, @keyX, @valX, @x))
  , sortAll#1^#(::(@x, @xs)) -> c_13(sortAll#2^#(@x, @xs))
  , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
    c_11(insert#3^#(@l1, @keyX, @ls, @valX, @x))
  , quicksort#1^#(::(@z, @zs)) ->
    c_21(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
  , splitqs^#(@pivot, @l) -> c_24(splitqs#1^#(@l, @pivot))
  , splitqs#1^#(::(@x, @xs), @pivot) ->
    c_30(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
         splitqs^#(@pivot, @xs)) }
Weak DPs:
  { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
  , #eq^#(#pos(@x), #pos(@y)) -> c_31(#eq^#(@x, @y))
  , #eq^#(#pos(@x), #0()) -> c_32()
  , #eq^#(#pos(@x), #neg(@y)) -> c_33()
  , #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    c_34(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_35()
  , #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_36()
  , #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_37()
  , #eq^#(nil(), nil()) -> c_38()
  , #eq^#(nil(), ::(@y_1, @y_2)) -> c_39()
  , #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_40()
  , #eq^#(::(@x_1, @x_2), nil()) -> c_41()
  , #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    c_42(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(#0(), #pos(@y)) -> c_43()
  , #eq^#(#0(), #0()) -> c_44()
  , #eq^#(#0(), #neg(@y)) -> c_45()
  , #eq^#(#0(), #s(@y)) -> c_46()
  , #eq^#(#neg(@x), #pos(@y)) -> c_47()
  , #eq^#(#neg(@x), #0()) -> c_48()
  , #eq^#(#neg(@x), #neg(@y)) -> c_49(#eq^#(@x, @y))
  , #eq^#(#s(@x), #0()) -> c_50()
  , #eq^#(#s(@x), #s(@y)) -> c_51(#eq^#(@x, @y))
  , split#1^#(nil()) -> c_14()
  , append#1^#(nil(), @ys) -> c_22()
  , insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_17()
  , sortAll#1^#(nil()) -> c_12()
  , insert#2^#(nil(), @keyX, @valX, @x) -> c_10()
  , #greater^#(@x, @y) ->
    c_16(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
  , #ckgt^#(#EQ()) -> c_52()
  , #ckgt^#(#LT()) -> c_53()
  , #ckgt^#(#GT()) -> c_54()
  , #compare^#(#pos(@x), #pos(@y)) -> c_59(#compare^#(@x, @y))
  , #compare^#(#pos(@x), #0()) -> c_60()
  , #compare^#(#pos(@x), #neg(@y)) -> c_61()
  , #compare^#(#0(), #pos(@y)) -> c_62()
  , #compare^#(#0(), #0()) -> c_63()
  , #compare^#(#0(), #neg(@y)) -> c_64()
  , #compare^#(#0(), #s(@y)) -> c_65()
  , #compare^#(#neg(@x), #pos(@y)) -> c_66()
  , #compare^#(#neg(@x), #0()) -> c_67()
  , #compare^#(#neg(@x), #neg(@y)) -> c_68(#compare^#(@y, @x))
  , #compare^#(#s(@x), #0()) -> c_69()
  , #compare^#(#s(@x), #s(@y)) -> c_70(#compare^#(@x, @y))
  , quicksort#1^#(nil()) -> c_20()
  , splitqs#1^#(nil(), @pivot) -> c_29()
  , splitqs#3^#(#true(), @ls, @rs, @x) -> c_26()
  , splitqs#3^#(#false(), @ls, @rs, @x) -> c_27()
  , splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
    c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
         #greater^#(@x, @pivot))
  , #and^#(#true(), #true()) -> c_55()
  , #and^#(#true(), #false()) -> c_56()
  , #and^#(#false(), #true()) -> c_57()
  , #and^#(#false(), #false()) -> c_58() }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
  , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , splitAndSort(@l) -> sortAll(split(@l))
  , sortAll#2(tuple#2(@vals, @key), @xs) ->
    ::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
  , quicksort#2(tuple#2(@xs, @ys), @z) ->
    append(quicksort(@xs), ::(@z, quicksort(@ys)))
  , split(@l) -> split#1(@l)
  , append(@l, @ys) -> append#1(@l, @ys)
  , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
  , #ckgt(#EQ()) -> #false()
  , #ckgt(#LT()) -> #false()
  , #ckgt(#GT()) -> #true()
  , insert(@x, @l) -> insert#1(@x, @l, @x)
  , sortAll(@l) -> sortAll#1(@l)
  , insert#2(nil(), @keyX, @valX, @x) ->
    ::(tuple#2(::(@valX, nil()), @keyX), nil())
  , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
    insert#3(@l1, @keyX, @ls, @valX, @x)
  , #and(#true(), #true()) -> #true()
  , #and(#true(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#false(), #false()) -> #false()
  , sortAll#1(nil()) -> nil()
  , sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
  , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
  , #compare(#pos(@x), #0()) -> #GT()
  , #compare(#pos(@x), #neg(@y)) -> #GT()
  , #compare(#0(), #pos(@y)) -> #LT()
  , #compare(#0(), #0()) -> #EQ()
  , #compare(#0(), #neg(@y)) -> #GT()
  , #compare(#0(), #s(@y)) -> #LT()
  , #compare(#neg(@x), #pos(@y)) -> #LT()
  , #compare(#neg(@x), #0()) -> #LT()
  , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
  , #compare(#s(@x), #0()) -> #GT()
  , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
  , split#1(nil()) -> nil()
  , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
  , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
  , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(::(@valX, @vals1), @key1), @ls)
  , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(@vals1, @key1), insert(@x, @ls))
  , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
    insert#2(@l, @keyX, @valX, @x)
  , quicksort#1(nil()) -> nil()
  , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
  , append#1(nil(), @ys) -> @ys
  , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
  , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
  , quicksort(@l) -> quicksort#1(@l)
  , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
  , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
  , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
    splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
  , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
  , splitqs#1(::(@x, @xs), @pivot) ->
    splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^6))

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
, #eq^#(#pos(@x), #pos(@y)) -> c_31(#eq^#(@x, @y))
, #eq^#(#pos(@x), #0()) -> c_32()
, #eq^#(#pos(@x), #neg(@y)) -> c_33()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
  c_34(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
       #eq^#(@x_1, @y_1),
       #eq^#(@x_2, @y_2))
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_35()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_36()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_37()
, #eq^#(nil(), nil()) -> c_38()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_39()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_40()
, #eq^#(::(@x_1, @x_2), nil()) -> c_41()
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
  c_42(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
       #eq^#(@x_1, @y_1),
       #eq^#(@x_2, @y_2))
, #eq^#(#0(), #pos(@y)) -> c_43()
, #eq^#(#0(), #0()) -> c_44()
, #eq^#(#0(), #neg(@y)) -> c_45()
, #eq^#(#0(), #s(@y)) -> c_46()
, #eq^#(#neg(@x), #pos(@y)) -> c_47()
, #eq^#(#neg(@x), #0()) -> c_48()
, #eq^#(#neg(@x), #neg(@y)) -> c_49(#eq^#(@x, @y))
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> c_51(#eq^#(@x, @y))
, split#1^#(nil()) -> c_14()
, append#1^#(nil(), @ys) -> c_22()
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_17()
, sortAll#1^#(nil()) -> c_12()
, insert#2^#(nil(), @keyX, @valX, @x) -> c_10()
, #greater^#(@x, @y) ->
  c_16(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, #ckgt^#(#EQ()) -> c_52()
, #ckgt^#(#LT()) -> c_53()
, #ckgt^#(#GT()) -> c_54()
, #compare^#(#pos(@x), #pos(@y)) -> c_59(#compare^#(@x, @y))
, #compare^#(#pos(@x), #0()) -> c_60()
, #compare^#(#pos(@x), #neg(@y)) -> c_61()
, #compare^#(#0(), #pos(@y)) -> c_62()
, #compare^#(#0(), #0()) -> c_63()
, #compare^#(#0(), #neg(@y)) -> c_64()
, #compare^#(#0(), #s(@y)) -> c_65()
, #compare^#(#neg(@x), #pos(@y)) -> c_66()
, #compare^#(#neg(@x), #0()) -> c_67()
, #compare^#(#neg(@x), #neg(@y)) -> c_68(#compare^#(@y, @x))
, #compare^#(#s(@x), #0()) -> c_69()
, #compare^#(#s(@x), #s(@y)) -> c_70(#compare^#(@x, @y))
, quicksort#1^#(nil()) -> c_20()
, splitqs#1^#(nil(), @pivot) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_26()
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_27()
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
  c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
       #greater^#(@x, @pivot))
, #and^#(#true(), #true()) -> c_55()
, #and^#(#true(), #false()) -> c_56()
, #and^#(#false(), #true()) -> c_57()
, #and^#(#false(), #false()) -> c_58() }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^6)).

Strict DPs:
  { splitAndSort^#(@l) -> c_2(sortAll^#(split(@l)), split^#(@l))
  , sortAll^#(@l) -> c_9(sortAll#1^#(@l))
  , split^#(@l) -> c_5(split#1^#(@l))
  , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
    c_3(quicksort^#(@vals), sortAll^#(@xs))
  , quicksort^#(@l) -> c_25(quicksort#1^#(@l))
  , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
    c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
        quicksort^#(@xs),
        quicksort^#(@ys))
  , append^#(@l, @ys) -> c_6(append#1^#(@l, @ys))
  , split#1^#(::(@x, @xs)) ->
    c_15(insert^#(@x, split(@xs)), split^#(@xs))
  , append#1^#(::(@x, @xs), @ys) -> c_23(append^#(@xs, @ys))
  , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    c_7(insert#4^#(#equal(@key1, @keyX),
                   @key1,
                   @ls,
                   @valX,
                   @vals1,
                   @x),
        #equal^#(@key1, @keyX))
  , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
    c_18(insert^#(@x, @ls))
  , insert^#(@x, @l) -> c_8(insert#1^#(@x, @l, @x))
  , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
    c_19(insert#2^#(@l, @keyX, @valX, @x))
  , sortAll#1^#(::(@x, @xs)) -> c_13(sortAll#2^#(@x, @xs))
  , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
    c_11(insert#3^#(@l1, @keyX, @ls, @valX, @x))
  , quicksort#1^#(::(@z, @zs)) ->
    c_21(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
  , splitqs^#(@pivot, @l) -> c_24(splitqs#1^#(@l, @pivot))
  , splitqs#1^#(::(@x, @xs), @pivot) ->
    c_30(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
         splitqs^#(@pivot, @xs)) }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
  , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , splitAndSort(@l) -> sortAll(split(@l))
  , sortAll#2(tuple#2(@vals, @key), @xs) ->
    ::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
  , quicksort#2(tuple#2(@xs, @ys), @z) ->
    append(quicksort(@xs), ::(@z, quicksort(@ys)))
  , split(@l) -> split#1(@l)
  , append(@l, @ys) -> append#1(@l, @ys)
  , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
  , #ckgt(#EQ()) -> #false()
  , #ckgt(#LT()) -> #false()
  , #ckgt(#GT()) -> #true()
  , insert(@x, @l) -> insert#1(@x, @l, @x)
  , sortAll(@l) -> sortAll#1(@l)
  , insert#2(nil(), @keyX, @valX, @x) ->
    ::(tuple#2(::(@valX, nil()), @keyX), nil())
  , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
    insert#3(@l1, @keyX, @ls, @valX, @x)
  , #and(#true(), #true()) -> #true()
  , #and(#true(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#false(), #false()) -> #false()
  , sortAll#1(nil()) -> nil()
  , sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
  , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
  , #compare(#pos(@x), #0()) -> #GT()
  , #compare(#pos(@x), #neg(@y)) -> #GT()
  , #compare(#0(), #pos(@y)) -> #LT()
  , #compare(#0(), #0()) -> #EQ()
  , #compare(#0(), #neg(@y)) -> #GT()
  , #compare(#0(), #s(@y)) -> #LT()
  , #compare(#neg(@x), #pos(@y)) -> #LT()
  , #compare(#neg(@x), #0()) -> #LT()
  , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
  , #compare(#s(@x), #0()) -> #GT()
  , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
  , split#1(nil()) -> nil()
  , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
  , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
  , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(::(@valX, @vals1), @key1), @ls)
  , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(@vals1, @key1), insert(@x, @ls))
  , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
    insert#2(@l, @keyX, @valX, @x)
  , quicksort#1(nil()) -> nil()
  , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
  , append#1(nil(), @ys) -> @ys
  , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
  , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
  , quicksort(@l) -> quicksort#1(@l)
  , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
  , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
  , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
    splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
  , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
  , splitqs#1(::(@x, @xs), @pivot) ->
    splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^6))

Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:

  { insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    c_7(insert#4^#(#equal(@key1, @keyX),
                   @key1,
                   @ls,
                   @valX,
                   @vals1,
                   @x),
        #equal^#(@key1, @keyX))
  , splitqs#1^#(::(@x, @xs), @pivot) ->
    c_30(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
         splitqs^#(@pivot, @xs)) }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^6)).

Strict DPs:
  { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
  , sortAll^#(@l) -> c_2(sortAll#1^#(@l))
  , split^#(@l) -> c_3(split#1^#(@l))
  , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
    c_4(quicksort^#(@vals), sortAll^#(@xs))
  , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
  , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
    c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
        quicksort^#(@xs),
        quicksort^#(@ys))
  , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
  , split#1^#(::(@x, @xs)) ->
    c_8(insert^#(@x, split(@xs)), split^#(@xs))
  , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
  , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    c_10(insert#4^#(#equal(@key1, @keyX),
                    @key1,
                    @ls,
                    @valX,
                    @vals1,
                    @x))
  , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
    c_11(insert^#(@x, @ls))
  , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
  , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
    c_13(insert#2^#(@l, @keyX, @valX, @x))
  , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
  , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
    c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x))
  , quicksort#1^#(::(@z, @zs)) ->
    c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
  , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
  , splitqs#1^#(::(@x, @xs), @pivot) ->
    c_18(splitqs^#(@pivot, @xs)) }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
  , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , splitAndSort(@l) -> sortAll(split(@l))
  , sortAll#2(tuple#2(@vals, @key), @xs) ->
    ::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
  , quicksort#2(tuple#2(@xs, @ys), @z) ->
    append(quicksort(@xs), ::(@z, quicksort(@ys)))
  , split(@l) -> split#1(@l)
  , append(@l, @ys) -> append#1(@l, @ys)
  , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
  , #ckgt(#EQ()) -> #false()
  , #ckgt(#LT()) -> #false()
  , #ckgt(#GT()) -> #true()
  , insert(@x, @l) -> insert#1(@x, @l, @x)
  , sortAll(@l) -> sortAll#1(@l)
  , insert#2(nil(), @keyX, @valX, @x) ->
    ::(tuple#2(::(@valX, nil()), @keyX), nil())
  , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
    insert#3(@l1, @keyX, @ls, @valX, @x)
  , #and(#true(), #true()) -> #true()
  , #and(#true(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#false(), #false()) -> #false()
  , sortAll#1(nil()) -> nil()
  , sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
  , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
  , #compare(#pos(@x), #0()) -> #GT()
  , #compare(#pos(@x), #neg(@y)) -> #GT()
  , #compare(#0(), #pos(@y)) -> #LT()
  , #compare(#0(), #0()) -> #EQ()
  , #compare(#0(), #neg(@y)) -> #GT()
  , #compare(#0(), #s(@y)) -> #LT()
  , #compare(#neg(@x), #pos(@y)) -> #LT()
  , #compare(#neg(@x), #0()) -> #LT()
  , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
  , #compare(#s(@x), #0()) -> #GT()
  , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
  , split#1(nil()) -> nil()
  , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
  , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
  , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(::(@valX, @vals1), @key1), @ls)
  , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(@vals1, @key1), insert(@x, @ls))
  , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
    insert#2(@l, @keyX, @valX, @x)
  , quicksort#1(nil()) -> nil()
  , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
  , append#1(nil(), @ys) -> @ys
  , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
  , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
  , quicksort(@l) -> quicksort#1(@l)
  , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
  , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
  , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
    splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
  , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
  , splitqs#1(::(@x, @xs), @pivot) ->
    splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^6))

We replace rewrite rules by usable rules:

  Weak Usable Rules:
    { #equal(@x, @y) -> #eq(@x, @y)
    , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
    , #eq(#pos(@x), #0()) -> #false()
    , #eq(#pos(@x), #neg(@y)) -> #false()
    , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
      #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
    , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
    , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
    , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
    , #eq(nil(), nil()) -> #true()
    , #eq(nil(), ::(@y_1, @y_2)) -> #false()
    , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
    , #eq(::(@x_1, @x_2), nil()) -> #false()
    , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
      #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
    , #eq(#0(), #pos(@y)) -> #false()
    , #eq(#0(), #0()) -> #true()
    , #eq(#0(), #neg(@y)) -> #false()
    , #eq(#0(), #s(@y)) -> #false()
    , #eq(#neg(@x), #pos(@y)) -> #false()
    , #eq(#neg(@x), #0()) -> #false()
    , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
    , #eq(#s(@x), #0()) -> #false()
    , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
    , quicksort#2(tuple#2(@xs, @ys), @z) ->
      append(quicksort(@xs), ::(@z, quicksort(@ys)))
    , split(@l) -> split#1(@l)
    , append(@l, @ys) -> append#1(@l, @ys)
    , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
      insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
    , #ckgt(#EQ()) -> #false()
    , #ckgt(#LT()) -> #false()
    , #ckgt(#GT()) -> #true()
    , insert(@x, @l) -> insert#1(@x, @l, @x)
    , insert#2(nil(), @keyX, @valX, @x) ->
      ::(tuple#2(::(@valX, nil()), @keyX), nil())
    , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
      insert#3(@l1, @keyX, @ls, @valX, @x)
    , #and(#true(), #true()) -> #true()
    , #and(#true(), #false()) -> #false()
    , #and(#false(), #true()) -> #false()
    , #and(#false(), #false()) -> #false()
    , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
    , #compare(#pos(@x), #0()) -> #GT()
    , #compare(#pos(@x), #neg(@y)) -> #GT()
    , #compare(#0(), #pos(@y)) -> #LT()
    , #compare(#0(), #0()) -> #EQ()
    , #compare(#0(), #neg(@y)) -> #GT()
    , #compare(#0(), #s(@y)) -> #LT()
    , #compare(#neg(@x), #pos(@y)) -> #LT()
    , #compare(#neg(@x), #0()) -> #LT()
    , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
    , #compare(#s(@x), #0()) -> #GT()
    , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
    , split#1(nil()) -> nil()
    , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
    , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
    , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
      ::(tuple#2(::(@valX, @vals1), @key1), @ls)
    , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
      ::(tuple#2(@vals1, @key1), insert(@x, @ls))
    , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
      insert#2(@l, @keyX, @valX, @x)
    , quicksort#1(nil()) -> nil()
    , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
    , append#1(nil(), @ys) -> @ys
    , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
    , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
    , quicksort(@l) -> quicksort#1(@l)
    , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
    , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
    , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
      splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
    , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
    , splitqs#1(::(@x, @xs), @pivot) ->
      splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^6)).

Strict DPs:
  { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
  , sortAll^#(@l) -> c_2(sortAll#1^#(@l))
  , split^#(@l) -> c_3(split#1^#(@l))
  , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
    c_4(quicksort^#(@vals), sortAll^#(@xs))
  , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
  , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
    c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
        quicksort^#(@xs),
        quicksort^#(@ys))
  , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
  , split#1^#(::(@x, @xs)) ->
    c_8(insert^#(@x, split(@xs)), split^#(@xs))
  , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
  , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    c_10(insert#4^#(#equal(@key1, @keyX),
                    @key1,
                    @ls,
                    @valX,
                    @vals1,
                    @x))
  , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
    c_11(insert^#(@x, @ls))
  , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
  , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
    c_13(insert#2^#(@l, @keyX, @valX, @x))
  , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
  , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
    c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x))
  , quicksort#1^#(::(@z, @zs)) ->
    c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
  , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
  , splitqs#1^#(::(@x, @xs), @pivot) ->
    c_18(splitqs^#(@pivot, @xs)) }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
  , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , quicksort#2(tuple#2(@xs, @ys), @z) ->
    append(quicksort(@xs), ::(@z, quicksort(@ys)))
  , split(@l) -> split#1(@l)
  , append(@l, @ys) -> append#1(@l, @ys)
  , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
    insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
  , #ckgt(#EQ()) -> #false()
  , #ckgt(#LT()) -> #false()
  , #ckgt(#GT()) -> #true()
  , insert(@x, @l) -> insert#1(@x, @l, @x)
  , insert#2(nil(), @keyX, @valX, @x) ->
    ::(tuple#2(::(@valX, nil()), @keyX), nil())
  , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
    insert#3(@l1, @keyX, @ls, @valX, @x)
  , #and(#true(), #true()) -> #true()
  , #and(#true(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#false(), #false()) -> #false()
  , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
  , #compare(#pos(@x), #0()) -> #GT()
  , #compare(#pos(@x), #neg(@y)) -> #GT()
  , #compare(#0(), #pos(@y)) -> #LT()
  , #compare(#0(), #0()) -> #EQ()
  , #compare(#0(), #neg(@y)) -> #GT()
  , #compare(#0(), #s(@y)) -> #LT()
  , #compare(#neg(@x), #pos(@y)) -> #LT()
  , #compare(#neg(@x), #0()) -> #LT()
  , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
  , #compare(#s(@x), #0()) -> #GT()
  , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
  , split#1(nil()) -> nil()
  , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
  , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
  , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(::(@valX, @vals1), @key1), @ls)
  , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
    ::(tuple#2(@vals1, @key1), insert(@x, @ls))
  , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
    insert#2(@l, @keyX, @valX, @x)
  , quicksort#1(nil()) -> nil()
  , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
  , append#1(nil(), @ys) -> @ys
  , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
  , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
  , quicksort(@l) -> quicksort#1(@l)
  , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
  , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
  , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
    splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
  , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
  , splitqs#1(::(@x, @xs), @pivot) ->
    splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^6))

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:
    { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
    , split^#(@l) -> c_3(split#1^#(@l))
    , split#1^#(::(@x, @xs)) ->
      c_8(insert^#(@x, split(@xs)), split^#(@xs))
    , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
      c_10(insert#4^#(#equal(@key1, @keyX),
                      @key1,
                      @ls,
                      @valX,
                      @vals1,
                      @x))
    , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
      c_11(insert^#(@x, @ls))
    , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
    , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
      c_13(insert#2^#(@l, @keyX, @valX, @x))
    , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
      c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
  Weak DPs:
    { sortAll^#(@l) -> c_2(sortAll#1^#(@l))
    , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
      c_4(quicksort^#(@vals), sortAll^#(@xs))
    , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
    , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
      c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
          quicksort^#(@xs),
          quicksort^#(@ys))
    , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
    , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
    , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
    , quicksort#1^#(::(@z, @zs)) ->
      c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
    , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
    , splitqs#1^#(::(@x, @xs), @pivot) ->
      c_18(splitqs^#(@pivot, @xs)) }
  Weak Trs:
    { #equal(@x, @y) -> #eq(@x, @y)
    , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
    , #eq(#pos(@x), #0()) -> #false()
    , #eq(#pos(@x), #neg(@y)) -> #false()
    , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
      #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
    , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
    , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
    , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
    , #eq(nil(), nil()) -> #true()
    , #eq(nil(), ::(@y_1, @y_2)) -> #false()
    , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
    , #eq(::(@x_1, @x_2), nil()) -> #false()
    , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
      #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
    , #eq(#0(), #pos(@y)) -> #false()
    , #eq(#0(), #0()) -> #true()
    , #eq(#0(), #neg(@y)) -> #false()
    , #eq(#0(), #s(@y)) -> #false()
    , #eq(#neg(@x), #pos(@y)) -> #false()
    , #eq(#neg(@x), #0()) -> #false()
    , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
    , #eq(#s(@x), #0()) -> #false()
    , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
    , quicksort#2(tuple#2(@xs, @ys), @z) ->
      append(quicksort(@xs), ::(@z, quicksort(@ys)))
    , split(@l) -> split#1(@l)
    , append(@l, @ys) -> append#1(@l, @ys)
    , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
      insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
    , #ckgt(#EQ()) -> #false()
    , #ckgt(#LT()) -> #false()
    , #ckgt(#GT()) -> #true()
    , insert(@x, @l) -> insert#1(@x, @l, @x)
    , insert#2(nil(), @keyX, @valX, @x) ->
      ::(tuple#2(::(@valX, nil()), @keyX), nil())
    , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
      insert#3(@l1, @keyX, @ls, @valX, @x)
    , #and(#true(), #true()) -> #true()
    , #and(#true(), #false()) -> #false()
    , #and(#false(), #true()) -> #false()
    , #and(#false(), #false()) -> #false()
    , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
    , #compare(#pos(@x), #0()) -> #GT()
    , #compare(#pos(@x), #neg(@y)) -> #GT()
    , #compare(#0(), #pos(@y)) -> #LT()
    , #compare(#0(), #0()) -> #EQ()
    , #compare(#0(), #neg(@y)) -> #GT()
    , #compare(#0(), #s(@y)) -> #LT()
    , #compare(#neg(@x), #pos(@y)) -> #LT()
    , #compare(#neg(@x), #0()) -> #LT()
    , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
    , #compare(#s(@x), #0()) -> #GT()
    , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
    , split#1(nil()) -> nil()
    , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
    , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
    , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
      ::(tuple#2(::(@valX, @vals1), @key1), @ls)
    , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
      ::(tuple#2(@vals1, @key1), insert(@x, @ls))
    , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
      insert#2(@l, @keyX, @valX, @x)
    , quicksort#1(nil()) -> nil()
    , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
    , append#1(nil(), @ys) -> @ys
    , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
    , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
    , quicksort(@l) -> quicksort#1(@l)
    , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
    , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
    , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
      splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
    , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
    , splitqs#1(::(@x, @xs), @pivot) ->
      splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
  StartTerms: basic terms
  Strategy: innermost

Problem (S):
------------
  Strict DPs:
    { sortAll^#(@l) -> c_2(sortAll#1^#(@l))
    , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
      c_4(quicksort^#(@vals), sortAll^#(@xs))
    , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
    , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
      c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
          quicksort^#(@xs),
          quicksort^#(@ys))
    , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
    , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
    , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
    , quicksort#1^#(::(@z, @zs)) ->
      c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
    , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
    , splitqs#1^#(::(@x, @xs), @pivot) ->
      c_18(splitqs^#(@pivot, @xs)) }
  Weak DPs:
    { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
    , split^#(@l) -> c_3(split#1^#(@l))
    , split#1^#(::(@x, @xs)) ->
      c_8(insert^#(@x, split(@xs)), split^#(@xs))
    , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
      c_10(insert#4^#(#equal(@key1, @keyX),
                      @key1,
                      @ls,
                      @valX,
                      @vals1,
                      @x))
    , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
      c_11(insert^#(@x, @ls))
    , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
    , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
      c_13(insert#2^#(@l, @keyX, @valX, @x))
    , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
      c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
  Weak Trs:
    { #equal(@x, @y) -> #eq(@x, @y)
    , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
    , #eq(#pos(@x), #0()) -> #false()
    , #eq(#pos(@x), #neg(@y)) -> #false()
    , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
      #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
    , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
    , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
    , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
    , #eq(nil(), nil()) -> #true()
    , #eq(nil(), ::(@y_1, @y_2)) -> #false()
    , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
    , #eq(::(@x_1, @x_2), nil()) -> #false()
    , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
      #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
    , #eq(#0(), #pos(@y)) -> #false()
    , #eq(#0(), #0()) -> #true()
    , #eq(#0(), #neg(@y)) -> #false()
    , #eq(#0(), #s(@y)) -> #false()
    , #eq(#neg(@x), #pos(@y)) -> #false()
    , #eq(#neg(@x), #0()) -> #false()
    , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
    , #eq(#s(@x), #0()) -> #false()
    , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
    , quicksort#2(tuple#2(@xs, @ys), @z) ->
      append(quicksort(@xs), ::(@z, quicksort(@ys)))
    , split(@l) -> split#1(@l)
    , append(@l, @ys) -> append#1(@l, @ys)
    , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
      insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
    , #ckgt(#EQ()) -> #false()
    , #ckgt(#LT()) -> #false()
    , #ckgt(#GT()) -> #true()
    , insert(@x, @l) -> insert#1(@x, @l, @x)
    , insert#2(nil(), @keyX, @valX, @x) ->
      ::(tuple#2(::(@valX, nil()), @keyX), nil())
    , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
      insert#3(@l1, @keyX, @ls, @valX, @x)
    , #and(#true(), #true()) -> #true()
    , #and(#true(), #false()) -> #false()
    , #and(#false(), #true()) -> #false()
    , #and(#false(), #false()) -> #false()
    , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
    , #compare(#pos(@x), #0()) -> #GT()
    , #compare(#pos(@x), #neg(@y)) -> #GT()
    , #compare(#0(), #pos(@y)) -> #LT()
    , #compare(#0(), #0()) -> #EQ()
    , #compare(#0(), #neg(@y)) -> #GT()
    , #compare(#0(), #s(@y)) -> #LT()
    , #compare(#neg(@x), #pos(@y)) -> #LT()
    , #compare(#neg(@x), #0()) -> #LT()
    , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
    , #compare(#s(@x), #0()) -> #GT()
    , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
    , split#1(nil()) -> nil()
    , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
    , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
    , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
      ::(tuple#2(::(@valX, @vals1), @key1), @ls)
    , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
      ::(tuple#2(@vals1, @key1), insert(@x, @ls))
    , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
      insert#2(@l, @keyX, @valX, @x)
    , quicksort#1(nil()) -> nil()
    , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
    , append#1(nil(), @ys) -> @ys
    , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
    , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
    , quicksort(@l) -> quicksort#1(@l)
    , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
    , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
    , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
      splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
    , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
    , splitqs#1(::(@x, @xs), @pivot) ->
      splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
  StartTerms: basic terms
  Strategy: innermost

Overall, the transformation results in the following sub-problem(s):

Generated new problems:
-----------------------
R) Strict DPs:
     { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
     , split^#(@l) -> c_3(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_8(insert^#(@x, split(@xs)), split^#(@xs))
     , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_10(insert#4^#(#equal(@key1, @keyX),
                       @key1,
                       @ls,
                       @valX,
                       @vals1,
                       @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_11(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_13(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak DPs:
     { sortAll^#(@l) -> c_2(sortAll#1^#(@l))
     , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
       c_4(quicksort^#(@vals), sortAll^#(@xs))
     , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
     , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
     , quicksort#1^#(::(@z, @zs)) ->
       c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
     , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_18(splitqs^#(@pivot, @xs)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   StartTerms: basic terms
   Strategy: innermost
   
   This problem was proven YES(O(1),O(n^2)).

S) Strict DPs:
     { sortAll^#(@l) -> c_2(sortAll#1^#(@l))
     , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
       c_4(quicksort^#(@vals), sortAll^#(@xs))
     , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
     , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
     , quicksort#1^#(::(@z, @zs)) ->
       c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
     , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_18(splitqs^#(@pivot, @xs)) }
   Weak DPs:
     { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
     , split^#(@l) -> c_3(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_8(insert^#(@x, split(@xs)), split^#(@xs))
     , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_10(insert#4^#(#equal(@key1, @keyX),
                       @key1,
                       @ls,
                       @valX,
                       @vals1,
                       @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_11(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_13(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   StartTerms: basic terms
   Strategy: innermost
   
   This problem was proven YES(O(1),O(n^6)).


Proofs for generated problems:
------------------------------
R) We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^2)).
   
   Strict DPs:
     { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
     , split^#(@l) -> c_3(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_8(insert^#(@x, split(@xs)), split^#(@xs))
     , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_10(insert#4^#(#equal(@key1, @keyX),
                       @key1,
                       @ls,
                       @valX,
                       @vals1,
                       @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_11(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_13(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak DPs:
     { sortAll^#(@l) -> c_2(sortAll#1^#(@l))
     , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
       c_4(quicksort^#(@vals), sortAll^#(@xs))
     , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
     , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
     , quicksort#1^#(::(@z, @zs)) ->
       c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
     , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_18(splitqs^#(@pivot, @xs)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^2))
   
   The following weak DPs constitute a sub-graph of the DG that is
   closed under successors. The DPs are removed.
   
   { sortAll^#(@l) -> c_2(sortAll#1^#(@l))
   , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
     c_4(quicksort^#(@vals), sortAll^#(@xs))
   , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
   , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
     c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
         quicksort^#(@xs),
         quicksort^#(@ys))
   , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
   , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
   , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
   , quicksort#1^#(::(@z, @zs)) ->
     c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
   , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
   , splitqs#1^#(::(@x, @xs), @pivot) ->
     c_18(splitqs^#(@pivot, @xs)) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^2)).
   
   Strict DPs:
     { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
     , split^#(@l) -> c_3(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_8(insert^#(@x, split(@xs)), split^#(@xs))
     , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_10(insert#4^#(#equal(@key1, @keyX),
                       @key1,
                       @ls,
                       @valX,
                       @vals1,
                       @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_11(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_13(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^2))
   
   Due to missing edges in the dependency-graph, the right-hand sides
   of following rules could be simplified:
   
     { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l)) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^2)).
   
   Strict DPs:
     { splitAndSort^#(@l) -> c_1(split^#(@l))
     , split^#(@l) -> c_2(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_3(insert^#(@x, split(@xs)), split^#(@xs))
     , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_4(insert#4^#(#equal(@key1, @keyX),
                      @key1,
                      @ls,
                      @valX,
                      @vals1,
                      @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_5(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_6(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_7(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^2))
   
   We replace rewrite rules by usable rules:
   
     Weak Usable Rules:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , split(@l) -> split#1(@l)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^2)).
   
   Strict DPs:
     { splitAndSort^#(@l) -> c_1(split^#(@l))
     , split^#(@l) -> c_2(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_3(insert^#(@x, split(@xs)), split^#(@xs))
     , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_4(insert#4^#(#equal(@key1, @keyX),
                      @key1,
                      @ls,
                      @valX,
                      @vals1,
                      @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_5(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_6(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_7(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , split(@l) -> split#1(@l)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^2))
   
   We decompose the input problem according to the dependency graph
   into the upper component
   
     { splitAndSort^#(@l) -> c_1(split^#(@l))
     , split^#(@l) -> c_2(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_3(insert^#(@x, split(@xs)), split^#(@xs)) }
   
   and lower component
   
     { insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_4(insert#4^#(#equal(@key1, @keyX),
                      @key1,
                      @ls,
                      @valX,
                      @vals1,
                      @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_5(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_6(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_7(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   
   Further, following extension rules are added to the lower
   component.
   
   { splitAndSort^#(@l) -> split^#(@l)
   , split^#(@l) -> split#1^#(@l)
   , split#1^#(::(@x, @xs)) -> split^#(@xs)
   , split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs)) }
   
   TcT solves the upper component with certificate YES(O(1),O(n^1)).
   
   Sub-proof:
   ----------
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { splitAndSort^#(@l) -> c_1(split^#(@l))
       , split^#(@l) -> c_2(split#1^#(@l))
       , split#1^#(::(@x, @xs)) ->
         c_3(insert^#(@x, split(@xs)), split^#(@xs)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , split(@l) -> split#1(@l)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We use the processor 'matrix interpretation of dimension 1' to
     orient following rules strictly.
     
     DPs:
       { 1: splitAndSort^#(@l) -> c_1(split^#(@l))
       , 3: split#1^#(::(@x, @xs)) ->
            c_3(insert^#(@x, split(@xs)), split^#(@xs)) }
     Trs: { split(@l) -> split#1(@l) }
     
     Sub-proof:
     ----------
       The following argument positions are usable:
         Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1, 2}
       
       TcT has computed the following constructor-based matrix
       interpretation satisfying not(EDA).
       
                           [#equal](x1, x2) = [0]                  
                                                                   
                              [#eq](x1, x2) = [0]                  
                                                                   
                                [split](x1) = [1]                  
                                                                   
                                    [#true] = [0]                  
                                                                   
             [insert#3](x1, x2, x3, x4, x5) = [4] x5 + [0]         
                                                                   
                           [insert](x1, x2) = [0]                  
                                                                   
                                 [#pos](x1) = [1] x1 + [0]         
                                                                   
                 [insert#2](x1, x2, x3, x4) = [2] x2 + [6] x3 + [0]
                                                                   
                             [#and](x1, x2) = [0]                  
                                                                   
                          [tuple#2](x1, x2) = [1] x1 + [0]         
                                                                   
                                      [nil] = [0]                  
                                                                   
                              [split#1](x1) = [0]                  
                                                                   
         [insert#4](x1, x2, x3, x4, x5, x6) = [1] x2 + [5] x5 + [0]
                                                                   
                     [insert#1](x1, x2, x3) = [1] x3 + [0]         
                                                                   
                                   [#false] = [0]                  
                                                                   
                               [::](x1, x2) = [1] x1 + [1] x2 + [4]
                                                                   
                                       [#0] = [0]                  
                                                                   
                                 [#neg](x1) = [1] x1 + [0]         
                                                                   
                                   [#s](x1) = [1] x1 + [0]         
                                                                   
                       [splitAndSort^#](x1) = [7] x1 + [7]         
                                                                   
                              [split^#](x1) = [1] x1 + [0]         
                                                                   
                            [split#1^#](x1) = [1] x1 + [0]         
                                                                   
                         [insert^#](x1, x2) = [0]                  
                                                                   
                                  [c_1](x1) = [4] x1 + [4]         
                                                                   
                                  [c_2](x1) = [1] x1 + [0]         
                                                                   
                              [c_3](x1, x2) = [5] x1 + [1] x2 + [1]
       
       The order satisfies the following ordering constraints:
       
                                                  [#equal(@x, @y)] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                         [#eq(#pos(@x), #pos(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                             [#eq(#pos(@x), #0())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#pos(@x), #neg(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                   [#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                     
                                 [#eq(tuple#2(@x_1, @x_2), nil())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                        [#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                 [#eq(nil(), tuple#2(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                               [#eq(nil(), nil())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                      [#eq(nil(), ::(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                        [#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                      [#eq(::(@x_1, @x_2), nil())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                             [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                     
                                             [#eq(#0(), #pos(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                 [#eq(#0(), #0())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                             [#eq(#0(), #neg(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                               [#eq(#0(), #s(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#neg(@x), #pos(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                             [#eq(#neg(@x), #0())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#neg(@x), #neg(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                               [#eq(#s(@x), #0())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                             [#eq(#s(@x), #s(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                                       [split(@l)] =  [1]                                                            
                                                                   >  [0]                                                            
                                                                   =  [split#1(@l)]                                                  
                                                                                                                                     
         [insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] =  [4] @x + [0]                                                   
                                                                   ?  [5] @vals1 + [1] @key1 + [0]                                   
                                                                   =  [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
                                                                                                                                     
                                                  [insert(@x, @l)] =  [0]                                                            
                                                                   ?  [1] @x + [0]                                                   
                                                                   =  [insert#1(@x, @l, @x)]                                         
                                                                                                                                     
                               [insert#2(nil(), @keyX, @valX, @x)] =  [6] @valX + [2] @keyX + [0]                                    
                                                                   ?  [1] @valX + [8]                                                
                                                                   =  [::(tuple#2(::(@valX, nil()), @keyX), nil())]                  
                                                                                                                                     
                        [insert#2(::(@l1, @ls), @keyX, @valX, @x)] =  [6] @valX + [2] @keyX + [0]                                    
                                                                   ?  [4] @x + [0]                                                   
                                                                   =  [insert#3(@l1, @keyX, @ls, @valX, @x)]                         
                                                                                                                                     
                                          [#and(#true(), #true())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                         [#and(#true(), #false())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#and(#false(), #true())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                        [#and(#false(), #false())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                  [split#1(nil())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [nil()]                                                        
                                                                                                                                     
                                            [split#1(::(@x, @xs))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [insert(@x, split(@xs))]                                       
                                                                                                                                     
                [insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] =  [5] @vals1 + [1] @key1 + [0]                                   
                                                                   ?  [1] @valX + [1] @ls + [1] @vals1 + [8]                         
                                                                   =  [::(tuple#2(::(@valX, @vals1), @key1), @ls)]                   
                                                                                                                                     
               [insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] =  [5] @vals1 + [1] @key1 + [0]                                   
                                                                   ?  [1] @vals1 + [4]                                               
                                                                   =  [::(tuple#2(@vals1, @key1), insert(@x, @ls))]                  
                                                                                                                                     
                         [insert#1(tuple#2(@valX, @keyX), @l, @x)] =  [1] @x + [0]                                                   
                                                                   ?  [6] @valX + [2] @keyX + [0]                                    
                                                                   =  [insert#2(@l, @keyX, @valX, @x)]                               
                                                                                                                                     
                                              [splitAndSort^#(@l)] =  [7] @l + [7]                                                   
                                                                   >  [4] @l + [4]                                                   
                                                                   =  [c_1(split^#(@l))]                                             
                                                                                                                                     
                                                     [split^#(@l)] =  [1] @l + [0]                                                   
                                                                   >= [1] @l + [0]                                                   
                                                                   =  [c_2(split#1^#(@l))]                                           
                                                                                                                                     
                                          [split#1^#(::(@x, @xs))] =  [1] @x + [1] @xs + [4]                                         
                                                                   >  [1] @xs + [1]                                                  
                                                                   =  [c_3(insert^#(@x, split(@xs)), split^#(@xs))]                  
                                                                                                                                     
     
     We return to the main proof. Consider the set of all dependency
     pairs
     
     :
       { 1: splitAndSort^#(@l) -> c_1(split^#(@l))
       , 2: split^#(@l) -> c_2(split#1^#(@l))
       , 3: split#1^#(::(@x, @xs)) ->
            c_3(insert^#(@x, split(@xs)), split^#(@xs)) }
     
     Processor 'matrix interpretation of dimension 1' induces the
     complexity certificate YES(?,O(n^1)) on application of dependency
     pairs {1,3}. These cover all (indirect) predecessors of dependency
     pairs {1,2,3}, their number of application is equally bounded. The
     dependency pairs are shifted into the weak component.
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Weak DPs:
       { splitAndSort^#(@l) -> c_1(split^#(@l))
       , split^#(@l) -> c_2(split#1^#(@l))
       , split#1^#(::(@x, @xs)) ->
         c_3(insert^#(@x, split(@xs)), split^#(@xs)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , split(@l) -> split#1(@l)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     The following weak DPs constitute a sub-graph of the DG that is
     closed under successors. The DPs are removed.
     
     { splitAndSort^#(@l) -> c_1(split^#(@l))
     , split^#(@l) -> c_2(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_3(insert^#(@x, split(@xs)), split^#(@xs)) }
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , split(@l) -> split#1(@l)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     No rule is usable, rules are removed from the input problem.
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Rules: Empty
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     Empty rules are trivially bounded
   
   We return to the main proof.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^1)).
   
   Strict DPs:
     { insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_4(insert#4^#(#equal(@key1, @keyX),
                      @key1,
                      @ls,
                      @valX,
                      @vals1,
                      @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_5(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_6(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_7(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak DPs:
     { splitAndSort^#(@l) -> split^#(@l)
     , split^#(@l) -> split#1^#(@l)
     , split#1^#(::(@x, @xs)) -> split^#(@xs)
     , split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , split(@l) -> split#1(@l)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^1))
   
   We use the processor 'matrix interpretation of dimension 1' to
   orient following rules strictly.
   
   DPs:
     { 5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
          c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x))
     , 8: split#1^#(::(@x, @xs)) -> split^#(@xs)
     , 9: split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs)) }
   Trs:
     { split#1(nil()) -> nil()
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls) }
   
   Sub-proof:
   ----------
     The following argument positions are usable:
       Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
       Uargs(c_7) = {1}, Uargs(c_8) = {1}
     
     TcT has computed the following constructor-based matrix
     interpretation satisfying not(EDA).
     
                           [#equal](x1, x2) = [0]                  
                                                                   
                              [#eq](x1, x2) = [0]                  
                                                                   
                                [split](x1) = [1] x1 + [4]         
                                                                   
                                    [#true] = [0]                  
                                                                   
             [insert#3](x1, x2, x3, x4, x5) = [1] x3 + [2]         
                                                                   
                           [insert](x1, x2) = [1] x2 + [1]         
                                                                   
                                 [#pos](x1) = [1] x1 + [6]         
                                                                   
                 [insert#2](x1, x2, x3, x4) = [1] x1 + [1]         
                                                                   
                             [#and](x1, x2) = [0]                  
                                                                   
                          [tuple#2](x1, x2) = [1] x1 + [0]         
                                                                   
                                      [nil] = [4]                  
                                                                   
                              [split#1](x1) = [1] x1 + [4]         
                                                                   
         [insert#4](x1, x2, x3, x4, x5, x6) = [1] x1 + [1] x3 + [2]
                                                                   
                     [insert#1](x1, x2, x3) = [1] x2 + [1]         
                                                                   
                                   [#false] = [0]                  
                                                                   
                               [::](x1, x2) = [1] x2 + [1]         
                                                                   
                                       [#0] = [1]                  
                                                                   
                                 [#neg](x1) = [1] x1 + [6]         
                                                                   
                                   [#s](x1) = [1] x1 + [6]         
                                                                   
                       [splitAndSort^#](x1) = [7] x1 + [7]         
                                                                   
                              [split^#](x1) = [6] x1 + [7]         
                                                                   
                            [split#1^#](x1) = [6] x1 + [7]         
                                                                   
           [insert#3^#](x1, x2, x3, x4, x5) = [3] x3 + [0]         
                                                                   
       [insert#4^#](x1, x2, x3, x4, x5, x6) = [3] x3 + [0]         
                                                                   
                         [insert^#](x1, x2) = [3] x2 + [0]         
                                                                   
                   [insert#1^#](x1, x2, x3) = [3] x2 + [0]         
                                                                   
               [insert#2^#](x1, x2, x3, x4) = [3] x1 + [0]         
                                                                   
                                  [c_4](x1) = [1] x1 + [0]         
                                                                   
                                  [c_5](x1) = [1] x1 + [0]         
                                                                   
                                  [c_6](x1) = [1] x1 + [0]         
                                                                   
                                  [c_7](x1) = [1] x1 + [0]         
                                                                   
                                  [c_8](x1) = [1] x1 + [1]         
     
     The order satisfies the following ordering constraints:
     
                                                  [#equal(@x, @y)] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                         [#eq(#pos(@x), #pos(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                             [#eq(#pos(@x), #0())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#pos(@x), #neg(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                   [#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                     
                                 [#eq(tuple#2(@x_1, @x_2), nil())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                        [#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                 [#eq(nil(), tuple#2(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                               [#eq(nil(), nil())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                      [#eq(nil(), ::(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                        [#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                      [#eq(::(@x_1, @x_2), nil())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                             [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                     
                                             [#eq(#0(), #pos(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                 [#eq(#0(), #0())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                             [#eq(#0(), #neg(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                               [#eq(#0(), #s(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#neg(@x), #pos(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                             [#eq(#neg(@x), #0())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#neg(@x), #neg(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                               [#eq(#s(@x), #0())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                             [#eq(#s(@x), #s(@y))] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                                       [split(@l)] =  [1] @l + [4]                                                   
                                                                   >= [1] @l + [4]                                                   
                                                                   =  [split#1(@l)]                                                  
                                                                                                                                     
         [insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] =  [1] @ls + [2]                                                  
                                                                   >= [1] @ls + [2]                                                  
                                                                   =  [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
                                                                                                                                     
                                                  [insert(@x, @l)] =  [1] @l + [1]                                                   
                                                                   >= [1] @l + [1]                                                   
                                                                   =  [insert#1(@x, @l, @x)]                                         
                                                                                                                                     
                               [insert#2(nil(), @keyX, @valX, @x)] =  [5]                                                            
                                                                   >= [5]                                                            
                                                                   =  [::(tuple#2(::(@valX, nil()), @keyX), nil())]                  
                                                                                                                                     
                        [insert#2(::(@l1, @ls), @keyX, @valX, @x)] =  [1] @ls + [2]                                                  
                                                                   >= [1] @ls + [2]                                                  
                                                                   =  [insert#3(@l1, @keyX, @ls, @valX, @x)]                         
                                                                                                                                     
                                          [#and(#true(), #true())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                         [#and(#true(), #false())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#and(#false(), #true())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                        [#and(#false(), #false())] =  [0]                                                            
                                                                   >= [0]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                  [split#1(nil())] =  [8]                                                            
                                                                   >  [4]                                                            
                                                                   =  [nil()]                                                        
                                                                                                                                     
                                            [split#1(::(@x, @xs))] =  [1] @xs + [5]                                                  
                                                                   >= [1] @xs + [5]                                                  
                                                                   =  [insert(@x, split(@xs))]                                       
                                                                                                                                     
                [insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] =  [1] @ls + [2]                                                  
                                                                   >  [1] @ls + [1]                                                  
                                                                   =  [::(tuple#2(::(@valX, @vals1), @key1), @ls)]                   
                                                                                                                                     
               [insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] =  [1] @ls + [2]                                                  
                                                                   >= [1] @ls + [2]                                                  
                                                                   =  [::(tuple#2(@vals1, @key1), insert(@x, @ls))]                  
                                                                                                                                     
                         [insert#1(tuple#2(@valX, @keyX), @l, @x)] =  [1] @l + [1]                                                   
                                                                   >= [1] @l + [1]                                                   
                                                                   =  [insert#2(@l, @keyX, @valX, @x)]                               
                                                                                                                                     
                                              [splitAndSort^#(@l)] =  [7] @l + [7]                                                   
                                                                   >= [6] @l + [7]                                                   
                                                                   =  [split^#(@l)]                                                  
                                                                                                                                     
                                                     [split^#(@l)] =  [6] @l + [7]                                                   
                                                                   >= [6] @l + [7]                                                   
                                                                   =  [split#1^#(@l)]                                                
                                                                                                                                     
                                          [split#1^#(::(@x, @xs))] =  [6] @xs + [13]                                                 
                                                                   >  [6] @xs + [7]                                                  
                                                                   =  [split^#(@xs)]                                                 
                                                                                                                                     
                                          [split#1^#(::(@x, @xs))] =  [6] @xs + [13]                                                 
                                                                   >  [3] @xs + [12]                                                 
                                                                   =  [insert^#(@x, split(@xs))]                                     
                                                                                                                                     
       [insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] =  [3] @ls + [0]                                                  
                                                                   >= [3] @ls + [0]                                                  
                                                                   =  [c_4(insert#4^#(#equal(@key1, @keyX),                          
                                                                                      @key1,                                         
                                                                                      @ls,                                           
                                                                                      @valX,                                         
                                                                                      @vals1,                                        
                                                                                      @x))]                                          
                                                                                                                                     
             [insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x)] =  [3] @ls + [0]                                                  
                                                                   >= [3] @ls + [0]                                                  
                                                                   =  [c_5(insert^#(@x, @ls))]                                       
                                                                                                                                     
                                                [insert^#(@x, @l)] =  [3] @l + [0]                                                   
                                                                   >= [3] @l + [0]                                                   
                                                                   =  [c_6(insert#1^#(@x, @l, @x))]                                  
                                                                                                                                     
                       [insert#1^#(tuple#2(@valX, @keyX), @l, @x)] =  [3] @l + [0]                                                   
                                                                   >= [3] @l + [0]                                                   
                                                                   =  [c_7(insert#2^#(@l, @keyX, @valX, @x))]                        
                                                                                                                                     
                      [insert#2^#(::(@l1, @ls), @keyX, @valX, @x)] =  [3] @ls + [3]                                                  
                                                                   >  [3] @ls + [1]                                                  
                                                                   =  [c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x))]                  
                                                                                                                                     
   
   We return to the main proof. Consider the set of all dependency
   pairs
   
   :
     { 1: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
          c_4(insert#4^#(#equal(@key1, @keyX),
                         @key1,
                         @ls,
                         @valX,
                         @vals1,
                         @x))
     , 2: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
          c_5(insert^#(@x, @ls))
     , 3: insert^#(@x, @l) -> c_6(insert#1^#(@x, @l, @x))
     , 4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
          c_7(insert#2^#(@l, @keyX, @valX, @x))
     , 5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
          c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x))
     , 6: splitAndSort^#(@l) -> split^#(@l)
     , 7: split^#(@l) -> split#1^#(@l)
     , 8: split#1^#(::(@x, @xs)) -> split^#(@xs)
     , 9: split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs)) }
   
   Processor 'matrix interpretation of dimension 1' induces the
   complexity certificate YES(?,O(n^1)) on application of dependency
   pairs {5,8,9}. These cover all (indirect) predecessors of
   dependency pairs {1,2,3,4,5,6,7,8,9}, their number of application
   is equally bounded. The dependency pairs are shifted into the weak
   component.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(1)).
   
   Weak DPs:
     { splitAndSort^#(@l) -> split^#(@l)
     , split^#(@l) -> split#1^#(@l)
     , split#1^#(::(@x, @xs)) -> split^#(@xs)
     , split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
     , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_4(insert#4^#(#equal(@key1, @keyX),
                      @key1,
                      @ls,
                      @valX,
                      @vals1,
                      @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_5(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_6(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_7(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , split(@l) -> split#1(@l)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(1))
   
   The following weak DPs constitute a sub-graph of the DG that is
   closed under successors. The DPs are removed.
   
   { splitAndSort^#(@l) -> split^#(@l)
   , split^#(@l) -> split#1^#(@l)
   , split#1^#(::(@x, @xs)) -> split^#(@xs)
   , split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
   , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
     c_4(insert#4^#(#equal(@key1, @keyX),
                    @key1,
                    @ls,
                    @valX,
                    @vals1,
                    @x))
   , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
     c_5(insert^#(@x, @ls))
   , insert^#(@x, @l) -> c_6(insert#1^#(@x, @l, @x))
   , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
     c_7(insert#2^#(@l, @keyX, @valX, @x))
   , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
     c_8(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(1)).
   
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , split(@l) -> split#1(@l)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(1))
   
   No rule is usable, rules are removed from the input problem.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(1)).
   
   Rules: Empty
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(1))
   
   Empty rules are trivially bounded

S) We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^6)).
   
   Strict DPs:
     { sortAll^#(@l) -> c_2(sortAll#1^#(@l))
     , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
       c_4(quicksort^#(@vals), sortAll^#(@xs))
     , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
     , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
     , quicksort#1^#(::(@z, @zs)) ->
       c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
     , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_18(splitqs^#(@pivot, @xs)) }
   Weak DPs:
     { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l))
     , split^#(@l) -> c_3(split#1^#(@l))
     , split#1^#(::(@x, @xs)) ->
       c_8(insert^#(@x, split(@xs)), split^#(@xs))
     , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       c_10(insert#4^#(#equal(@key1, @keyX),
                       @key1,
                       @ls,
                       @valX,
                       @vals1,
                       @x))
     , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
       c_11(insert^#(@x, @ls))
     , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
     , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
       c_13(insert#2^#(@l, @keyX, @valX, @x))
     , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
       c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^6))
   
   The following weak DPs constitute a sub-graph of the DG that is
   closed under successors. The DPs are removed.
   
   { split^#(@l) -> c_3(split#1^#(@l))
   , split#1^#(::(@x, @xs)) ->
     c_8(insert^#(@x, split(@xs)), split^#(@xs))
   , insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
     c_10(insert#4^#(#equal(@key1, @keyX),
                     @key1,
                     @ls,
                     @valX,
                     @vals1,
                     @x))
   , insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
     c_11(insert^#(@x, @ls))
   , insert^#(@x, @l) -> c_12(insert#1^#(@x, @l, @x))
   , insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
     c_13(insert#2^#(@l, @keyX, @valX, @x))
   , insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
     c_15(insert#3^#(@l1, @keyX, @ls, @valX, @x)) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^6)).
   
   Strict DPs:
     { sortAll^#(@l) -> c_2(sortAll#1^#(@l))
     , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
       c_4(quicksort^#(@vals), sortAll^#(@xs))
     , quicksort^#(@l) -> c_5(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_6(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , append^#(@l, @ys) -> c_7(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_9(append^#(@xs, @ys))
     , sortAll#1^#(::(@x, @xs)) -> c_14(sortAll#2^#(@x, @xs))
     , quicksort#1^#(::(@z, @zs)) ->
       c_16(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
     , splitqs^#(@pivot, @l) -> c_17(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_18(splitqs^#(@pivot, @xs)) }
   Weak DPs:
     { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^6))
   
   Due to missing edges in the dependency-graph, the right-hand sides
   of following rules could be simplified:
   
     { splitAndSort^#(@l) -> c_1(sortAll^#(split(@l)), split^#(@l)) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^6)).
   
   Strict DPs:
     { sortAll^#(@l) -> c_1(sortAll#1^#(@l))
     , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
       c_2(quicksort^#(@vals), sortAll^#(@xs))
     , quicksort^#(@l) -> c_3(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys))
     , sortAll#1^#(::(@x, @xs)) -> c_7(sortAll#2^#(@x, @xs))
     , quicksort#1^#(::(@z, @zs)) ->
       c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
     , splitqs^#(@pivot, @l) -> c_9(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_10(splitqs^#(@pivot, @xs)) }
   Weak DPs: { splitAndSort^#(@l) -> c_11(sortAll^#(split(@l))) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^6))
   
   We decompose the input problem according to the dependency graph
   into the upper component
   
     { splitAndSort^#(@l) -> c_11(sortAll^#(split(@l)))
     , sortAll^#(@l) -> c_1(sortAll#1^#(@l))
     , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
       c_2(quicksort^#(@vals), sortAll^#(@xs))
     , sortAll#1^#(::(@x, @xs)) -> c_7(sortAll#2^#(@x, @xs)) }
   
   and lower component
   
     { quicksort^#(@l) -> c_3(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys))
     , quicksort#1^#(::(@z, @zs)) ->
       c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
     , splitqs^#(@pivot, @l) -> c_9(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_10(splitqs^#(@pivot, @xs)) }
   
   Further, following extension rules are added to the lower
   component.
   
   { splitAndSort^#(@l) -> sortAll^#(split(@l))
   , sortAll^#(@l) -> sortAll#1^#(@l)
   , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
   , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
   , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
   
   TcT solves the upper component with certificate YES(O(1),O(n^1)).
   
   Sub-proof:
   ----------
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { sortAll^#(@l) -> c_1(sortAll#1^#(@l))
       , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
         c_2(quicksort^#(@vals), sortAll^#(@xs))
       , sortAll#1^#(::(@x, @xs)) -> c_7(sortAll#2^#(@x, @xs)) }
     Weak DPs: { splitAndSort^#(@l) -> c_11(sortAll^#(split(@l))) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , quicksort#2(tuple#2(@xs, @ys), @z) ->
         append(quicksort(@xs), ::(@z, quicksort(@ys)))
       , split(@l) -> split#1(@l)
       , append(@l, @ys) -> append#1(@l, @ys)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , #ckgt(#EQ()) -> #false()
       , #ckgt(#LT()) -> #false()
       , #ckgt(#GT()) -> #true()
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
       , #compare(#pos(@x), #0()) -> #GT()
       , #compare(#pos(@x), #neg(@y)) -> #GT()
       , #compare(#0(), #pos(@y)) -> #LT()
       , #compare(#0(), #0()) -> #EQ()
       , #compare(#0(), #neg(@y)) -> #GT()
       , #compare(#0(), #s(@y)) -> #LT()
       , #compare(#neg(@x), #pos(@y)) -> #LT()
       , #compare(#neg(@x), #0()) -> #LT()
       , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
       , #compare(#s(@x), #0()) -> #GT()
       , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x)
       , quicksort#1(nil()) -> nil()
       , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
       , append#1(nil(), @ys) -> @ys
       , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
       , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
       , quicksort(@l) -> quicksort#1(@l)
       , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
       , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
       , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
         splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
       , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
       , splitqs#1(::(@x, @xs), @pivot) ->
         splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We replace rewrite rules by usable rules:
     
       Weak Usable Rules:
         { #equal(@x, @y) -> #eq(@x, @y)
         , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
         , #eq(#pos(@x), #0()) -> #false()
         , #eq(#pos(@x), #neg(@y)) -> #false()
         , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
           #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
         , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
         , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
         , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
         , #eq(nil(), nil()) -> #true()
         , #eq(nil(), ::(@y_1, @y_2)) -> #false()
         , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
         , #eq(::(@x_1, @x_2), nil()) -> #false()
         , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
         , #eq(#0(), #pos(@y)) -> #false()
         , #eq(#0(), #0()) -> #true()
         , #eq(#0(), #neg(@y)) -> #false()
         , #eq(#0(), #s(@y)) -> #false()
         , #eq(#neg(@x), #pos(@y)) -> #false()
         , #eq(#neg(@x), #0()) -> #false()
         , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
         , #eq(#s(@x), #0()) -> #false()
         , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
         , split(@l) -> split#1(@l)
         , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
           insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
         , insert(@x, @l) -> insert#1(@x, @l, @x)
         , insert#2(nil(), @keyX, @valX, @x) ->
           ::(tuple#2(::(@valX, nil()), @keyX), nil())
         , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
           insert#3(@l1, @keyX, @ls, @valX, @x)
         , #and(#true(), #true()) -> #true()
         , #and(#true(), #false()) -> #false()
         , #and(#false(), #true()) -> #false()
         , #and(#false(), #false()) -> #false()
         , split#1(nil()) -> nil()
         , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
         , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
           ::(tuple#2(::(@valX, @vals1), @key1), @ls)
         , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
           ::(tuple#2(@vals1, @key1), insert(@x, @ls))
         , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
           insert#2(@l, @keyX, @valX, @x) }
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { sortAll^#(@l) -> c_1(sortAll#1^#(@l))
       , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
         c_2(quicksort^#(@vals), sortAll^#(@xs))
       , sortAll#1^#(::(@x, @xs)) -> c_7(sortAll#2^#(@x, @xs)) }
     Weak DPs: { splitAndSort^#(@l) -> c_11(sortAll^#(split(@l))) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , split(@l) -> split#1(@l)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We use the processor 'matrix interpretation of dimension 1' to
     orient following rules strictly.
     
     DPs:
       { 2: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
            c_2(quicksort^#(@vals), sortAll^#(@xs)) }
     Trs:
       { split(@l) -> split#1(@l)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls) }
     
     Sub-proof:
     ----------
       The following argument positions are usable:
         Uargs(c_1) = {1}, Uargs(c_2) = {2}, Uargs(c_7) = {1},
         Uargs(c_11) = {1}
       
       TcT has computed the following constructor-based matrix
       interpretation satisfying not(EDA).
       
                           [#equal](x1, x2) = [1]                  
                                                                   
                              [#eq](x1, x2) = [1]                  
                                                                   
                      [quicksort#2](x1, x2) = [0]                  
                                                                   
                                [split](x1) = [5] x1 + [3]         
                                                                   
                                    [#true] = [1]                  
                                                                   
                           [append](x1, x2) = [0]                  
                                                                   
             [insert#3](x1, x2, x3, x4, x5) = [1] x3 + [3]         
                                                                   
                                [#ckgt](x1) = [0]                  
                                                                   
                           [insert](x1, x2) = [1] x2 + [2]         
                                                                   
                                 [#pos](x1) = [1] x1 + [0]         
                                                                   
                                      [#EQ] = [0]                  
                                                                   
                 [insert#2](x1, x2, x3, x4) = [1] x1 + [2]         
                                                                   
                             [#and](x1, x2) = [1] x1 + [0]         
                                                                   
                         [#compare](x1, x2) = [0]                  
                                                                   
                          [tuple#2](x1, x2) = [0]                  
                                                                   
                                      [nil] = [2]                  
                                                                   
                              [split#1](x1) = [5] x1 + [1]         
                                                                   
                         [#greater](x1, x2) = [0]                  
                                                                   
         [insert#4](x1, x2, x3, x4, x5, x6) = [1] x3 + [3]         
                                                                   
                     [insert#1](x1, x2, x3) = [1] x2 + [2]         
                                                                   
                          [quicksort#1](x1) = [0]                  
                                                                   
                         [append#1](x1, x2) = [0]                  
                                                                   
                          [splitqs](x1, x2) = [0]                  
                                                                   
                                   [#false] = [1]                  
                                                                   
                            [quicksort](x1) = [0]                  
                                                                   
                               [::](x1, x2) = [1] x1 + [1] x2 + [1]
                                                                   
                                      [#LT] = [0]                  
                                                                   
                [splitqs#3](x1, x2, x3, x4) = [0]                  
                                                                   
                    [splitqs#2](x1, x2, x3) = [0]                  
                                                                   
                                       [#0] = [0]                  
                                                                   
                                 [#neg](x1) = [1] x1 + [0]         
                                                                   
                                   [#s](x1) = [1] x1 + [0]         
                                                                   
                                      [#GT] = [0]                  
                                                                   
                        [splitqs#1](x1, x2) = [0]                  
                                                                   
                       [splitAndSort^#](x1) = [7] x1 + [7]         
                                                                   
                            [sortAll^#](x1) = [1] x1 + [0]         
                                                                   
                      [sortAll#2^#](x1, x2) = [1] x2 + [1]         
                                                                   
                          [quicksort^#](x1) = [0]                  
                                                                   
                          [sortAll#1^#](x1) = [1] x1 + [0]         
                                                                   
                                  [c_1](x1) = [1] x1 + [0]         
                                                                   
                              [c_2](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                   
                                  [c_7](x1) = [1] x1 + [0]         
                                                                   
                                 [c_11](x1) = [1] x1 + [4]         
       
       The order satisfies the following ordering constraints:
       
                                                  [#equal(@x, @y)] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                         [#eq(#pos(@x), #pos(@y))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                             [#eq(#pos(@x), #0())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#pos(@x), #neg(@y))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                   [#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                     
                                 [#eq(tuple#2(@x_1, @x_2), nil())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                        [#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                 [#eq(nil(), tuple#2(@y_1, @y_2))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                               [#eq(nil(), nil())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                      [#eq(nil(), ::(@y_1, @y_2))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                        [#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                      [#eq(::(@x_1, @x_2), nil())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                             [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                     
                                             [#eq(#0(), #pos(@y))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                 [#eq(#0(), #0())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                             [#eq(#0(), #neg(@y))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                               [#eq(#0(), #s(@y))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#neg(@x), #pos(@y))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                             [#eq(#neg(@x), #0())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#neg(@x), #neg(@y))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                               [#eq(#s(@x), #0())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                             [#eq(#s(@x), #s(@y))] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                                       [split(@l)] =  [5] @l + [3]                                                   
                                                                   >  [5] @l + [1]                                                   
                                                                   =  [split#1(@l)]                                                  
                                                                                                                                     
         [insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] =  [1] @ls + [3]                                                  
                                                                   >= [1] @ls + [3]                                                  
                                                                   =  [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
                                                                                                                                     
                                                  [insert(@x, @l)] =  [1] @l + [2]                                                   
                                                                   >= [1] @l + [2]                                                   
                                                                   =  [insert#1(@x, @l, @x)]                                         
                                                                                                                                     
                               [insert#2(nil(), @keyX, @valX, @x)] =  [4]                                                            
                                                                   >  [3]                                                            
                                                                   =  [::(tuple#2(::(@valX, nil()), @keyX), nil())]                  
                                                                                                                                     
                        [insert#2(::(@l1, @ls), @keyX, @valX, @x)] =  [1] @l1 + [1] @ls + [3]                                        
                                                                   >= [1] @ls + [3]                                                  
                                                                   =  [insert#3(@l1, @keyX, @ls, @valX, @x)]                         
                                                                                                                                     
                                          [#and(#true(), #true())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                         [#and(#true(), #false())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#and(#false(), #true())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                        [#and(#false(), #false())] =  [1]                                                            
                                                                   >= [1]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                  [split#1(nil())] =  [11]                                                           
                                                                   >  [2]                                                            
                                                                   =  [nil()]                                                        
                                                                                                                                     
                                            [split#1(::(@x, @xs))] =  [5] @x + [5] @xs + [6]                                         
                                                                   >  [5] @xs + [5]                                                  
                                                                   =  [insert(@x, split(@xs))]                                       
                                                                                                                                     
                [insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] =  [1] @ls + [3]                                                  
                                                                   >  [1] @ls + [1]                                                  
                                                                   =  [::(tuple#2(::(@valX, @vals1), @key1), @ls)]                   
                                                                                                                                     
               [insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] =  [1] @ls + [3]                                                  
                                                                   >= [1] @ls + [3]                                                  
                                                                   =  [::(tuple#2(@vals1, @key1), insert(@x, @ls))]                  
                                                                                                                                     
                         [insert#1(tuple#2(@valX, @keyX), @l, @x)] =  [1] @l + [2]                                                   
                                                                   >= [1] @l + [2]                                                   
                                                                   =  [insert#2(@l, @keyX, @valX, @x)]                               
                                                                                                                                     
                                              [splitAndSort^#(@l)] =  [7] @l + [7]                                                   
                                                                   >= [5] @l + [7]                                                   
                                                                   =  [c_11(sortAll^#(split(@l)))]                                   
                                                                                                                                     
                                                   [sortAll^#(@l)] =  [1] @l + [0]                                                   
                                                                   >= [1] @l + [0]                                                   
                                                                   =  [c_1(sortAll#1^#(@l))]                                         
                                                                                                                                     
                          [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [1] @xs + [1]                                                  
                                                                   >  [1] @xs + [0]                                                  
                                                                   =  [c_2(quicksort^#(@vals), sortAll^#(@xs))]                      
                                                                                                                                     
                                        [sortAll#1^#(::(@x, @xs))] =  [1] @x + [1] @xs + [1]                                         
                                                                   >= [1] @xs + [1]                                                  
                                                                   =  [c_7(sortAll#2^#(@x, @xs))]                                    
                                                                                                                                     
     
     We return to the main proof. Consider the set of all dependency
     pairs
     
     :
       { 1: sortAll^#(@l) -> c_1(sortAll#1^#(@l))
       , 2: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
            c_2(quicksort^#(@vals), sortAll^#(@xs))
       , 3: sortAll#1^#(::(@x, @xs)) -> c_7(sortAll#2^#(@x, @xs))
       , 4: splitAndSort^#(@l) -> c_11(sortAll^#(split(@l))) }
     
     Processor 'matrix interpretation of dimension 1' induces the
     complexity certificate YES(?,O(n^1)) on application of dependency
     pairs {2}. These cover all (indirect) predecessors of dependency
     pairs {1,2,3,4}, their number of application is equally bounded.
     The dependency pairs are shifted into the weak component.
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Weak DPs:
       { splitAndSort^#(@l) -> c_11(sortAll^#(split(@l)))
       , sortAll^#(@l) -> c_1(sortAll#1^#(@l))
       , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
         c_2(quicksort^#(@vals), sortAll^#(@xs))
       , sortAll#1^#(::(@x, @xs)) -> c_7(sortAll#2^#(@x, @xs)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , split(@l) -> split#1(@l)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     The following weak DPs constitute a sub-graph of the DG that is
     closed under successors. The DPs are removed.
     
     { splitAndSort^#(@l) -> c_11(sortAll^#(split(@l)))
     , sortAll^#(@l) -> c_1(sortAll#1^#(@l))
     , sortAll#2^#(tuple#2(@vals, @key), @xs) ->
       c_2(quicksort^#(@vals), sortAll^#(@xs))
     , sortAll#1^#(::(@x, @xs)) -> c_7(sortAll#2^#(@x, @xs)) }
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , split(@l) -> split#1(@l)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     No rule is usable, rules are removed from the input problem.
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Rules: Empty
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     Empty rules are trivially bounded
   
   We return to the main proof.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^5)).
   
   Strict DPs:
     { quicksort^#(@l) -> c_3(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys))
     , quicksort#1^#(::(@z, @zs)) ->
       c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
     , splitqs^#(@pivot, @l) -> c_9(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_10(splitqs^#(@pivot, @xs)) }
   Weak DPs:
     { splitAndSort^#(@l) -> sortAll^#(split(@l))
     , sortAll^#(@l) -> sortAll#1^#(@l)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^5))
   
   We decompose the input problem according to the dependency graph
   into the upper component
   
     { splitAndSort^#(@l) -> sortAll^#(split(@l))
     , sortAll^#(@l) -> sortAll#1^#(@l)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , quicksort^#(@l) -> c_3(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
     , quicksort#1^#(::(@z, @zs)) ->
       c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
   
   and lower component
   
     { append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys))
     , splitqs^#(@pivot, @l) -> c_9(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_10(splitqs^#(@pivot, @xs)) }
   
   Further, following extension rules are added to the lower
   component.
   
   { splitAndSort^#(@l) -> sortAll^#(split(@l))
   , sortAll^#(@l) -> sortAll#1^#(@l)
   , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
   , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
   , quicksort^#(@l) -> quicksort#1^#(@l)
   , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
   , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
   , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
     append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
   , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
   , quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
   , quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs) }
   
   TcT solves the upper component with certificate YES(O(1),O(n^1)).
   
   Sub-proof:
   ----------
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { quicksort^#(@l) -> c_3(quicksort#1^#(@l))
       , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
         c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
             quicksort^#(@xs),
             quicksort^#(@ys))
       , quicksort#1^#(::(@z, @zs)) ->
         c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
     Weak DPs:
       { splitAndSort^#(@l) -> sortAll^#(split(@l))
       , sortAll^#(@l) -> sortAll#1^#(@l)
       , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
       , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
       , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , quicksort#2(tuple#2(@xs, @ys), @z) ->
         append(quicksort(@xs), ::(@z, quicksort(@ys)))
       , split(@l) -> split#1(@l)
       , append(@l, @ys) -> append#1(@l, @ys)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , #ckgt(#EQ()) -> #false()
       , #ckgt(#LT()) -> #false()
       , #ckgt(#GT()) -> #true()
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
       , #compare(#pos(@x), #0()) -> #GT()
       , #compare(#pos(@x), #neg(@y)) -> #GT()
       , #compare(#0(), #pos(@y)) -> #LT()
       , #compare(#0(), #0()) -> #EQ()
       , #compare(#0(), #neg(@y)) -> #GT()
       , #compare(#0(), #s(@y)) -> #LT()
       , #compare(#neg(@x), #pos(@y)) -> #LT()
       , #compare(#neg(@x), #0()) -> #LT()
       , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
       , #compare(#s(@x), #0()) -> #GT()
       , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x)
       , quicksort#1(nil()) -> nil()
       , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
       , append#1(nil(), @ys) -> @ys
       , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
       , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
       , quicksort(@l) -> quicksort#1(@l)
       , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
       , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
       , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
         splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
       , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
       , splitqs#1(::(@x, @xs), @pivot) ->
         splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We use the processor 'matrix interpretation of dimension 2' to
     orient following rules strictly.
     
     DPs:
       { 3: quicksort#1^#(::(@z, @zs)) ->
            c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
       , 4: splitAndSort^#(@l) -> sortAll^#(split(@l))
       , 5: sortAll^#(@l) -> sortAll#1^#(@l)
       , 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
       , 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
       , 8: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
     Trs:
       { insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
       , #compare(#pos(@x), #0()) -> #GT()
       , #compare(#pos(@x), #neg(@y)) -> #GT()
       , #compare(#0(), #pos(@y)) -> #LT()
       , #compare(#0(), #0()) -> #EQ()
       , #compare(#0(), #neg(@y)) -> #GT()
       , #compare(#0(), #s(@y)) -> #LT()
       , #compare(#neg(@x), #pos(@y)) -> #LT()
       , #compare(#neg(@x), #0()) -> #LT()
       , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
       , #compare(#s(@x), #0()) -> #GT()
       , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , quicksort#1(nil()) -> nil()
       , append#1(nil(), @ys) -> @ys }
     
     Sub-proof:
     ----------
       The following argument positions are usable:
         Uargs(c_3) = {1}, Uargs(c_4) = {1, 2, 3}, Uargs(c_8) = {1}
       
       TcT has computed the following constructor-based matrix
       interpretation satisfying not(EDA) and not(IDA(1)).
       
                           [#equal](x1, x2) = [1]                               
                                              [5]                               
                                                                                
                              [#eq](x1, x2) = [1]                               
                                              [5]                               
                                                                                
                      [quicksort#2](x1, x2) = [0 0] x2 + [7]                    
                                              [0 1]      [0]                    
                                                                                
                                [split](x1) = [7 0] x1 + [1]                    
                                              [0 3]      [1]                    
                                                                                
                                    [#true] = [1]                               
                                              [1]                               
                                                                                
                           [append](x1, x2) = [0 0] x1 + [3 0] x2 + [0]         
                                              [7 0]      [2 1]      [0]         
                                                                                
             [insert#3](x1, x2, x3, x4, x5) = [0 0] x1 + [1 0] x3 + [7]         
                                              [0 1]      [0 1]      [7]         
                                                                                
                                [#ckgt](x1) = [0 0] x1 + [1]                    
                                              [1 0]      [3]                    
                                                                                
                           [insert](x1, x2) = [1 0] x2 + [6]                    
                                              [0 1]      [5]                    
                                                                                
                                 [#pos](x1) = [1 0] x1 + [0]                    
                                              [0 1]      [2]                    
                                                                                
                                      [#EQ] = [3]                               
                                              [0]                               
                                                                                
                 [insert#2](x1, x2, x3, x4) = [1 0] x1 + [6]                    
                                              [0 1]      [5]                    
                                                                                
                             [#and](x1, x2) = [1]                               
                                              [5]                               
                                                                                
                         [#compare](x1, x2) = [2 1] x1 + [1 2] x2 + [4]         
                                              [6 1]      [1 6]      [0]         
                                                                                
                          [tuple#2](x1, x2) = [1 0] x1 + [1 0] x2 + [1]         
                                              [1 0]      [0 0]      [2]         
                                                                                
                                      [nil] = [0]                               
                                              [5]                               
                                                                                
                              [split#1](x1) = [7 0] x1 + [1]                    
                                              [0 3]      [0]                    
                                                                                
                         [#greater](x1, x2) = [0 0] x1 + [0 0] x2 + [1]         
                                              [2 1]      [1 2]      [7]         
                                                                                
         [insert#4](x1, x2, x3, x4, x5, x6) = [2 1] x1 + [1 0] x3 + [0          
                                                                     0] x5 + [0]
                                              [7 0]      [0 1]      [1          
                                                                     0]      [2]
                                                                                
                     [insert#1](x1, x2, x3) = [1 0] x2 + [6]                    
                                              [0 1]      [5]                    
                                                                                
                          [quicksort#1](x1) = [0 0] x1 + [7]                    
                                              [0 1]      [2]                    
                                                                                
                         [append#1](x1, x2) = [7 0] x2 + [1]                    
                                              [1 5]      [0]                    
                                                                                
                          [splitqs](x1, x2) = [1 0] x2 + [1]                    
                                              [4 0]      [2]                    
                                                                                
                                   [#false] = [1]                               
                                              [5]                               
                                                                                
                            [quicksort](x1) = [0 0] x1 + [1]                    
                                              [0 1]      [0]                    
                                                                                
                               [::](x1, x2) = [0 0] x1 + [1 0] x2 + [1]         
                                              [0 1]      [0 1]      [2]         
                                                                                
                                      [#LT] = [2]                               
                                              [0]                               
                                                                                
                [splitqs#3](x1, x2, x3, x4) = [0 0] x1 + [1 0] x2 + [1          
                                                                     0] x3 + [2]
                                              [2 0]      [1 0]      [0          
                                                                     0]      [1]
                                                                                
                    [splitqs#2](x1, x2, x3) = [1 0] x1 + [1]                    
                                              [0 1]      [1]                    
                                                                                
                                       [#0] = [0]                               
                                              [0]                               
                                                                                
                                 [#neg](x1) = [0 1] x1 + [0]                    
                                              [1 0]      [2]                    
                                                                                
                                   [#s](x1) = [1 0] x1 + [2]                    
                                              [0 1]      [0]                    
                                                                                
                                      [#GT] = [0]                               
                                              [0]                               
                                                                                
                        [splitqs#1](x1, x2) = [1 0] x1 + [1]                    
                                              [4 0]      [2]                    
                                                                                
                       [splitAndSort^#](x1) = [7 7] x1 + [7]                    
                                              [7 7]      [7]                    
                                                                                
                            [sortAll^#](x1) = [0 2] x1 + [4]                    
                                              [0 0]      [4]                    
                                                                                
                      [sortAll#2^#](x1, x2) = [0 2] x1 + [0 2] x2 + [3]         
                                              [0 0]      [0 0]      [4]         
                                                                                
                          [quicksort^#](x1) = [2 0] x1 + [1]                    
                                              [0 0]      [0]                    
                                                                                
                    [quicksort#2^#](x1, x2) = [2 0] x1 + [0]                    
                                              [1 0]      [0]                    
                                                                                
                         [append^#](x1, x2) = [0]                               
                                              [1]                               
                                                                                
                          [sortAll#1^#](x1) = [0 2] x1 + [2]                    
                                              [0 0]      [4]                    
                                                                                
                        [quicksort#1^#](x1) = [2 0] x1 + [1]                    
                                              [0 0]      [0]                    
                                                                                
                        [splitqs^#](x1, x2) = [1]                               
                                              [1]                               
                                                                                
                                  [c_3](x1) = [1 1] x1 + [0]                    
                                              [0 0]      [0]                    
                                                                                
                          [c_4](x1, x2, x3) = [5 0] x1 + [1 0] x2 + [1          
                                                                     0] x3 + [0]
                                              [0 0]      [0 0]      [0          
                                                                     0]      [0]
                                                                                
                              [c_8](x1, x2) = [1 0] x1 + [0]                    
                                              [0 0]      [0]                    
       
       The order satisfies the following ordering constraints:
       
                                                  [#equal(@x, @y)] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                         [#eq(#pos(@x), #pos(@y))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                             [#eq(#pos(@x), #0())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#pos(@x), #neg(@y))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                   [#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                     
                                 [#eq(tuple#2(@x_1, @x_2), nil())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                        [#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                 [#eq(nil(), tuple#2(@y_1, @y_2))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                               [#eq(nil(), nil())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [1]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                      [#eq(nil(), ::(@y_1, @y_2))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                        [#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                      [#eq(::(@x_1, @x_2), nil())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                             [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                     
                                             [#eq(#0(), #pos(@y))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                 [#eq(#0(), #0())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [1]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                             [#eq(#0(), #neg(@y))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                               [#eq(#0(), #s(@y))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#neg(@x), #pos(@y))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                             [#eq(#neg(@x), #0())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#eq(#neg(@x), #neg(@y))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                                               [#eq(#s(@x), #0())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                             [#eq(#s(@x), #s(@y))] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#eq(@x, @y)]                                                  
                                                                                                                                     
                              [quicksort#2(tuple#2(@xs, @ys), @z)] =  [0 0] @z + [7]                                                 
                                                                      [0 1]      [0]                                                 
                                                                   ?  [0 0] @ys + [0 0] @z + [6]                                     
                                                                      [0 1]       [0 1]      [13]                                    
                                                                   =  [append(quicksort(@xs), ::(@z, quicksort(@ys)))]               
                                                                                                                                     
                                                       [split(@l)] =  [7 0] @l + [1]                                                 
                                                                      [0 3]      [1]                                                 
                                                                   >= [7 0] @l + [1]                                                 
                                                                      [0 3]      [0]                                                 
                                                                   =  [split#1(@l)]                                                  
                                                                                                                                     
                                                 [append(@l, @ys)] =  [0 0] @l + [3 0] @ys + [0]                                     
                                                                      [7 0]      [2 1]       [0]                                     
                                                                   ?  [7 0] @ys + [1]                                                
                                                                      [1 5]       [0]                                                
                                                                   =  [append#1(@l, @ys)]                                            
                                                                                                                                     
         [insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] =  [1 0] @ls + [0 0] @vals1 + [7]                                 
                                                                      [0 1]       [1 0]          [9]                                 
                                                                   >= [1 0] @ls + [0 0] @vals1 + [7]                                 
                                                                      [0 1]       [1 0]          [9]                                 
                                                                   =  [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
                                                                                                                                     
                                                    [#ckgt(#EQ())] =  [1]                                                            
                                                                      [6]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                    [#ckgt(#LT())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                                    [#ckgt(#GT())] =  [1]                                                            
                                                                      [3]                                                            
                                                                   >= [1]                                                            
                                                                      [1]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                                  [insert(@x, @l)] =  [1 0] @l + [6]                                                 
                                                                      [0 1]      [5]                                                 
                                                                   >= [1 0] @l + [6]                                                 
                                                                      [0 1]      [5]                                                 
                                                                   =  [insert#1(@x, @l, @x)]                                         
                                                                                                                                     
                               [insert#2(nil(), @keyX, @valX, @x)] =  [6]                                                            
                                                                      [10]                                                           
                                                                   >  [1]                                                            
                                                                      [10]                                                           
                                                                   =  [::(tuple#2(::(@valX, nil()), @keyX), nil())]                  
                                                                                                                                     
                        [insert#2(::(@l1, @ls), @keyX, @valX, @x)] =  [0 0] @l1 + [1 0] @ls + [7]                                    
                                                                      [0 1]       [0 1]       [7]                                    
                                                                   >= [0 0] @l1 + [1 0] @ls + [7]                                    
                                                                      [0 1]       [0 1]       [7]                                    
                                                                   =  [insert#3(@l1, @keyX, @ls, @valX, @x)]                         
                                                                                                                                     
                                          [#and(#true(), #true())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [1]                                                            
                                                                   =  [#true()]                                                      
                                                                                                                                     
                                         [#and(#true(), #false())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                         [#and(#false(), #true())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                        [#and(#false(), #false())] =  [1]                                                            
                                                                      [5]                                                            
                                                                   >= [1]                                                            
                                                                      [5]                                                            
                                                                   =  [#false()]                                                     
                                                                                                                                     
                                    [#compare(#pos(@x), #pos(@y))] =  [2 1] @x + [1 2] @y + [10]                                     
                                                                      [6 1]      [1 6]      [14]                                     
                                                                   >  [2 1] @x + [1 2] @y + [4]                                      
                                                                      [6 1]      [1 6]      [0]                                      
                                                                   =  [#compare(@x, @y)]                                             
                                                                                                                                     
                                        [#compare(#pos(@x), #0())] =  [2 1] @x + [6]                                                 
                                                                      [6 1]      [2]                                                 
                                                                   >  [0]                                                            
                                                                      [0]                                                            
                                                                   =  [#GT()]                                                        
                                                                                                                                     
                                    [#compare(#pos(@x), #neg(@y))] =  [2 1] @x + [2 1] @y + [10]                                     
                                                                      [6 1]      [6 1]      [14]                                     
                                                                   >  [0]                                                            
                                                                      [0]                                                            
                                                                   =  [#GT()]                                                        
                                                                                                                                     
                                        [#compare(#0(), #pos(@y))] =  [1 2] @y + [8]                                                 
                                                                      [1 6]      [12]                                                
                                                                   >  [2]                                                            
                                                                      [0]                                                            
                                                                   =  [#LT()]                                                        
                                                                                                                                     
                                            [#compare(#0(), #0())] =  [4]                                                            
                                                                      [0]                                                            
                                                                   >  [3]                                                            
                                                                      [0]                                                            
                                                                   =  [#EQ()]                                                        
                                                                                                                                     
                                        [#compare(#0(), #neg(@y))] =  [2 1] @y + [8]                                                 
                                                                      [6 1]      [12]                                                
                                                                   >  [0]                                                            
                                                                      [0]                                                            
                                                                   =  [#GT()]                                                        
                                                                                                                                     
                                          [#compare(#0(), #s(@y))] =  [1 2] @y + [6]                                                 
                                                                      [1 6]      [2]                                                 
                                                                   >  [2]                                                            
                                                                      [0]                                                            
                                                                   =  [#LT()]                                                        
                                                                                                                                     
                                    [#compare(#neg(@x), #pos(@y))] =  [1 2] @x + [1 2] @y + [10]                                     
                                                                      [1 6]      [1 6]      [14]                                     
                                                                   >  [2]                                                            
                                                                      [0]                                                            
                                                                   =  [#LT()]                                                        
                                                                                                                                     
                                        [#compare(#neg(@x), #0())] =  [1 2] @x + [6]                                                 
                                                                      [1 6]      [2]                                                 
                                                                   >  [2]                                                            
                                                                      [0]                                                            
                                                                   =  [#LT()]                                                        
                                                                                                                                     
                                    [#compare(#neg(@x), #neg(@y))] =  [1 2] @x + [2 1] @y + [10]                                     
                                                                      [1 6]      [6 1]      [14]                                     
                                                                   >  [1 2] @x + [2 1] @y + [4]                                      
                                                                      [1 6]      [6 1]      [0]                                      
                                                                   =  [#compare(@y, @x)]                                             
                                                                                                                                     
                                          [#compare(#s(@x), #0())] =  [2 1] @x + [8]                                                 
                                                                      [6 1]      [12]                                                
                                                                   >  [0]                                                            
                                                                      [0]                                                            
                                                                   =  [#GT()]                                                        
                                                                                                                                     
                                        [#compare(#s(@x), #s(@y))] =  [2 1] @x + [1 2] @y + [10]                                     
                                                                      [6 1]      [1 6]      [14]                                     
                                                                   >  [2 1] @x + [1 2] @y + [4]                                      
                                                                      [6 1]      [1 6]      [0]                                      
                                                                   =  [#compare(@x, @y)]                                             
                                                                                                                                     
                                                  [split#1(nil())] =  [1]                                                            
                                                                      [15]                                                           
                                                                   >  [0]                                                            
                                                                      [5]                                                            
                                                                   =  [nil()]                                                        
                                                                                                                                     
                                            [split#1(::(@x, @xs))] =  [0 0] @x + [7 0] @xs + [8]                                     
                                                                      [0 3]      [0 3]       [6]                                     
                                                                   >  [7 0] @xs + [7]                                                
                                                                      [0 3]       [6]                                                
                                                                   =  [insert(@x, split(@xs))]                                       
                                                                                                                                     
                                                [#greater(@x, @y)] =  [0 0] @x + [0 0] @y + [1]                                      
                                                                      [2 1]      [1 2]      [7]                                      
                                                                   >= [0 0] @x + [0 0] @y + [1]                                      
                                                                      [2 1]      [1 2]      [7]                                      
                                                                   =  [#ckgt(#compare(@x, @y))]                                      
                                                                                                                                     
                [insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] =  [1 0] @ls + [0 0] @vals1 + [3]                                 
                                                                      [0 1]       [1 0]          [9]                                 
                                                                   >  [1 0] @ls + [0 0] @vals1 + [1]                                 
                                                                      [0 1]       [1 0]          [5]                                 
                                                                   =  [::(tuple#2(::(@valX, @vals1), @key1), @ls)]                   
                                                                                                                                     
               [insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] =  [1 0] @ls + [0 0] @vals1 + [7]                                 
                                                                      [0 1]       [1 0]          [9]                                 
                                                                   >= [1 0] @ls + [0 0] @vals1 + [7]                                 
                                                                      [0 1]       [1 0]          [9]                                 
                                                                   =  [::(tuple#2(@vals1, @key1), insert(@x, @ls))]                  
                                                                                                                                     
                         [insert#1(tuple#2(@valX, @keyX), @l, @x)] =  [1 0] @l + [6]                                                 
                                                                      [0 1]      [5]                                                 
                                                                   >= [1 0] @l + [6]                                                 
                                                                      [0 1]      [5]                                                 
                                                                   =  [insert#2(@l, @keyX, @valX, @x)]                               
                                                                                                                                     
                                              [quicksort#1(nil())] =  [7]                                                            
                                                                      [7]                                                            
                                                                   >  [0]                                                            
                                                                      [5]                                                            
                                                                   =  [nil()]                                                        
                                                                                                                                     
                                        [quicksort#1(::(@z, @zs))] =  [0 0] @z + [0 0] @zs + [7]                                     
                                                                      [0 1]      [0 1]       [4]                                     
                                                                   >= [0 0] @z + [7]                                                 
                                                                      [0 1]      [0]                                                 
                                                                   =  [quicksort#2(splitqs(@z, @zs), @z)]                            
                                                                                                                                     
                                            [append#1(nil(), @ys)] =  [7 0] @ys + [1]                                                
                                                                      [1 5]       [0]                                                
                                                                   >  [1 0] @ys + [0]                                                
                                                                      [0 1]       [0]                                                
                                                                   =  [@ys]                                                          
                                                                                                                                     
                                      [append#1(::(@x, @xs), @ys)] =  [7 0] @ys + [1]                                                
                                                                      [1 5]       [0]                                                
                                                                   ?  [0 0] @x + [3 0] @ys + [0 0] @xs + [1]                         
                                                                      [0 1]      [2 1]       [7 0]       [2]                         
                                                                   =  [::(@x, append(@xs, @ys))]                                     
                                                                                                                                     
                                             [splitqs(@pivot, @l)] =  [1 0] @l + [1]                                                 
                                                                      [4 0]      [2]                                                 
                                                                   >= [1 0] @l + [1]                                                 
                                                                      [4 0]      [2]                                                 
                                                                   =  [splitqs#1(@l, @pivot)]                                        
                                                                                                                                     
                                                   [quicksort(@l)] =  [0 0] @l + [1]                                                 
                                                                      [0 1]      [0]                                                 
                                                                   ?  [0 0] @l + [7]                                                 
                                                                      [0 1]      [2]                                                 
                                                                   =  [quicksort#1(@l)]                                              
                                                                                                                                     
                                [splitqs#3(#true(), @ls, @rs, @x)] =  [1 0] @ls + [1 0] @rs + [2]                                    
                                                                      [1 0]       [0 0]       [3]                                    
                                                                   >= [1 0] @ls + [1 0] @rs + [2]                                    
                                                                      [1 0]       [0 0]       [2]                                    
                                                                   =  [tuple#2(@ls, ::(@x, @rs))]                                    
                                                                                                                                     
                               [splitqs#3(#false(), @ls, @rs, @x)] =  [1 0] @ls + [1 0] @rs + [2]                                    
                                                                      [1 0]       [0 0]       [3]                                    
                                                                   >= [1 0] @ls + [1 0] @rs + [2]                                    
                                                                      [1 0]       [0 0]       [3]                                    
                                                                   =  [tuple#2(::(@x, @ls), @rs)]                                    
                                                                                                                                     
                        [splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] =  [1 0] @ls + [1 0] @rs + [2]                                    
                                                                      [1 0]       [0 0]       [3]                                    
                                                                   >= [1 0] @ls + [1 0] @rs + [2]                                    
                                                                      [1 0]       [0 0]       [3]                                    
                                                                   =  [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]                
                                                                                                                                     
                                        [splitqs#1(nil(), @pivot)] =  [1]                                                            
                                                                      [2]                                                            
                                                                   >= [1]                                                            
                                                                      [2]                                                            
                                                                   =  [tuple#2(nil(), nil())]                                        
                                                                                                                                     
                                  [splitqs#1(::(@x, @xs), @pivot)] =  [1 0] @xs + [2]                                                
                                                                      [4 0]       [6]                                                
                                                                   >= [1 0] @xs + [2]                                                
                                                                      [4 0]       [3]                                                
                                                                   =  [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]                  
                                                                                                                                     
                                              [splitAndSort^#(@l)] =  [7 7] @l + [7]                                                 
                                                                      [7 7]      [7]                                                 
                                                                   >  [0 6] @l + [6]                                                 
                                                                      [0 0]      [4]                                                 
                                                                   =  [sortAll^#(split(@l))]                                         
                                                                                                                                     
                                                   [sortAll^#(@l)] =  [0 2] @l + [4]                                                 
                                                                      [0 0]      [4]                                                 
                                                                   >  [0 2] @l + [2]                                                 
                                                                      [0 0]      [4]                                                 
                                                                   =  [sortAll#1^#(@l)]                                              
                                                                                                                                     
                          [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [0 2] @xs + [2 0] @vals + [7]                                  
                                                                      [0 0]       [0 0]         [4]                                  
                                                                   >  [0 2] @xs + [4]                                                
                                                                      [0 0]       [4]                                                
                                                                   =  [sortAll^#(@xs)]                                               
                                                                                                                                     
                          [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [0 2] @xs + [2 0] @vals + [7]                                  
                                                                      [0 0]       [0 0]         [4]                                  
                                                                   >  [2 0] @vals + [1]                                              
                                                                      [0 0]         [0]                                              
                                                                   =  [quicksort^#(@vals)]                                           
                                                                                                                                     
                                                 [quicksort^#(@l)] =  [2 0] @l + [1]                                                 
                                                                      [0 0]      [0]                                                 
                                                                   >= [2 0] @l + [1]                                                 
                                                                      [0 0]      [0]                                                 
                                                                   =  [c_3(quicksort#1^#(@l))]                                       
                                                                                                                                     
                            [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [2 0] @ys + [2 0] @xs + [2]                                    
                                                                      [1 0]       [1 0]       [1]                                    
                                                                   >= [2 0] @ys + [2 0] @xs + [2]                                    
                                                                      [0 0]       [0 0]       [0]                                    
                                                                   =  [c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),         
                                                                           quicksort^#(@xs),                                         
                                                                           quicksort^#(@ys))]                                        
                                                                                                                                     
                                        [sortAll#1^#(::(@x, @xs))] =  [0 2] @x + [0 2] @xs + [6]                                     
                                                                      [0 0]      [0 0]       [4]                                     
                                                                   >  [0 2] @x + [0 2] @xs + [3]                                     
                                                                      [0 0]      [0 0]       [4]                                     
                                                                   =  [sortAll#2^#(@x, @xs)]                                         
                                                                                                                                     
                                      [quicksort#1^#(::(@z, @zs))] =  [2 0] @zs + [3]                                                
                                                                      [0 0]       [0]                                                
                                                                   >  [2 0] @zs + [2]                                                
                                                                      [0 0]       [0]                                                
                                                                   =  [c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))] 
                                                                                                                                     
     
     We return to the main proof. Consider the set of all dependency
     pairs
     
     :
       { 1: quicksort^#(@l) -> c_3(quicksort#1^#(@l))
       , 2: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
            c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
                quicksort^#(@xs),
                quicksort^#(@ys))
       , 3: quicksort#1^#(::(@z, @zs)) ->
            c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
       , 4: splitAndSort^#(@l) -> sortAll^#(split(@l))
       , 5: sortAll^#(@l) -> sortAll#1^#(@l)
       , 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
       , 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
       , 8: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
     
     Processor 'matrix interpretation of dimension 2' induces the
     complexity certificate YES(?,O(n^1)) on application of dependency
     pairs {3,4,5,6,7,8}. These cover all (indirect) predecessors of
     dependency pairs {1,2,3,4,5,6,7,8}, their number of application is
     equally bounded. The dependency pairs are shifted into the weak
     component.
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Weak DPs:
       { splitAndSort^#(@l) -> sortAll^#(split(@l))
       , sortAll^#(@l) -> sortAll#1^#(@l)
       , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
       , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
       , quicksort^#(@l) -> c_3(quicksort#1^#(@l))
       , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
         c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
             quicksort^#(@xs),
             quicksort^#(@ys))
       , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
       , quicksort#1^#(::(@z, @zs)) ->
         c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , quicksort#2(tuple#2(@xs, @ys), @z) ->
         append(quicksort(@xs), ::(@z, quicksort(@ys)))
       , split(@l) -> split#1(@l)
       , append(@l, @ys) -> append#1(@l, @ys)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , #ckgt(#EQ()) -> #false()
       , #ckgt(#LT()) -> #false()
       , #ckgt(#GT()) -> #true()
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
       , #compare(#pos(@x), #0()) -> #GT()
       , #compare(#pos(@x), #neg(@y)) -> #GT()
       , #compare(#0(), #pos(@y)) -> #LT()
       , #compare(#0(), #0()) -> #EQ()
       , #compare(#0(), #neg(@y)) -> #GT()
       , #compare(#0(), #s(@y)) -> #LT()
       , #compare(#neg(@x), #pos(@y)) -> #LT()
       , #compare(#neg(@x), #0()) -> #LT()
       , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
       , #compare(#s(@x), #0()) -> #GT()
       , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x)
       , quicksort#1(nil()) -> nil()
       , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
       , append#1(nil(), @ys) -> @ys
       , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
       , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
       , quicksort(@l) -> quicksort#1(@l)
       , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
       , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
       , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
         splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
       , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
       , splitqs#1(::(@x, @xs), @pivot) ->
         splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     The following weak DPs constitute a sub-graph of the DG that is
     closed under successors. The DPs are removed.
     
     { splitAndSort^#(@l) -> sortAll^#(split(@l))
     , sortAll^#(@l) -> sortAll#1^#(@l)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , quicksort^#(@l) -> c_3(quicksort#1^#(@l))
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       c_4(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
           quicksort^#(@xs),
           quicksort^#(@ys))
     , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
     , quicksort#1^#(::(@z, @zs)) ->
       c_8(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
       , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , quicksort#2(tuple#2(@xs, @ys), @z) ->
         append(quicksort(@xs), ::(@z, quicksort(@ys)))
       , split(@l) -> split#1(@l)
       , append(@l, @ys) -> append#1(@l, @ys)
       , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
         insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
       , #ckgt(#EQ()) -> #false()
       , #ckgt(#LT()) -> #false()
       , #ckgt(#GT()) -> #true()
       , insert(@x, @l) -> insert#1(@x, @l, @x)
       , insert#2(nil(), @keyX, @valX, @x) ->
         ::(tuple#2(::(@valX, nil()), @keyX), nil())
       , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
         insert#3(@l1, @keyX, @ls, @valX, @x)
       , #and(#true(), #true()) -> #true()
       , #and(#true(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#false(), #false()) -> #false()
       , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
       , #compare(#pos(@x), #0()) -> #GT()
       , #compare(#pos(@x), #neg(@y)) -> #GT()
       , #compare(#0(), #pos(@y)) -> #LT()
       , #compare(#0(), #0()) -> #EQ()
       , #compare(#0(), #neg(@y)) -> #GT()
       , #compare(#0(), #s(@y)) -> #LT()
       , #compare(#neg(@x), #pos(@y)) -> #LT()
       , #compare(#neg(@x), #0()) -> #LT()
       , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
       , #compare(#s(@x), #0()) -> #GT()
       , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
       , split#1(nil()) -> nil()
       , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
       , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
       , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(::(@valX, @vals1), @key1), @ls)
       , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
         ::(tuple#2(@vals1, @key1), insert(@x, @ls))
       , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
         insert#2(@l, @keyX, @valX, @x)
       , quicksort#1(nil()) -> nil()
       , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
       , append#1(nil(), @ys) -> @ys
       , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
       , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
       , quicksort(@l) -> quicksort#1(@l)
       , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
       , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
       , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
         splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
       , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
       , splitqs#1(::(@x, @xs), @pivot) ->
         splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     No rule is usable, rules are removed from the input problem.
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Rules: Empty
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     Empty rules are trivially bounded
   
   We return to the main proof.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^4)).
   
   Strict DPs:
     { append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys))
     , splitqs^#(@pivot, @l) -> c_9(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_10(splitqs^#(@pivot, @xs)) }
   Weak DPs:
     { splitAndSort^#(@l) -> sortAll^#(split(@l))
     , sortAll^#(@l) -> sortAll#1^#(@l)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , quicksort^#(@l) -> quicksort#1^#(@l)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
     , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
     , quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
     , quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^4))
   
   We use the processor 'matrix interpretation of dimension 2' to
   orient following rules strictly.
   
   DPs:
     { 4: splitqs#1^#(::(@x, @xs), @pivot) ->
          c_10(splitqs^#(@pivot, @xs))
     , 5: splitAndSort^#(@l) -> sortAll^#(split(@l))
     , 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , 12: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
           append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
     , 14: quicksort#1^#(::(@z, @zs)) ->
           quicksort#2^#(splitqs(@z, @zs), @z)
     , 15: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs) }
   Trs:
     { #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#s(@x), #0()) -> #false()
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , #and(#true(), #true()) -> #true()
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   
   Sub-proof:
   ----------
     The following argument positions are usable:
       Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_9) = {1},
       Uargs(c_10) = {1}
     
     TcT has computed the following constructor-based matrix
     interpretation satisfying not(EDA) and not(IDA(1)).
     
                         [#equal](x1, x2) = [0 3] x2 + [6]                               
                                            [0 0]      [0]                               
                                                                                         
                            [#eq](x1, x2) = [6]                                          
                                            [0]                                          
                                                                                         
                    [quicksort#2](x1, x2) = [1]                                          
                                            [0]                                          
                                                                                         
                              [split](x1) = [3 0] x1 + [7]                               
                                            [2 3]      [2]                               
                                                                                         
                                  [#true] = [4]                                          
                                            [0]                                          
                                                                                         
                         [append](x1, x2) = [0 0] x1 + [0]                               
                                            [0 3]      [0]                               
                                                                                         
           [insert#3](x1, x2, x3, x4, x5) = [0 0] x1 + [1 0] x3 + [6]                    
                                            [1 0]      [0 1]      [5]                    
                                                                                         
                              [#ckgt](x1) = [2 3] x1 + [0]                               
                                            [1 0]      [0]                               
                                                                                         
                         [insert](x1, x2) = [1 0] x2 + [3]                               
                                            [0 1]      [5]                               
                                                                                         
                               [#pos](x1) = [1 0] x1 + [4]                               
                                            [0 1]      [0]                               
                                                                                         
                                    [#EQ] = [0]                                          
                                            [2]                                          
                                                                                         
               [insert#2](x1, x2, x3, x4) = [1 0] x1 + [3]                               
                                            [0 1]      [5]                               
                                                                                         
                           [#and](x1, x2) = [5]                                          
                                            [0]                                          
                                                                                         
                       [#compare](x1, x2) = [0 0] x1 + [0 0] x2 + [0]                    
                                            [1 0]      [0 1]      [0]                    
                                                                                         
                        [tuple#2](x1, x2) = [1 0] x1 + [0 0] x2 + [1]                    
                                            [1 0]      [1 0]      [0]                    
                                                                                         
                                    [nil] = [1]                                          
                                            [2]                                          
                                                                                         
                            [split#1](x1) = [3 0] x1 + [6]                               
                                            [2 3]      [2]                               
                                                                                         
                       [#greater](x1, x2) = [3 0] x1 + [0 3] x2 + [0]                    
                                            [0 0]      [0 1]      [0]                    
                                                                                         
       [insert#4](x1, x2, x3, x4, x5, x6) = [0 0] x1 + [1 0] x3 + [0                     
                                                                   0] x5 + [6]           
                                            [0 1]      [0 1]      [1                     
                                                                   0]      [6]           
                                                                                         
                   [insert#1](x1, x2, x3) = [1 0] x2 + [3]                               
                                            [0 1]      [5]                               
                                                                                         
                        [quicksort#1](x1) = [3]                                          
                                            [4]                                          
                                                                                         
                       [append#1](x1, x2) = [0 0] x1 + [7 0] x2 + [3]                    
                                            [0 1]      [0 7]      [0]                    
                                                                                         
                        [splitqs](x1, x2) = [0 4] x1 + [4 5] x2 + [3]                    
                                            [0 0]      [1 0]      [1]                    
                                                                                         
                                 [#false] = [5]                                          
                                            [0]                                          
                                                                                         
                          [quicksort](x1) = [0 2] x1 + [5]                               
                                            [0 0]      [0]                               
                                                                                         
                             [::](x1, x2) = [0 0] x1 + [1 0] x2 + [3]                    
                                            [1 0]      [0 1]      [0]                    
                                                                                         
                                    [#LT] = [0]                                          
                                            [2]                                          
                                                                                         
              [splitqs#3](x1, x2, x3, x4) = [1 1] x1 + [1 0] x2 + [0                     
                                                                   0] x3 + [1 0] x4 + [0]
                                            [0 0]      [1 0]      [1                     
                                                                   0]      [0 0]      [3]
                                                                                         
                  [splitqs#2](x1, x2, x3) = [0 1] x1 + [0 4] x2 + [4                     
                                                                   0] x3 + [0]           
                                            [0 1]      [0 0]      [0                     
                                                                   0]      [3]           
                                                                                         
                                     [#0] = [4]                                          
                                            [0]                                          
                                                                                         
                               [#neg](x1) = [0 1] x1 + [4]                               
                                            [1 0]      [0]                               
                                                                                         
                                 [#s](x1) = [1 0] x1 + [5]                               
                                            [0 1]      [1]                               
                                                                                         
                                    [#GT] = [0]                                          
                                            [3]                                          
                                                                                         
                      [splitqs#1](x1, x2) = [1 4] x1 + [0 4] x2 + [2]                    
                                            [1 0]      [0 0]      [1]                    
                                                                                         
                     [splitAndSort^#](x1) = [7 7] x1 + [7]                               
                                            [7 7]      [7]                               
                                                                                         
                          [sortAll^#](x1) = [0 2] x1 + [1]                               
                                            [0 0]      [5]                               
                                                                                         
                    [sortAll#2^#](x1, x2) = [2 0] x1 + [0 2] x2 + [1]                    
                                            [0 0]      [0 0]      [5]                    
                                                                                         
                        [quicksort^#](x1) = [2 0] x1 + [3]                               
                                            [0 0]      [5]                               
                                                                                         
                  [quicksort#2^#](x1, x2) = [0 2] x1 + [3]                               
                                            [0 0]      [5]                               
                                                                                         
                       [append^#](x1, x2) = [0]                                          
                                            [1]                                          
                                                                                         
                     [append#1^#](x1, x2) = [0]                                          
                                            [1]                                          
                                                                                         
                        [sortAll#1^#](x1) = [0 2] x1 + [1]                               
                                            [0 0]      [5]                               
                                                                                         
                      [quicksort#1^#](x1) = [2 0] x1 + [3]                               
                                            [0 0]      [5]                               
                                                                                         
                      [splitqs^#](x1, x2) = [2 0] x2 + [2]                               
                                            [0 0]      [0]                               
                                                                                         
                    [splitqs#1^#](x1, x2) = [2 0] x1 + [0]                               
                                            [0 0]      [1]                               
                                                                                         
                                [c_5](x1) = [1 0] x1 + [0]                               
                                            [0 0]      [0]                               
                                                                                         
                                [c_6](x1) = [1 0] x1 + [0]                               
                                            [0 0]      [0]                               
                                                                                         
                                [c_9](x1) = [1 2] x1 + [0]                               
                                            [0 0]      [0]                               
                                                                                         
                               [c_10](x1) = [1 0] x1 + [0]                               
                                            [0 0]      [0]                               
     
     The order satisfies the following ordering constraints:
     
                                                [#equal(@x, @y)] =  [0 3] @y + [6]                                                 
                                                                    [0 0]      [0]                                                 
                                                                 >= [6]                                                            
                                                                    [0]                                                            
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                       [#eq(#pos(@x), #pos(@y))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >= [6]                                                            
                                                                    [0]                                                            
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                           [#eq(#pos(@x), #0())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#pos(@x), #neg(@y))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                 [#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                   
                               [#eq(tuple#2(@x_1, @x_2), nil())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                      [#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                               [#eq(nil(), tuple#2(@y_1, @y_2))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                             [#eq(nil(), nil())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [4]                                                            
                                                                    [0]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                    [#eq(nil(), ::(@y_1, @y_2))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                      [#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                    [#eq(::(@x_1, @x_2), nil())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                           [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                   
                                           [#eq(#0(), #pos(@y))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                               [#eq(#0(), #0())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [4]                                                            
                                                                    [0]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                           [#eq(#0(), #neg(@y))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                             [#eq(#0(), #s(@y))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#neg(@x), #pos(@y))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                           [#eq(#neg(@x), #0())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#neg(@x), #neg(@y))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >= [6]                                                            
                                                                    [0]                                                            
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                             [#eq(#s(@x), #0())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                           [#eq(#s(@x), #s(@y))] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >= [6]                                                            
                                                                    [0]                                                            
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                            [quicksort#2(tuple#2(@xs, @ys), @z)] =  [1]                                                            
                                                                    [0]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                 =  [append(quicksort(@xs), ::(@z, quicksort(@ys)))]               
                                                                                                                                   
                                                     [split(@l)] =  [3 0] @l + [7]                                                 
                                                                    [2 3]      [2]                                                 
                                                                 >  [3 0] @l + [6]                                                 
                                                                    [2 3]      [2]                                                 
                                                                 =  [split#1(@l)]                                                  
                                                                                                                                   
                                               [append(@l, @ys)] =  [0 0] @l + [0]                                                 
                                                                    [0 3]      [0]                                                 
                                                                 ?  [0 0] @l + [7 0] @ys + [3]                                     
                                                                    [0 1]      [0 7]       [0]                                     
                                                                 =  [append#1(@l, @ys)]                                            
                                                                                                                                   
       [insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] =  [1 0] @ls + [0 0] @vals1 + [6]                                 
                                                                    [0 1]       [1 0]          [6]                                 
                                                                 >= [1 0] @ls + [0 0] @vals1 + [6]                                 
                                                                    [0 1]       [1 0]          [6]                                 
                                                                 =  [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
                                                                                                                                   
                                                  [#ckgt(#EQ())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                                  [#ckgt(#LT())] =  [6]                                                            
                                                                    [0]                                                            
                                                                 >  [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                                  [#ckgt(#GT())] =  [9]                                                            
                                                                    [0]                                                            
                                                                 >  [4]                                                            
                                                                    [0]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                                [insert(@x, @l)] =  [1 0] @l + [3]                                                 
                                                                    [0 1]      [5]                                                 
                                                                 >= [1 0] @l + [3]                                                 
                                                                    [0 1]      [5]                                                 
                                                                 =  [insert#1(@x, @l, @x)]                                         
                                                                                                                                   
                             [insert#2(nil(), @keyX, @valX, @x)] =  [4]                                                            
                                                                    [7]                                                            
                                                                 >= [4]                                                            
                                                                    [7]                                                            
                                                                 =  [::(tuple#2(::(@valX, nil()), @keyX), nil())]                  
                                                                                                                                   
                      [insert#2(::(@l1, @ls), @keyX, @valX, @x)] =  [0 0] @l1 + [1 0] @ls + [6]                                    
                                                                    [1 0]       [0 1]       [5]                                    
                                                                 >= [0 0] @l1 + [1 0] @ls + [6]                                    
                                                                    [1 0]       [0 1]       [5]                                    
                                                                 =  [insert#3(@l1, @keyX, @ls, @valX, @x)]                         
                                                                                                                                   
                                        [#and(#true(), #true())] =  [5]                                                            
                                                                    [0]                                                            
                                                                 >  [4]                                                            
                                                                    [0]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                       [#and(#true(), #false())] =  [5]                                                            
                                                                    [0]                                                            
                                                                 >= [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#and(#false(), #true())] =  [5]                                                            
                                                                    [0]                                                            
                                                                 >= [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                      [#and(#false(), #false())] =  [5]                                                            
                                                                    [0]                                                            
                                                                 >= [5]                                                            
                                                                    [0]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                  [#compare(#pos(@x), #pos(@y))] =  [0 0] @x + [0 0] @y + [0]                                      
                                                                    [1 0]      [0 1]      [4]                                      
                                                                 >= [0 0] @x + [0 0] @y + [0]                                      
                                                                    [1 0]      [0 1]      [0]                                      
                                                                 =  [#compare(@x, @y)]                                             
                                                                                                                                   
                                      [#compare(#pos(@x), #0())] =  [0 0] @x + [0]                                                 
                                                                    [1 0]      [4]                                                 
                                                                 >= [0]                                                            
                                                                    [3]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                  [#compare(#pos(@x), #neg(@y))] =  [0 0] @x + [0 0] @y + [0]                                      
                                                                    [1 0]      [1 0]      [4]                                      
                                                                 >= [0]                                                            
                                                                    [3]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                      [#compare(#0(), #pos(@y))] =  [0 0] @y + [0]                                                 
                                                                    [0 1]      [4]                                                 
                                                                 >= [0]                                                            
                                                                    [2]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                          [#compare(#0(), #0())] =  [0]                                                            
                                                                    [4]                                                            
                                                                 >= [0]                                                            
                                                                    [2]                                                            
                                                                 =  [#EQ()]                                                        
                                                                                                                                   
                                      [#compare(#0(), #neg(@y))] =  [0 0] @y + [0]                                                 
                                                                    [1 0]      [4]                                                 
                                                                 >= [0]                                                            
                                                                    [3]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                        [#compare(#0(), #s(@y))] =  [0 0] @y + [0]                                                 
                                                                    [0 1]      [5]                                                 
                                                                 >= [0]                                                            
                                                                    [2]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                  [#compare(#neg(@x), #pos(@y))] =  [0 0] @x + [0 0] @y + [0]                                      
                                                                    [0 1]      [0 1]      [4]                                      
                                                                 >= [0]                                                            
                                                                    [2]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                      [#compare(#neg(@x), #0())] =  [0 0] @x + [0]                                                 
                                                                    [0 1]      [4]                                                 
                                                                 >= [0]                                                            
                                                                    [2]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                  [#compare(#neg(@x), #neg(@y))] =  [0 0] @x + [0 0] @y + [0]                                      
                                                                    [0 1]      [1 0]      [4]                                      
                                                                 >= [0 0] @x + [0 0] @y + [0]                                      
                                                                    [0 1]      [1 0]      [0]                                      
                                                                 =  [#compare(@y, @x)]                                             
                                                                                                                                   
                                        [#compare(#s(@x), #0())] =  [0 0] @x + [0]                                                 
                                                                    [1 0]      [5]                                                 
                                                                 >= [0]                                                            
                                                                    [3]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                      [#compare(#s(@x), #s(@y))] =  [0 0] @x + [0 0] @y + [0]                                      
                                                                    [1 0]      [0 1]      [6]                                      
                                                                 >= [0 0] @x + [0 0] @y + [0]                                      
                                                                    [1 0]      [0 1]      [0]                                      
                                                                 =  [#compare(@x, @y)]                                             
                                                                                                                                   
                                                [split#1(nil())] =  [9]                                                            
                                                                    [10]                                                           
                                                                 >  [1]                                                            
                                                                    [2]                                                            
                                                                 =  [nil()]                                                        
                                                                                                                                   
                                          [split#1(::(@x, @xs))] =  [0 0] @x + [3 0] @xs + [15]                                    
                                                                    [3 0]      [2 3]       [8]                                     
                                                                 >  [3 0] @xs + [10]                                               
                                                                    [2 3]       [7]                                                
                                                                 =  [insert(@x, split(@xs))]                                       
                                                                                                                                   
                                              [#greater(@x, @y)] =  [3 0] @x + [0 3] @y + [0]                                      
                                                                    [0 0]      [0 1]      [0]                                      
                                                                 >= [3 0] @x + [0 3] @y + [0]                                      
                                                                    [0 0]      [0 0]      [0]                                      
                                                                 =  [#ckgt(#compare(@x, @y))]                                      
                                                                                                                                   
              [insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] =  [1 0] @ls + [0 0] @vals1 + [6]                                 
                                                                    [0 1]       [1 0]          [6]                                 
                                                                 >  [1 0] @ls + [0 0] @vals1 + [3]                                 
                                                                    [0 1]       [1 0]          [4]                                 
                                                                 =  [::(tuple#2(::(@valX, @vals1), @key1), @ls)]                   
                                                                                                                                   
             [insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] =  [1 0] @ls + [0 0] @vals1 + [6]                                 
                                                                    [0 1]       [1 0]          [6]                                 
                                                                 >= [1 0] @ls + [0 0] @vals1 + [6]                                 
                                                                    [0 1]       [1 0]          [6]                                 
                                                                 =  [::(tuple#2(@vals1, @key1), insert(@x, @ls))]                  
                                                                                                                                   
                       [insert#1(tuple#2(@valX, @keyX), @l, @x)] =  [1 0] @l + [3]                                                 
                                                                    [0 1]      [5]                                                 
                                                                 >= [1 0] @l + [3]                                                 
                                                                    [0 1]      [5]                                                 
                                                                 =  [insert#2(@l, @keyX, @valX, @x)]                               
                                                                                                                                   
                                            [quicksort#1(nil())] =  [3]                                                            
                                                                    [4]                                                            
                                                                 >  [1]                                                            
                                                                    [2]                                                            
                                                                 =  [nil()]                                                        
                                                                                                                                   
                                      [quicksort#1(::(@z, @zs))] =  [3]                                                            
                                                                    [4]                                                            
                                                                 >  [1]                                                            
                                                                    [0]                                                            
                                                                 =  [quicksort#2(splitqs(@z, @zs), @z)]                            
                                                                                                                                   
                                          [append#1(nil(), @ys)] =  [7 0] @ys + [3]                                                
                                                                    [0 7]       [2]                                                
                                                                 >  [1 0] @ys + [0]                                                
                                                                    [0 1]       [0]                                                
                                                                 =  [@ys]                                                          
                                                                                                                                   
                                    [append#1(::(@x, @xs), @ys)] =  [0 0] @x + [7 0] @ys + [0 0] @xs + [3]                         
                                                                    [1 0]      [0 7]       [0 1]       [0]                         
                                                                 ?  [0 0] @x + [0 0] @xs + [3]                                     
                                                                    [1 0]      [0 3]       [0]                                     
                                                                 =  [::(@x, append(@xs, @ys))]                                     
                                                                                                                                   
                                           [splitqs(@pivot, @l)] =  [4 5] @l + [0 4] @pivot + [3]                                  
                                                                    [1 0]      [0 0]          [1]                                  
                                                                 >  [1 4] @l + [0 4] @pivot + [2]                                  
                                                                    [1 0]      [0 0]          [1]                                  
                                                                 =  [splitqs#1(@l, @pivot)]                                        
                                                                                                                                   
                                                 [quicksort(@l)] =  [0 2] @l + [5]                                                 
                                                                    [0 0]      [0]                                                 
                                                                 ?  [3]                                                            
                                                                    [4]                                                            
                                                                 =  [quicksort#1(@l)]                                              
                                                                                                                                   
                              [splitqs#3(#true(), @ls, @rs, @x)] =  [1 0] @x + [1 0] @ls + [0 0] @rs + [4]                         
                                                                    [0 0]      [1 0]       [1 0]       [3]                         
                                                                 >  [1 0] @ls + [0 0] @rs + [1]                                    
                                                                    [1 0]       [1 0]       [3]                                    
                                                                 =  [tuple#2(@ls, ::(@x, @rs))]                                    
                                                                                                                                   
                             [splitqs#3(#false(), @ls, @rs, @x)] =  [1 0] @x + [1 0] @ls + [0 0] @rs + [5]                         
                                                                    [0 0]      [1 0]       [1 0]       [3]                         
                                                                 >  [1 0] @ls + [0 0] @rs + [4]                                    
                                                                    [1 0]       [1 0]       [3]                                    
                                                                 =  [tuple#2(::(@x, @ls), @rs)]                                    
                                                                                                                                   
                      [splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] =  [4 0] @x + [1 0] @ls + [0 4] @pivot + [1 0] @rs + [0]          
                                                                    [0 0]      [1 0]       [0 0]          [1 0]       [3]          
                                                                 >= [4 0] @x + [1 0] @ls + [0 4] @pivot + [0 0] @rs + [0]          
                                                                    [0 0]      [1 0]       [0 0]          [1 0]       [3]          
                                                                 =  [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]                
                                                                                                                                   
                                      [splitqs#1(nil(), @pivot)] =  [0 4] @pivot + [11]                                            
                                                                    [0 0]          [2]                                             
                                                                 >  [2]                                                            
                                                                    [2]                                                            
                                                                 =  [tuple#2(nil(), nil())]                                        
                                                                                                                                   
                                [splitqs#1(::(@x, @xs), @pivot)] =  [4 0] @x + [1 4] @xs + [0 4] @pivot + [5]                      
                                                                    [0 0]      [1 0]       [0 0]          [4]                      
                                                                 >  [4 0] @x + [1 0] @xs + [0 4] @pivot + [1]                      
                                                                    [0 0]      [1 0]       [0 0]          [4]                      
                                                                 =  [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]                  
                                                                                                                                   
                                            [splitAndSort^#(@l)] =  [7 7] @l + [7]                                                 
                                                                    [7 7]      [7]                                                 
                                                                 >  [4 6] @l + [5]                                                 
                                                                    [0 0]      [5]                                                 
                                                                 =  [sortAll^#(split(@l))]                                         
                                                                                                                                   
                                                 [sortAll^#(@l)] =  [0 2] @l + [1]                                                 
                                                                    [0 0]      [5]                                                 
                                                                 >= [0 2] @l + [1]                                                 
                                                                    [0 0]      [5]                                                 
                                                                 =  [sortAll#1^#(@l)]                                              
                                                                                                                                   
                        [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [0 2] @xs + [2 0] @vals + [3]                                  
                                                                    [0 0]       [0 0]         [5]                                  
                                                                 >  [0 2] @xs + [1]                                                
                                                                    [0 0]       [5]                                                
                                                                 =  [sortAll^#(@xs)]                                               
                                                                                                                                   
                        [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [0 2] @xs + [2 0] @vals + [3]                                  
                                                                    [0 0]       [0 0]         [5]                                  
                                                                 >= [2 0] @vals + [3]                                              
                                                                    [0 0]         [5]                                              
                                                                 =  [quicksort^#(@vals)]                                           
                                                                                                                                   
                                               [quicksort^#(@l)] =  [2 0] @l + [3]                                                 
                                                                    [0 0]      [5]                                                 
                                                                 >= [2 0] @l + [3]                                                 
                                                                    [0 0]      [5]                                                 
                                                                 =  [quicksort#1^#(@l)]                                            
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [2 0] @ys + [2 0] @xs + [3]                                    
                                                                    [0 0]       [0 0]       [5]                                    
                                                                 >= [2 0] @xs + [3]                                                
                                                                    [0 0]       [5]                                                
                                                                 =  [quicksort^#(@xs)]                                             
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [2 0] @ys + [2 0] @xs + [3]                                    
                                                                    [0 0]       [0 0]       [5]                                    
                                                                 >= [2 0] @ys + [3]                                                
                                                                    [0 0]       [5]                                                
                                                                 =  [quicksort^#(@ys)]                                             
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [2 0] @ys + [2 0] @xs + [3]                                    
                                                                    [0 0]       [0 0]       [5]                                    
                                                                 >  [0]                                                            
                                                                    [1]                                                            
                                                                 =  [append^#(quicksort(@xs), ::(@z, quicksort(@ys)))]             
                                                                                                                                   
                                             [append^#(@l, @ys)] =  [0]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                 =  [c_5(append#1^#(@l, @ys))]                                     
                                                                                                                                   
                                  [append#1^#(::(@x, @xs), @ys)] =  [0]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                 =  [c_6(append^#(@xs, @ys))]                                      
                                                                                                                                   
                                      [sortAll#1^#(::(@x, @xs))] =  [2 0] @x + [0 2] @xs + [1]                                     
                                                                    [0 0]      [0 0]       [5]                                     
                                                                 >= [2 0] @x + [0 2] @xs + [1]                                     
                                                                    [0 0]      [0 0]       [5]                                     
                                                                 =  [sortAll#2^#(@x, @xs)]                                         
                                                                                                                                   
                                    [quicksort#1^#(::(@z, @zs))] =  [2 0] @zs + [9]                                                
                                                                    [0 0]       [5]                                                
                                                                 >  [2 0] @zs + [5]                                                
                                                                    [0 0]       [5]                                                
                                                                 =  [quicksort#2^#(splitqs(@z, @zs), @z)]                          
                                                                                                                                   
                                    [quicksort#1^#(::(@z, @zs))] =  [2 0] @zs + [9]                                                
                                                                    [0 0]       [5]                                                
                                                                 >  [2 0] @zs + [2]                                                
                                                                    [0 0]       [0]                                                
                                                                 =  [splitqs^#(@z, @zs)]                                           
                                                                                                                                   
                                         [splitqs^#(@pivot, @l)] =  [2 0] @l + [2]                                                 
                                                                    [0 0]      [0]                                                 
                                                                 >= [2 0] @l + [2]                                                 
                                                                    [0 0]      [0]                                                 
                                                                 =  [c_9(splitqs#1^#(@l, @pivot))]                                 
                                                                                                                                   
                              [splitqs#1^#(::(@x, @xs), @pivot)] =  [2 0] @xs + [6]                                                
                                                                    [0 0]       [1]                                                
                                                                 >  [2 0] @xs + [2]                                                
                                                                    [0 0]       [0]                                                
                                                                 =  [c_10(splitqs^#(@pivot, @xs))]                                 
                                                                                                                                   
   
   We return to the main proof. Consider the set of all dependency
   pairs
   
   :
     { 1: append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , 2: append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys))
     , 3: splitqs^#(@pivot, @l) -> c_9(splitqs#1^#(@l, @pivot))
     , 4: splitqs#1^#(::(@x, @xs), @pivot) ->
          c_10(splitqs^#(@pivot, @xs))
     , 5: splitAndSort^#(@l) -> sortAll^#(split(@l))
     , 6: sortAll^#(@l) -> sortAll#1^#(@l)
     , 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , 8: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , 9: quicksort^#(@l) -> quicksort#1^#(@l)
     , 10: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
     , 11: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
     , 12: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
           append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
     , 13: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
     , 14: quicksort#1^#(::(@z, @zs)) ->
           quicksort#2^#(splitqs(@z, @zs), @z)
     , 15: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs) }
   
   Processor 'matrix interpretation of dimension 2' induces the
   complexity certificate YES(?,O(n^1)) on application of dependency
   pairs {4,5,7,12,14,15}. These cover all (indirect) predecessors of
   dependency pairs {3,4,5,6,7,8,9,10,11,12,13,14,15}, their number of
   application is equally bounded. The dependency pairs are shifted
   into the weak component.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^4)).
   
   Strict DPs:
     { append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys)) }
   Weak DPs:
     { splitAndSort^#(@l) -> sortAll^#(split(@l))
     , sortAll^#(@l) -> sortAll#1^#(@l)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , quicksort^#(@l) -> quicksort#1^#(@l)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
     , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
     , quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
     , quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
     , splitqs^#(@pivot, @l) -> c_9(splitqs#1^#(@l, @pivot))
     , splitqs#1^#(::(@x, @xs), @pivot) ->
       c_10(splitqs^#(@pivot, @xs)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^4))
   
   The following weak DPs constitute a sub-graph of the DG that is
   closed under successors. The DPs are removed.
   
   { quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
   , splitqs^#(@pivot, @l) -> c_9(splitqs#1^#(@l, @pivot))
   , splitqs#1^#(::(@x, @xs), @pivot) ->
     c_10(splitqs^#(@pivot, @xs)) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^4)).
   
   Strict DPs:
     { append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys)) }
   Weak DPs:
     { splitAndSort^#(@l) -> sortAll^#(split(@l))
     , sortAll^#(@l) -> sortAll#1^#(@l)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , quicksort^#(@l) -> quicksort#1^#(@l)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
     , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
     , quicksort#1^#(::(@z, @zs)) ->
       quicksort#2^#(splitqs(@z, @zs), @z) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^4))
   
   We use the processor 'matrix interpretation of dimension 4' to
   orient following rules strictly.
   
   DPs: { append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys)) }
   
   The induced complexity on above rules (modulo remaining rules) is
   YES(?,O(n^4)) . These rules are moved into the corresponding weak
   component(s).
   
   Sub-proof:
   ----------
     The following argument positions are usable:
       Uargs(c_5) = {1}, Uargs(c_6) = {1}
     
     TcT has computed the following constructor-based matrix
     interpretation satisfying not(EDA).
     
                                            [0 1 0 0]      [0 1 0                                    
                                                            1]      [1]                              
                         [#equal](x1, x2) = [0 0 0 1] x1 + [0 1 0                                    
                                                            1] x2 + [1]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                                                                                                     
                                            [0 0 0 1]      [1]                                       
                            [#eq](x1, x2) = [0 1 0 1] x2 + [1]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 1 0 0]      [1 0 0                                    
                                                            0]      [0]                              
                    [quicksort#2](x1, x2) = [0 1 0 1] x1 + [1 0 0                                    
                                                            0] x2 + [1]                              
                                            [0 0 0 1]      [0 0 0                                    
                                                            0]      [1]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                                                                                                     
                                            [1 0 1 0]      [0]                                       
                              [split](x1) = [1 1 1 1] x1 + [0]                                       
                                            [0 0 1 1]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [1]                                                      
                                  [#true] = [1]                                                      
                                            [0]                                                      
                                            [1]                                                      
                                                                                                     
                                            [1 0 0 0]      [1 0 0                                    
                                                            0]      [0]                              
                         [append](x1, x2) = [1 0 1 0] x1 + [0 1 1                                    
                                                            0] x2 + [0]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [1 0 0 0]      [1 0 0                                    
                                                            0]      [1]                              
           [insert#3](x1, x2, x3, x4, x5) = [1 0 0 0] x1 + [0 0 1                                    
                                                            1] x3 + [1]                              
                                            [0 0 0 0]      [0 0 1                                    
                                                            1]      [1]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [0 0 0 0]      [1]                                       
                              [#ckgt](x1) = [0 1 0 0] x1 + [0]                                       
                                            [1 0 1 0]      [0]                                       
                                            [0 1 0 0]      [0]                                       
                                                                                                     
                                            [0 0 0 0]      [1 0 0                                    
                                                            0]      [1]                              
                         [insert](x1, x2) = [1 0 0 0] x1 + [1 0 1                                    
                                                            1] x2 + [0]                              
                                            [0 0 0 0]      [0 0 1                                    
                                                            1]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [1 0 0 0]      [1]                                       
                               [#pos](x1) = [1 1 0 0] x1 + [0]                                       
                                            [0 0 1 0]      [1]                                       
                                            [1 0 1 1]      [0]                                       
                                                                                                     
                                            [0]                                                      
                                    [#EQ] = [1]                                                      
                                            [0]                                                      
                                            [1]                                                      
                                                                                                     
                                            [1 0 0 0]      [1]                                       
               [insert#2](x1, x2, x3, x4) = [1 0 1 1] x1 + [0]                                       
                                            [0 0 1 1]      [0]                                       
                                            [0 0 0 1]      [0]                                       
                                                                                                     
                                            [0 0 1 0]      [0 0 0                                    
                                                            1]      [0]                              
                           [#and](x1, x2) = [0 0 0 0] x1 + [1 0 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                                                                                                     
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                       [#compare](x1, x2) = [1 0 0 0] x1 + [0 0 1                                    
                                                            0] x2 + [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                                                                                                     
                                            [0 0 1 0]      [0 0 0                                    
                                                            0]      [0]                              
                        [tuple#2](x1, x2) = [1 0 1 0] x1 + [1 0 1                                    
                                                            1] x2 + [0]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                                                                                     
                                            [0]                                                      
                                    [nil] = [0]                                                      
                                            [0]                                                      
                                            [1]                                                      
                                                                                                     
                                            [1 0 1 0]      [0]                                       
                            [split#1](x1) = [1 1 1 1] x1 + [0]                                       
                                            [0 0 1 1]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                       [#greater](x1, x2) = [1 0 0 0] x1 + [0 0 1                                    
                                                            1] x2 + [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                                            [1 0 0 0]      [0 0 1                                    
                                                            0]      [0]                              
                                                                                                     
                                            [0 0 0 0]      [1 0 0                                    
                                                            0]      [0 0 1 0]      [1]               
       [insert#4](x1, x2, x3, x4, x5, x6) = [0 0 0 0] x1 + [0 0 1                                    
                                                            1] x3 + [0 0 1 0] x5 + [1]               
                                            [0 0 1 1]      [0 0 1                                    
                                                            1]      [0 0 0 0]      [0]               
                                            [0 0 0 0]      [0 0 0                                    
                                                            1]      [0 0 0 0]      [0]               
                                                                                                     
                                            [1 0 0 0]      [1]                                       
                   [insert#1](x1, x2, x3) = [1 0 1 1] x2 + [0]                                       
                                            [0 0 1 1]      [0]                                       
                                            [0 0 0 1]      [0]                                       
                                                                                                     
                                            [1 0 1 0]      [0]                                       
                        [quicksort#1](x1) = [1 1 1 1] x1 + [1]                                       
                                            [0 0 1 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [1 0 0 0]      [1 0 0                                    
                                                            0]      [0]                              
                       [append#1](x1, x2) = [1 0 1 0] x1 + [0 1 1                                    
                                                            0] x2 + [0]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [0 0 0 1]      [1 0 1                                    
                                                            0]      [1]                              
                        [splitqs](x1, x2) = [0 0 0 0] x1 + [1 0 1                                    
                                                            0] x2 + [1]                              
                                            [0 0 1 1]      [1 1 1                                    
                                                            1]      [1]                              
                                            [0 0 0 0]      [0 0 1                                    
                                                            0]      [0]                              
                                                                                                     
                                            [0]                                                      
                                 [#false] = [0]                                                      
                                            [0]                                                      
                                            [1]                                                      
                                                                                                     
                                            [1 0 1 0]      [0]                                       
                          [quicksort](x1) = [1 1 1 1] x1 + [1]                                       
                                            [0 0 1 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [1 0 0 0]      [1 0 0                                    
                                                            0]      [0]                              
                             [::](x1, x2) = [1 0 0 0] x1 + [0 0 1                                    
                                                            0] x2 + [0]                              
                                            [0 0 0 0]      [0 0 1                                    
                                                            0]      [1]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [0]                                                      
                                    [#LT] = [1]                                                      
                                            [0]                                                      
                                            [1]                                                      
                                                                                                     
                                            [0 0 0 0]      [0 0 1                                    
                                                            0]      [0 0 0 0]      [0 0 0 0]      [1]
              [splitqs#3](x1, x2, x3, x4) = [0 0 0 0] x1 + [1 0 1                                    
                                                            0] x2 + [1 0 1 1] x3 + [1 0 0 0] x4 + [1]
                                            [1 0 1 1]      [0 0 1                                    
                                                            0]      [0 0 1 0]      [0 0 0 0]      [0]
                                            [0 0 0 0]      [0 0 1                                    
                                                            0]      [0 0 1 0]      [0 0 0 0]      [1]
                                                                                                     
                                            [0 1 0 0]      [0 0 0                                    
                                                            1]      [0 0 0 0]      [1]               
                  [splitqs#2](x1, x2, x3) = [0 1 0 0] x1 + [0 0 0                                    
                                                            0] x2 + [1 0 0 0] x3 + [1]               
                                            [1 0 0 1]      [0 0 1                                    
                                                            0]      [1 0 0 0]      [1]               
                                            [0 0 0 1]      [0 0 0                                    
                                                            0]      [0 0 0 0]      [1]               
                                                                                                     
                                            [1]                                                      
                                     [#0] = [0]                                                      
                                            [1]                                                      
                                            [0]                                                      
                                                                                                     
                                            [0 0 1 0]      [1]                                       
                               [#neg](x1) = [0 1 0 0] x1 + [1]                                       
                                            [1 0 0 0]      [1]                                       
                                            [1 0 1 1]      [0]                                       
                                                                                                     
                                            [1 0 0 0]      [1]                                       
                                 [#s](x1) = [0 1 0 0] x1 + [0]                                       
                                            [0 0 1 0]      [0]                                       
                                            [0 0 0 1]      [0]                                       
                                                                                                     
                                            [0]                                                      
                                    [#GT] = [1]                                                      
                                            [0]                                                      
                                            [1]                                                      
                                                                                                     
                                            [1 0 1 0]      [0 0 0                                    
                                                            1]      [1]                              
                      [splitqs#1](x1, x2) = [1 0 1 0] x1 + [0 0 0                                    
                                                            0] x2 + [1]                              
                                            [1 1 1 1]      [0 0 1                                    
                                                            1]      [1]                              
                                            [0 0 1 0]      [0 0 0                                    
                                                            0]      [0]                              
                                                                                                     
                                            [1 0 1 0]      [1]                                       
                     [splitAndSort^#](x1) = [1 1 1 1] x1 + [1]                                       
                                            [1 1 1 1]      [1]                                       
                                            [1 1 1 1]      [1]                                       
                                                                                                     
                                            [1 0 0 1]      [0]                                       
                          [sortAll^#](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [1 0 0 0]      [1 0 0                                    
                                                            1]      [0]                              
                    [sortAll#2^#](x1, x2) = [0 0 0 0] x1 + [0 0 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                                                                                                     
                                            [0 0 1 0]      [0]                                       
                        [quicksort^#](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 0 0 1]      [1]                                       
                  [quicksort#2^#](x1, x2) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 0 1 1]      [0]                                       
                       [append^#](x1, x2) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 0 1 1]      [0]                                       
                     [append#1^#](x1, x2) = [0 0 0 0] x1 + [1]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
                                                                                                     
                                            [1 0 0 1]      [0]                                       
                        [sortAll#1^#](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 0 1 0]      [0]                                       
                      [quicksort#1^#](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [1 0 0 0]      [0]                                       
                                [c_5](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [1 0 0 0]      [0]                                       
                                [c_6](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
     
     The order satisfies the following ordering constraints:
     
                                                [#equal(@x, @y)] =  [0 1 0 0]      [0 1 0 1]      [1]                              
                                                                    [0 0 0 1] @x + [0 1 0 1] @y + [1]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 >= [0 0 0 1]      [1]                                             
                                                                    [0 1 0 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                       [#eq(#pos(@x), #pos(@y))] =  [1 0 1 1]      [1]                                             
                                                                    [2 1 1 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 0 1]      [1]                                             
                                                                    [0 1 0 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                           [#eq(#pos(@x), #0())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#pos(@x), #neg(@y))] =  [1 0 1 1]      [1]                                             
                                                                    [1 1 1 1] @y + [2]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                 [#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [0 0 1 0]        [0 0 1 0]        [1]                          
                                                                    [1 0 2 0] @y_1 + [1 0 2 1] @y_2 + [1]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >= [0 0 0 0]        [1]                                           
                                                                    [0 0 0 1] @y_2 + [1]                                           
                                                                    [0 0 0 0]        [0]                                           
                                                                    [0 0 0 0]        [1]                                           
                                                                 =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                   
                               [#eq(tuple#2(@x_1, @x_2), nil())] =  [2]                                                            
                                                                    [2]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                      [#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] =  [0 0 0 0]        [0 0 0 1]        [1]                          
                                                                    [1 0 0 0] @y_1 + [0 0 1 1] @y_2 + [1]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                               [#eq(nil(), tuple#2(@y_1, @y_2))] =  [0 0 1 0]        [0 0 1 0]        [1]                          
                                                                    [1 0 2 0] @y_1 + [1 0 2 1] @y_2 + [1]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                             [#eq(nil(), nil())] =  [2]                                                            
                                                                    [2]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                    [#eq(nil(), ::(@y_1, @y_2))] =  [0 0 0 0]        [0 0 0 1]        [1]                          
                                                                    [1 0 0 0] @y_1 + [0 0 1 1] @y_2 + [1]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                      [#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [0 0 1 0]        [0 0 1 0]        [1]                          
                                                                    [1 0 2 0] @y_1 + [1 0 2 1] @y_2 + [1]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                    [#eq(::(@x_1, @x_2), nil())] =  [2]                                                            
                                                                    [2]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                           [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [0 0 0 0]        [0 0 0 1]        [1]                          
                                                                    [1 0 0 0] @y_1 + [0 0 1 1] @y_2 + [1]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >= [0 0 0 0]        [1]                                           
                                                                    [0 0 0 1] @y_2 + [1]                                           
                                                                    [0 0 0 0]        [0]                                           
                                                                    [0 0 0 0]        [1]                                           
                                                                 =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                   
                                           [#eq(#0(), #pos(@y))] =  [1 0 1 1]      [1]                                             
                                                                    [2 1 1 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                               [#eq(#0(), #0())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                           [#eq(#0(), #neg(@y))] =  [1 0 1 1]      [1]                                             
                                                                    [1 1 1 1] @y + [2]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                             [#eq(#0(), #s(@y))] =  [0 0 0 1]      [1]                                             
                                                                    [0 1 0 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#neg(@x), #pos(@y))] =  [1 0 1 1]      [1]                                             
                                                                    [2 1 1 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                           [#eq(#neg(@x), #0())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#neg(@x), #neg(@y))] =  [1 0 1 1]      [1]                                             
                                                                    [1 1 1 1] @y + [2]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 0 1]      [1]                                             
                                                                    [0 1 0 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                             [#eq(#s(@x), #0())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                           [#eq(#s(@x), #s(@y))] =  [0 0 0 1]      [1]                                             
                                                                    [0 1 0 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 0 1]      [1]                                             
                                                                    [0 1 0 1] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                            [quicksort#2(tuple#2(@xs, @ys), @z)] =  [1 0 1 1]       [1 0 1 0]       [1 0 0 0]      [0]             
                                                                    [1 0 2 1] @ys + [1 0 2 0] @xs + [1 0 0 0] @z + [1]             
                                                                    [0 0 1 0]       [0 0 1 0]       [0 0 0 0]      [1]             
                                                                    [0 0 0 0]       [0 0 0 0]       [0 0 0 0]      [1]             
                                                                 >= [1 0 1 0]       [1 0 1 0]       [1 0 0 0]      [0]             
                                                                    [0 0 2 0] @ys + [1 0 2 0] @xs + [1 0 0 0] @z + [1]             
                                                                    [0 0 1 0]       [0 0 1 0]       [0 0 0 0]      [1]             
                                                                    [0 0 0 0]       [0 0 0 0]       [0 0 0 0]      [1]             
                                                                 =  [append(quicksort(@xs), ::(@z, quicksort(@ys)))]               
                                                                                                                                   
                                                     [split(@l)] =  [1 0 1 0]      [0]                                             
                                                                    [1 1 1 1] @l + [0]                                             
                                                                    [0 0 1 1]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [1 0 1 0]      [0]                                             
                                                                    [1 1 1 1] @l + [0]                                             
                                                                    [0 0 1 1]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [split#1(@l)]                                                  
                                                                                                                                   
                                               [append(@l, @ys)] =  [1 0 0 0]      [1 0 0 0]       [0]                             
                                                                    [1 0 1 0] @l + [0 1 1 0] @ys + [0]                             
                                                                    [0 0 1 0]      [0 0 1 0]       [0]                             
                                                                    [0 0 0 0]      [0 0 0 1]       [0]                             
                                                                 >= [1 0 0 0]      [1 0 0 0]       [0]                             
                                                                    [1 0 1 0] @l + [0 1 1 0] @ys + [0]                             
                                                                    [0 0 1 0]      [0 0 1 0]       [0]                             
                                                                    [0 0 0 0]      [0 0 0 1]       [0]                             
                                                                 =  [append#1(@l, @ys)]                                            
                                                                                                                                   
       [insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] =  [1 0 0 0]       [0 0 1 0]          [1]                         
                                                                    [0 0 1 1] @ls + [0 0 1 0] @vals1 + [1]                         
                                                                    [0 0 1 1]       [0 0 0 0]          [1]                         
                                                                    [0 0 0 1]       [0 0 0 0]          [0]                         
                                                                 >= [1 0 0 0]       [0 0 1 0]          [1]                         
                                                                    [0 0 1 1] @ls + [0 0 1 0] @vals1 + [1]                         
                                                                    [0 0 1 1]       [0 0 0 0]          [1]                         
                                                                    [0 0 0 1]       [0 0 0 0]          [0]                         
                                                                 =  [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
                                                                                                                                   
                                                  [#ckgt(#EQ())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                                  [#ckgt(#LT())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                                  [#ckgt(#GT())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                                [insert(@x, @l)] =  [0 0 0 0]      [1 0 0 0]      [1]                              
                                                                    [1 0 0 0] @x + [1 0 1 1] @l + [0]                              
                                                                    [0 0 0 0]      [0 0 1 1]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 1]      [0]                              
                                                                 >= [1 0 0 0]      [1]                                             
                                                                    [1 0 1 1] @l + [0]                                             
                                                                    [0 0 1 1]      [0]                                             
                                                                    [0 0 0 1]      [0]                                             
                                                                 =  [insert#1(@x, @l, @x)]                                         
                                                                                                                                   
                             [insert#2(nil(), @keyX, @valX, @x)] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [1]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [::(tuple#2(::(@valX, nil()), @keyX), nil())]                  
                                                                                                                                   
                      [insert#2(::(@l1, @ls), @keyX, @valX, @x)] =  [1 0 0 0]       [1 0 0 0]       [1]                            
                                                                    [1 0 0 0] @l1 + [1 0 1 1] @ls + [1]                            
                                                                    [0 0 0 0]       [0 0 1 1]       [1]                            
                                                                    [0 0 0 0]       [0 0 0 1]       [0]                            
                                                                 >= [1 0 0 0]       [1 0 0 0]       [1]                            
                                                                    [1 0 0 0] @l1 + [0 0 1 1] @ls + [1]                            
                                                                    [0 0 0 0]       [0 0 1 1]       [1]                            
                                                                    [0 0 0 0]       [0 0 0 1]       [0]                            
                                                                 =  [insert#3(@l1, @keyX, @ls, @valX, @x)]                         
                                                                                                                                   
                                        [#and(#true(), #true())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                       [#and(#true(), #false())] =  [1]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#and(#false(), #true())] =  [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                      [#and(#false(), #false())] =  [1]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                  [#compare(#pos(@x), #pos(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [1 0 0 0] @x + [0 0 1 0] @y + [2]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 >= [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [1 0 0 0] @x + [0 0 1 0] @y + [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 =  [#compare(@x, @y)]                                             
                                                                                                                                   
                                      [#compare(#pos(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [1 0 0 0] @x + [2]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                  [#compare(#pos(@x), #neg(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [1 0 0 0] @x + [1 0 0 0] @y + [2]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                      [#compare(#0(), #pos(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 1 0] @y + [2]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                          [#compare(#0(), #0())] =  [0]                                                            
                                                                    [2]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#EQ()]                                                        
                                                                                                                                   
                                      [#compare(#0(), #neg(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [1 0 0 0] @y + [2]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                        [#compare(#0(), #s(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 1 0] @y + [1]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                  [#compare(#neg(@x), #pos(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 1 0] @x + [0 0 1 0] @y + [2]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                      [#compare(#neg(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 1 0] @x + [2]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                  [#compare(#neg(@x), #neg(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 1 0] @x + [1 0 0 0] @y + [2]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 >= [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 1 0] @x + [1 0 0 0] @y + [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 =  [#compare(@y, @x)]                                             
                                                                                                                                   
                                        [#compare(#s(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [1 0 0 0] @x + [2]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                      [#compare(#s(@x), #s(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [1 0 0 0] @x + [0 0 1 0] @y + [1]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 >= [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [1 0 0 0] @x + [0 0 1 0] @y + [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                 =  [#compare(@x, @y)]                                             
                                                                                                                                   
                                                [split#1(nil())] =  [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [nil()]                                                        
                                                                                                                                   
                                          [split#1(::(@x, @xs))] =  [1 0 0 0]      [1 0 1 0]       [1]                             
                                                                    [2 0 0 0] @x + [1 0 2 1] @xs + [1]                             
                                                                    [0 0 0 0]      [0 0 1 1]       [1]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [1]                             
                                                                 >= [0 0 0 0]      [1 0 1 0]       [1]                             
                                                                    [1 0 0 0] @x + [1 0 2 1] @xs + [1]                             
                                                                    [0 0 0 0]      [0 0 1 1]       [1]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [1]                             
                                                                 =  [insert(@x, split(@xs))]                                       
                                                                                                                                   
                                              [#greater(@x, @y)] =  [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                    [1 0 0 0] @x + [0 0 1 1] @y + [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [1 0 0 0]      [0 0 1 0]      [0]                              
                                                                 >= [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                    [1 0 0 0] @x + [0 0 1 0] @y + [0]                              
                                                                    [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [1 0 0 0]      [0 0 1 0]      [0]                              
                                                                 =  [#ckgt(#compare(@x, @y))]                                      
                                                                                                                                   
              [insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] =  [1 0 0 0]       [0 0 1 0]          [1]                         
                                                                    [0 0 1 1] @ls + [0 0 1 0] @vals1 + [1]                         
                                                                    [0 0 1 1]       [0 0 0 0]          [1]                         
                                                                    [0 0 0 1]       [0 0 0 0]          [0]                         
                                                                 >= [1 0 0 0]       [0 0 1 0]          [1]                         
                                                                    [0 0 1 0] @ls + [0 0 1 0] @vals1 + [1]                         
                                                                    [0 0 1 0]       [0 0 0 0]          [1]                         
                                                                    [0 0 0 1]       [0 0 0 0]          [0]                         
                                                                 =  [::(tuple#2(::(@valX, @vals1), @key1), @ls)]                   
                                                                                                                                   
             [insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] =  [1 0 0 0]       [0 0 1 0]          [1]                         
                                                                    [0 0 1 1] @ls + [0 0 1 0] @vals1 + [1]                         
                                                                    [0 0 1 1]       [0 0 0 0]          [1]                         
                                                                    [0 0 0 1]       [0 0 0 0]          [0]                         
                                                                 >= [1 0 0 0]       [0 0 1 0]          [1]                         
                                                                    [0 0 1 1] @ls + [0 0 1 0] @vals1 + [0]                         
                                                                    [0 0 1 1]       [0 0 0 0]          [1]                         
                                                                    [0 0 0 1]       [0 0 0 0]          [0]                         
                                                                 =  [::(tuple#2(@vals1, @key1), insert(@x, @ls))]                  
                                                                                                                                   
                       [insert#1(tuple#2(@valX, @keyX), @l, @x)] =  [1 0 0 0]      [1]                                             
                                                                    [1 0 1 1] @l + [0]                                             
                                                                    [0 0 1 1]      [0]                                             
                                                                    [0 0 0 1]      [0]                                             
                                                                 >= [1 0 0 0]      [1]                                             
                                                                    [1 0 1 1] @l + [0]                                             
                                                                    [0 0 1 1]      [0]                                             
                                                                    [0 0 0 1]      [0]                                             
                                                                 =  [insert#2(@l, @keyX, @valX, @x)]                               
                                                                                                                                   
                                            [quicksort#1(nil())] =  [0]                                                            
                                                                    [2]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [nil()]                                                        
                                                                                                                                   
                                      [quicksort#1(::(@z, @zs))] =  [1 0 0 0]      [1 0 1 0]       [1]                             
                                                                    [2 0 0 0] @z + [1 0 2 1] @zs + [2]                             
                                                                    [0 0 0 0]      [0 0 1 0]       [1]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [1]                             
                                                                 >= [1 0 0 0]      [1 0 1 0]       [1]                             
                                                                    [1 0 0 0] @z + [1 0 2 0] @zs + [2]                             
                                                                    [0 0 0 0]      [0 0 1 0]       [1]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [1]                             
                                                                 =  [quicksort#2(splitqs(@z, @zs), @z)]                            
                                                                                                                                   
                                          [append#1(nil(), @ys)] =  [1 0 0 0]       [0]                                            
                                                                    [0 1 1 0] @ys + [0]                                            
                                                                    [0 0 1 0]       [0]                                            
                                                                    [0 0 0 1]       [0]                                            
                                                                 >= [1 0 0 0]       [0]                                            
                                                                    [0 1 0 0] @ys + [0]                                            
                                                                    [0 0 1 0]       [0]                                            
                                                                    [0 0 0 1]       [0]                                            
                                                                 =  [@ys]                                                          
                                                                                                                                   
                                    [append#1(::(@x, @xs), @ys)] =  [1 0 0 0]      [1 0 0 0]       [1 0 0 0]       [0]             
                                                                    [1 0 0 0] @x + [0 1 1 0] @ys + [1 0 1 0] @xs + [1]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 0]       [0]             
                                                                 >= [1 0 0 0]      [1 0 0 0]       [1 0 0 0]       [0]             
                                                                    [1 0 0 0] @x + [0 0 1 0] @ys + [0 0 1 0] @xs + [0]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 0]       [0]             
                                                                 =  [::(@x, append(@xs, @ys))]                                     
                                                                                                                                   
                                           [splitqs(@pivot, @l)] =  [1 0 1 0]      [0 0 0 1]          [1]                          
                                                                    [1 0 1 0] @l + [0 0 0 0] @pivot + [1]                          
                                                                    [1 1 1 1]      [0 0 1 1]          [1]                          
                                                                    [0 0 1 0]      [0 0 0 0]          [0]                          
                                                                 >= [1 0 1 0]      [0 0 0 1]          [1]                          
                                                                    [1 0 1 0] @l + [0 0 0 0] @pivot + [1]                          
                                                                    [1 1 1 1]      [0 0 1 1]          [1]                          
                                                                    [0 0 1 0]      [0 0 0 0]          [0]                          
                                                                 =  [splitqs#1(@l, @pivot)]                                        
                                                                                                                                   
                                                 [quicksort(@l)] =  [1 0 1 0]      [0]                                             
                                                                    [1 1 1 1] @l + [1]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [1 0 1 0]      [0]                                             
                                                                    [1 1 1 1] @l + [1]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [quicksort#1(@l)]                                              
                                                                                                                                   
                              [splitqs#3(#true(), @ls, @rs, @x)] =  [0 0 0 0]      [0 0 1 0]       [0 0 0 0]       [1]             
                                                                    [1 0 0 0] @x + [1 0 1 0] @ls + [1 0 1 1] @rs + [1]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [2]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                 >  [0 0 0 0]      [0 0 1 0]       [0 0 0 0]       [0]             
                                                                    [1 0 0 0] @x + [1 0 1 0] @ls + [1 0 1 1] @rs + [1]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                 =  [tuple#2(@ls, ::(@x, @rs))]                                    
                                                                                                                                   
                             [splitqs#3(#false(), @ls, @rs, @x)] =  [0 0 0 0]      [0 0 1 0]       [0 0 0 0]       [1]             
                                                                    [1 0 0 0] @x + [1 0 1 0] @ls + [1 0 1 1] @rs + [1]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                 >= [0 0 0 0]      [0 0 1 0]       [0 0 0 0]       [1]             
                                                                    [1 0 0 0] @x + [1 0 1 0] @ls + [1 0 1 1] @rs + [1]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 1 0]       [1]             
                                                                 =  [tuple#2(::(@x, @ls), @rs)]                                    
                                                                                                                                   
                      [splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] =  [0 0 0 0]      [1 0 1 0]       [0 0 0 1]          [1 0 1       
                                                                                                                       1]       [1]
                                                                    [1 0 0 0] @x + [1 0 1 0] @ls + [0 0 0 0] @pivot + [1 0 1       
                                                                                                                       1] @rs + [1]
                                                                    [1 0 0 0]      [0 0 2 0]       [0 0 1 0]          [0 0 1       
                                                                                                                       0]       [1]
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 0 0]          [0 0 1       
                                                                                                                       0]       [1]
                                                                 >= [0 0 0 0]      [0 0 1 0]       [0 0 0 0]          [0 0 0       
                                                                                                                       0]       [1]
                                                                    [1 0 0 0] @x + [1 0 1 0] @ls + [0 0 0 0] @pivot + [1 0 1       
                                                                                                                       1] @rs + [1]
                                                                    [1 0 0 0]      [0 0 1 0]       [0 0 1 0]          [0 0 1       
                                                                                                                       0]       [1]
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 0 0]          [0 0 1       
                                                                                                                       0]       [1]
                                                                 =  [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]                
                                                                                                                                   
                                      [splitqs#1(nil(), @pivot)] =  [0 0 0 1]          [1]                                         
                                                                    [0 0 0 0] @pivot + [1]                                         
                                                                    [0 0 1 1]          [2]                                         
                                                                    [0 0 0 0]          [0]                                         
                                                                 >  [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                 =  [tuple#2(nil(), nil())]                                        
                                                                                                                                   
                                [splitqs#1(::(@x, @xs), @pivot)] =  [1 0 0 0]      [1 0 1 0]       [0 0 0 1]          [2]          
                                                                    [1 0 0 0] @x + [1 0 1 0] @xs + [0 0 0 0] @pivot + [2]          
                                                                    [2 0 0 0]      [1 0 2 1]       [0 0 1 1]          [2]          
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 0 0]          [1]          
                                                                 >= [0 0 0 0]      [1 0 1 0]       [0 0 0 1]          [2]          
                                                                    [1 0 0 0] @x + [1 0 1 0] @xs + [0 0 0 0] @pivot + [2]          
                                                                    [1 0 0 0]      [1 0 2 0]       [0 0 1 1]          [2]          
                                                                    [0 0 0 0]      [0 0 1 0]       [0 0 0 0]          [1]          
                                                                 =  [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]                  
                                                                                                                                   
                                            [splitAndSort^#(@l)] =  [1 0 1 0]      [1]                                             
                                                                    [1 1 1 1] @l + [1]                                             
                                                                    [1 1 1 1]      [1]                                             
                                                                    [1 1 1 1]      [1]                                             
                                                                 >= [1 0 1 0]      [1]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [sortAll^#(split(@l))]                                         
                                                                                                                                   
                                                 [sortAll^#(@l)] =  [1 0 0 1]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [1 0 0 1]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [sortAll#1^#(@l)]                                              
                                                                                                                                   
                        [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [1 0 0 1]       [0 0 1 0]         [0]                          
                                                                    [0 0 0 0] @xs + [0 0 0 0] @vals + [0]                          
                                                                    [0 0 0 0]       [0 0 0 0]         [0]                          
                                                                    [0 0 0 0]       [0 0 0 0]         [1]                          
                                                                 >= [1 0 0 1]       [0]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [1]                                            
                                                                 =  [sortAll^#(@xs)]                                               
                                                                                                                                   
                        [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [1 0 0 1]       [0 0 1 0]         [0]                          
                                                                    [0 0 0 0] @xs + [0 0 0 0] @vals + [0]                          
                                                                    [0 0 0 0]       [0 0 0 0]         [0]                          
                                                                    [0 0 0 0]       [0 0 0 0]         [1]                          
                                                                 >= [0 0 1 0]         [0]                                          
                                                                    [0 0 0 0] @vals + [0]                                          
                                                                    [0 0 0 0]         [0]                                          
                                                                    [0 0 0 0]         [1]                                          
                                                                 =  [quicksort^#(@vals)]                                           
                                                                                                                                   
                                               [quicksort^#(@l)] =  [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [quicksort#1^#(@l)]                                            
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [0 0 1 0]       [0 0 1 0]       [1]                            
                                                                    [0 0 0 0] @ys + [0 0 0 0] @xs + [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [1]                            
                                                                 >  [0 0 1 0]       [0]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [1]                                            
                                                                 =  [quicksort^#(@xs)]                                             
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [0 0 1 0]       [0 0 1 0]       [1]                            
                                                                    [0 0 0 0] @ys + [0 0 0 0] @xs + [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [1]                            
                                                                 >  [0 0 1 0]       [0]                                            
                                                                    [0 0 0 0] @ys + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [1]                                            
                                                                 =  [quicksort^#(@ys)]                                             
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [0 0 1 0]       [0 0 1 0]       [1]                            
                                                                    [0 0 0 0] @ys + [0 0 0 0] @xs + [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [1]                            
                                                                 >= [0 0 1 0]       [1]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [1]                                            
                                                                 =  [append^#(quicksort(@xs), ::(@z, quicksort(@ys)))]             
                                                                                                                                   
                                             [append^#(@l, @ys)] =  [0 0 1 1]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 1 1]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [c_5(append#1^#(@l, @ys))]                                     
                                                                                                                                   
                                  [append#1^#(::(@x, @xs), @ys)] =  [0 0 1 1]       [1]                                            
                                                                    [0 0 0 0] @xs + [1]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 >  [0 0 1 1]       [0]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 =  [c_6(append^#(@xs, @ys))]                                      
                                                                                                                                   
                                      [sortAll#1^#(::(@x, @xs))] =  [1 0 0 0]      [1 0 0 1]       [0]                             
                                                                    [0 0 0 0] @x + [0 0 0 0] @xs + [0]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [0]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [1]                             
                                                                 >= [1 0 0 0]      [1 0 0 1]       [0]                             
                                                                    [0 0 0 0] @x + [0 0 0 0] @xs + [0]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [0]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [1]                             
                                                                 =  [sortAll#2^#(@x, @xs)]                                         
                                                                                                                                   
                                    [quicksort#1^#(::(@z, @zs))] =  [0 0 1 0]       [1]                                            
                                                                    [0 0 0 0] @zs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [1]                                            
                                                                 >= [0 0 1 0]       [1]                                            
                                                                    [0 0 0 0] @zs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [1]                                            
                                                                 =  [quicksort#2^#(splitqs(@z, @zs), @z)]                          
                                                                                                                                   
   
   We return to the main proof.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^4)).
   
   Strict DPs: { append^#(@l, @ys) -> c_5(append#1^#(@l, @ys)) }
   Weak DPs:
     { splitAndSort^#(@l) -> sortAll^#(split(@l))
     , sortAll^#(@l) -> sortAll#1^#(@l)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , quicksort^#(@l) -> quicksort#1^#(@l)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys))
     , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
     , quicksort#1^#(::(@z, @zs)) ->
       quicksort#2^#(splitqs(@z, @zs), @z) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^4))
   
   We use the processor 'matrix interpretation of dimension 4' to
   orient following rules strictly.
   
   DPs: { append^#(@l, @ys) -> c_5(append#1^#(@l, @ys)) }
   
   The induced complexity on above rules (modulo remaining rules) is
   YES(?,O(n^4)) . These rules are moved into the corresponding weak
   component(s).
   
   Sub-proof:
   ----------
     The following argument positions are usable:
       Uargs(c_5) = {1}, Uargs(c_6) = {1}
     
     TcT has computed the following constructor-based matrix
     interpretation satisfying not(EDA).
     
                                            [0 0 0 0]      [0]                                       
                         [#equal](x1, x2) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 1 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 0 0 0]      [0]                                       
                            [#eq](x1, x2) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 1 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 1 0 0]      [0 0 0                                    
                                                            1]      [1]                              
                    [quicksort#2](x1, x2) = [0 1 0 0] x1 + [0 0 0                                    
                                                            0] x2 + [0]                              
                                            [1 0 1 0]      [0 0 0                                    
                                                            1]      [0]                              
                                            [1 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                                                                                                     
                                            [0 0 1 0]      [1]                                       
                              [split](x1) = [0 0 0 0] x1 + [1]                                       
                                            [0 1 0 1]      [1]                                       
                                            [0 0 0 1]      [1]                                       
                                                                                                     
                                            [0]                                                      
                                  [#true] = [0]                                                      
                                            [1]                                                      
                                            [1]                                                      
                                                                                                     
                                            [0 0 0 0]      [1 1 0                                    
                                                            0]      [0]                              
                         [append](x1, x2) = [0 0 0 0] x1 + [0 1 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                            [0 0 0 1]      [0 0 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [0 0 0 0]      [0 1 0                                    
                                                            0]      [0 0 0 1]      [0]               
           [insert#3](x1, x2, x3, x4, x5) = [0 0 0 0] x1 + [0 1 0                                    
                                                            0] x3 + [0 0 0 0] x4 + [0]               
                                            [0 0 0 1]      [0 0 1                                    
                                                            0]      [0 0 0 0]      [1]               
                                            [0 0 0 0]      [0 1 0                                    
                                                            1]      [0 0 0 0]      [1]               
                                                                                                     
                                            [0 0 0 0]      [0]                                       
                              [#ckgt](x1) = [0 0 0 0] x1 + [0]                                       
                                            [1 1 0 1]      [0]                                       
                                            [0 0 1 0]      [0]                                       
                                                                                                     
                                            [0 0 0 1]      [1 0 0                                    
                                                            0]      [0]                              
                         [insert](x1, x2) = [0 0 0 0] x1 + [0 1 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 0 0]      [0 0 1                                    
                                                            0]      [1]                              
                                            [0 0 0 0]      [0 1 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [1 0 0 0]      [1]                                       
                               [#pos](x1) = [0 1 0 0] x1 + [1]                                       
                                            [0 0 1 0]      [1]                                       
                                            [1 0 0 0]      [1]                                       
                                                                                                     
                                            [0]                                                      
                                    [#EQ] = [0]                                                      
                                            [1]                                                      
                                            [0]                                                      
                                                                                                     
                                            [1 0 0 0]      [0 0 0                                    
                                                            1]      [0]                              
               [insert#2](x1, x2, x3, x4) = [0 1 0 0] x1 + [0 0 0                                    
                                                            0] x3 + [0]                              
                                            [0 0 1 0]      [0 0 0                                    
                                                            0]      [1]                              
                                            [0 1 0 1]      [0 0 0                                    
                                                            0]      [0]                              
                                                                                                     
                                            [0 0 0 0]      [0]                                       
                           [#and](x1, x2) = [0 0 0 0] x2 + [0]                                       
                                            [0 0 1 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                       [#compare](x1, x2) = [0 0 0 0] x1 + [0 0 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                            [1 0 0 0]      [1 0 0                                    
                                                            0]      [0]                              
                                                                                                     
                                            [0 0 0 1]      [0 0 0                                    
                                                            1]      [0]                              
                        [tuple#2](x1, x2) = [0 0 0 0] x1 + [0 0 0                                    
                                                            0] x2 + [1]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                            [0 0 0 1]      [0 0 0                                    
                                                            0]      [0]                              
                                                                                                     
                                            [1]                                                      
                                    [nil] = [1]                                                      
                                            [1]                                                      
                                            [0]                                                      
                                                                                                     
                                            [0 0 1 0]      [1]                                       
                            [split#1](x1) = [0 0 0 0] x1 + [1]                                       
                                            [0 1 0 1]      [1]                                       
                                            [0 0 0 1]      [1]                                       
                                                                                                     
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                       [#greater](x1, x2) = [0 0 0 0] x1 + [0 0 0                                    
                                                            0] x2 + [0]                              
                                            [1 0 0 0]      [1 1 0                                    
                                                            0]      [0]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                                                                                     
                                            [0 0 0 0]      [0 1 0                                    
                                                            0]      [0 0 0 1]      [0 0 0 0]      [0]
       [insert#4](x1, x2, x3, x4, x5, x6) = [0 0 0 0] x1 + [0 1 0                                    
                                                            0] x3 + [0 0 0 0] x4 + [0 0 0 0] x5 + [0]
                                            [1 0 0 1]      [0 0 1                                    
                                                            0]      [0 0 0 0]      [0 0 0 1]      [0]
                                            [0 0 0 0]      [0 1 0                                    
                                                            1]      [0 0 0 0]      [0 0 0 0]      [1]
                                                                                                     
                                            [0 0 0 1]      [1 0 0                                    
                                                            0]      [0]                              
                   [insert#1](x1, x2, x3) = [0 0 0 0] x1 + [0 1 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 0 0]      [0 0 1                                    
                                                            0]      [1]                              
                                            [0 0 0 0]      [0 1 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [0 0 1 1]      [1]                                       
                        [quicksort#1](x1) = [0 0 0 0] x1 + [1]                                       
                                            [0 0 1 1]      [0]                                       
                                            [0 0 0 1]      [0]                                       
                                                                                                     
                                            [0 0 0 0]      [1 1 0                                    
                                                            0]      [0]                              
                       [append#1](x1, x2) = [0 0 0 0] x1 + [0 1 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 1 0]      [0 0 1                                    
                                                            0]      [0]                              
                                            [0 0 0 1]      [0 0 0                                    
                                                            1]      [0]                              
                                                                                                     
                                            [0 0 0 1]      [0]                                       
                        [splitqs](x1, x2) = [0 0 0 0] x2 + [1]                                       
                                            [0 0 1 0]      [1]                                       
                                            [1 0 0 1]      [0]                                       
                                                                                                     
                                            [0]                                                      
                                 [#false] = [0]                                                      
                                            [0]                                                      
                                            [1]                                                      
                                                                                                     
                                            [0 0 1 1]      [1]                                       
                          [quicksort](x1) = [0 0 0 0] x1 + [1]                                       
                                            [0 0 1 1]      [0]                                       
                                            [0 0 0 1]      [0]                                       
                                                                                                     
                                            [0 0 0 0]      [0 1 0                                    
                                                            0]      [0]                              
                             [::](x1, x2) = [0 0 0 0] x1 + [0 1 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 0 1]      [0 0 1                                    
                                                            0]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            1]      [1]                              
                                                                                                     
                                            [0]                                                      
                                    [#LT] = [0]                                                      
                                            [1]                                                      
                                            [0]                                                      
                                                                                                     
                                            [0 0 0 0]      [0 0 0                                    
                                                            1]      [0 0 0 1]      [0 0 0 0]      [1]
              [splitqs#3](x1, x2, x3, x4) = [0 0 0 0] x1 + [0 0 0                                    
                                                            0] x2 + [0 0 0 0] x3 + [0 0 0 0] x4 + [1]
                                            [0 0 0 0]      [0 0 1                                    
                                                            0]      [0 0 1 0]      [0 0 0 1]      [0]
                                            [0 1 0 0]      [0 0 0                                    
                                                            1]      [0 0 0 0]      [0 0 0 0]      [1]
                                                                                                     
                                            [1 1 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                  [splitqs#2](x1, x2, x3) = [0 1 0 0] x1 + [0 0 0                                    
                                                            0] x3 + [0]                              
                                            [0 0 1 0]      [0 0 0                                    
                                                            1]      [0]                              
                                            [1 0 0 0]      [0 0 0                                    
                                                            0]      [1]                              
                                                                                                     
                                            [1]                                                      
                                     [#0] = [1]                                                      
                                            [1]                                                      
                                            [1]                                                      
                                                                                                     
                                            [1 0 0 0]      [0]                                       
                               [#neg](x1) = [0 1 0 0] x1 + [0]                                       
                                            [0 1 1 0]      [0]                                       
                                            [0 0 0 0]      [1]                                       
                                                                                                     
                                            [1 0 0 0]      [0]                                       
                                 [#s](x1) = [0 1 0 0] x1 + [1]                                       
                                            [0 0 1 0]      [0]                                       
                                            [0 0 0 1]      [0]                                       
                                                                                                     
                                            [0]                                                      
                                    [#GT] = [0]                                                      
                                            [1]                                                      
                                            [1]                                                      
                                                                                                     
                                            [0 0 0 1]      [0]                                       
                      [splitqs#1](x1, x2) = [0 0 0 0] x1 + [1]                                       
                                            [0 0 1 0]      [1]                                       
                                            [1 0 0 1]      [0]                                       
                                                                                                     
                                            [1 1 0 1]      [1]                                       
                     [splitAndSort^#](x1) = [1 1 1 1] x1 + [1]                                       
                                            [1 1 1 1]      [1]                                       
                                            [1 1 1 1]      [1]                                       
                                                                                                     
                                            [0 0 1 0]      [0]                                       
                          [sortAll^#](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
                                                                                                     
                                            [0 0 0 1]      [0 0 1                                    
                                                            0]      [0]                              
                    [sortAll#2^#](x1, x2) = [0 0 0 0] x1 + [0 0 0                                    
                                                            0] x2 + [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                                            [0 0 0 0]      [0 0 0                                    
                                                            0]      [0]                              
                                                                                                     
                                            [0 0 0 1]      [0]                                       
                        [quicksort^#](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
                                                                                                     
                                            [1 0 0 0]      [1]                                       
                  [quicksort#2^#](x1, x2) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
                                                                                                     
                                            [0 0 0 1]      [1]                                       
                       [append^#](x1, x2) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
                                                                                                     
                                            [0 0 0 1]      [0]                                       
                     [append#1^#](x1, x2) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [1]                                       
                                            [1 0 0 0]      [1]                                       
                                                                                                     
                                            [0 0 1 0]      [0]                                       
                        [sortAll#1^#](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
                                                                                                     
                                            [0 0 0 1]      [0]                                       
                      [quicksort#1^#](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
                                                                                                     
                                            [1 0 0 0]      [0]                                       
                                [c_5](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
                                                                                                     
                                            [1 0 0 0]      [0]                                       
                                [c_6](x1) = [0 0 0 0] x1 + [0]                                       
                                            [0 0 0 0]      [0]                                       
                                            [0 0 0 0]      [0]                                       
     
     The order satisfies the following ordering constraints:
     
                                                [#equal(@x, @y)] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                       [#eq(#pos(@x), #pos(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [1]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                           [#eq(#pos(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [1]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#pos(@x), #neg(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [1]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                 [#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0] @x_1 + [0 0 0 0] @x_2 + [0]                          
                                                                    [0 0 1 0]        [0 0 1 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >= [0 0 0 0]        [0]                                           
                                                                    [0 0 0 0] @x_2 + [0]                                           
                                                                    [0 0 1 0]        [0]                                           
                                                                    [0 0 0 0]        [1]                                           
                                                                 =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                   
                               [#eq(tuple#2(@x_1, @x_2), nil())] =  [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0] @x_1 + [0 0 0 0] @x_2 + [0]                          
                                                                    [0 0 1 0]        [0 0 1 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                      [#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] =  [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0] @x_1 + [0 0 0 0] @x_2 + [0]                          
                                                                    [0 0 1 0]        [0 0 1 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                               [#eq(nil(), tuple#2(@y_1, @y_2))] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                             [#eq(nil(), nil())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                    [#eq(nil(), ::(@y_1, @y_2))] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                      [#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] =  [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0] @x_1 + [0 0 0 0] @x_2 + [0]                          
                                                                    [0 0 0 1]        [0 0 1 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                    [#eq(::(@x_1, @x_2), nil())] =  [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0] @x_1 + [0 0 0 0] @x_2 + [0]                          
                                                                    [0 0 0 1]        [0 0 1 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                           [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [0 0 0 0]        [0 0 0 0]        [0]                          
                                                                    [0 0 0 0] @x_1 + [0 0 0 0] @x_2 + [0]                          
                                                                    [0 0 0 1]        [0 0 1 0]        [0]                          
                                                                    [0 0 0 0]        [0 0 0 0]        [1]                          
                                                                 >= [0 0 0 0]        [0]                                           
                                                                    [0 0 0 0] @x_2 + [0]                                           
                                                                    [0 0 1 0]        [0]                                           
                                                                    [0 0 0 0]        [1]                                           
                                                                 =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                       
                                                                                                                                   
                                           [#eq(#0(), #pos(@y))] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                               [#eq(#0(), #0())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                           [#eq(#0(), #neg(@y))] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                             [#eq(#0(), #s(@y))] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#neg(@x), #pos(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 1 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                           [#eq(#neg(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 1 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#eq(#neg(@x), #neg(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 1 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                                             [#eq(#s(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                           [#eq(#s(@x), #s(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 >= [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0]      [1]                                             
                                                                 =  [#eq(@x, @y)]                                                  
                                                                                                                                   
                            [quicksort#2(tuple#2(@xs, @ys), @z)] =  [0 0 0 0]       [0 0 0 0]       [0 0 0 1]      [2]             
                                                                    [0 0 0 0] @ys + [0 0 0 0] @xs + [0 0 0 0] @z + [1]             
                                                                    [0 0 1 1]       [0 0 1 1]       [0 0 0 1]      [0]             
                                                                    [0 0 0 1]       [0 0 0 1]       [0 0 0 0]      [1]             
                                                                 >= [0 0 0 0]       [0 0 0 0]       [0 0 0 0]      [2]             
                                                                    [0 0 0 0] @ys + [0 0 0 0] @xs + [0 0 0 0] @z + [1]             
                                                                    [0 0 1 1]       [0 0 1 1]       [0 0 0 1]      [0]             
                                                                    [0 0 0 1]       [0 0 0 1]       [0 0 0 0]      [1]             
                                                                 =  [append(quicksort(@xs), ::(@z, quicksort(@ys)))]               
                                                                                                                                   
                                                     [split(@l)] =  [0 0 1 0]      [1]                                             
                                                                    [0 0 0 0] @l + [1]                                             
                                                                    [0 1 0 1]      [1]                                             
                                                                    [0 0 0 1]      [1]                                             
                                                                 >= [0 0 1 0]      [1]                                             
                                                                    [0 0 0 0] @l + [1]                                             
                                                                    [0 1 0 1]      [1]                                             
                                                                    [0 0 0 1]      [1]                                             
                                                                 =  [split#1(@l)]                                                  
                                                                                                                                   
                                               [append(@l, @ys)] =  [0 0 0 0]      [1 1 0 0]       [0]                             
                                                                    [0 0 0 0] @l + [0 1 0 0] @ys + [0]                             
                                                                    [0 0 1 0]      [0 0 1 0]       [0]                             
                                                                    [0 0 0 1]      [0 0 0 1]       [0]                             
                                                                 >= [0 0 0 0]      [1 1 0 0]       [0]                             
                                                                    [0 0 0 0] @l + [0 1 0 0] @ys + [0]                             
                                                                    [0 0 1 0]      [0 0 1 0]       [0]                             
                                                                    [0 0 0 1]      [0 0 0 1]       [0]                             
                                                                 =  [append#1(@l, @ys)]                                            
                                                                                                                                   
       [insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] =  [0 0 0 1]         [0 1 0 0]       [0 0 0 0]          [0]       
                                                                    [0 0 0 0] @valX + [0 1 0 0] @ls + [0 0 0 0] @vals1 + [0]       
                                                                    [0 0 0 0]         [0 0 1 0]       [0 0 0 1]          [1]       
                                                                    [0 0 0 0]         [0 1 0 1]       [0 0 0 0]          [1]       
                                                                 >= [0 0 0 1]         [0 1 0 0]       [0 0 0 0]          [0]       
                                                                    [0 0 0 0] @valX + [0 1 0 0] @ls + [0 0 0 0] @vals1 + [0]       
                                                                    [0 0 0 0]         [0 0 1 0]       [0 0 0 1]          [1]       
                                                                    [0 0 0 0]         [0 1 0 1]       [0 0 0 0]          [1]       
                                                                 =  [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
                                                                                                                                   
                                                  [#ckgt(#EQ())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                                  [#ckgt(#LT())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                                  [#ckgt(#GT())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                                [insert(@x, @l)] =  [0 0 0 1]      [1 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 1 0 0] @l + [0]                              
                                                                    [0 0 0 0]      [0 0 1 0]      [1]                              
                                                                    [0 0 0 0]      [0 1 0 1]      [0]                              
                                                                 >= [0 0 0 1]      [1 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 1 0 0] @l + [0]                              
                                                                    [0 0 0 0]      [0 0 1 0]      [1]                              
                                                                    [0 0 0 0]      [0 1 0 1]      [0]                              
                                                                 =  [insert#1(@x, @l, @x)]                                         
                                                                                                                                   
                             [insert#2(nil(), @keyX, @valX, @x)] =  [0 0 0 1]         [1]                                          
                                                                    [0 0 0 0] @valX + [1]                                          
                                                                    [0 0 0 0]         [2]                                          
                                                                    [0 0 0 0]         [1]                                          
                                                                 >= [1]                                                            
                                                                    [1]                                                            
                                                                    [2]                                                            
                                                                    [1]                                                            
                                                                 =  [::(tuple#2(::(@valX, nil()), @keyX), nil())]                  
                                                                                                                                   
                      [insert#2(::(@l1, @ls), @keyX, @valX, @x)] =  [0 0 0 1]         [0 0 0 0]       [0 1 0 0]       [0]          
                                                                    [0 0 0 0] @valX + [0 0 0 0] @l1 + [0 1 0 0] @ls + [0]          
                                                                    [0 0 0 0]         [0 0 0 1]       [0 0 1 0]       [1]          
                                                                    [0 0 0 0]         [0 0 0 0]       [0 1 0 1]       [1]          
                                                                 >= [0 0 0 1]         [0 0 0 0]       [0 1 0 0]       [0]          
                                                                    [0 0 0 0] @valX + [0 0 0 0] @l1 + [0 1 0 0] @ls + [0]          
                                                                    [0 0 0 0]         [0 0 0 1]       [0 0 1 0]       [1]          
                                                                    [0 0 0 0]         [0 0 0 0]       [0 1 0 1]       [1]          
                                                                 =  [insert#3(@l1, @keyX, @ls, @valX, @x)]                         
                                                                                                                                   
                                        [#and(#true(), #true())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [#true()]                                                      
                                                                                                                                   
                                       [#and(#true(), #false())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                       [#and(#false(), #true())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                      [#and(#false(), #false())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                 =  [#false()]                                                     
                                                                                                                                   
                                  [#compare(#pos(@x), #pos(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [0 0 1 0]      [0 0 1 0]      [2]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [2]                              
                                                                 >= [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [0 0 1 0]      [0 0 1 0]      [0]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [0]                              
                                                                 =  [#compare(@x, @y)]                                             
                                                                                                                                   
                                      [#compare(#pos(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [2]                                             
                                                                    [1 0 0 0]      [2]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                  [#compare(#pos(@x), #neg(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [0 0 1 0]      [0 1 1 0]      [1]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [1]                              
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                      [#compare(#0(), #pos(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @y + [0]                                             
                                                                    [0 0 1 0]      [2]                                             
                                                                    [1 0 0 0]      [2]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                          [#compare(#0(), #0())] =  [0]                                                            
                                                                    [0]                                                            
                                                                    [2]                                                            
                                                                    [2]                                                            
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                 =  [#EQ()]                                                        
                                                                                                                                   
                                      [#compare(#0(), #neg(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @y + [0]                                             
                                                                    [0 1 1 0]      [1]                                             
                                                                    [1 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                        [#compare(#0(), #s(@y))] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @y + [0]                                             
                                                                    [0 0 1 0]      [1]                                             
                                                                    [1 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                  [#compare(#neg(@x), #pos(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [0 1 1 0]      [0 0 1 0]      [1]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [1]                              
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                      [#compare(#neg(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 1 1 0]      [1]                                             
                                                                    [1 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                 =  [#LT()]                                                        
                                                                                                                                   
                                  [#compare(#neg(@x), #neg(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [0 1 1 0]      [0 1 1 0]      [0]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [0]                              
                                                                 >= [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [0 0 1 0]      [0 0 1 0]      [0]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [0]                              
                                                                 =  [#compare(@y, @x)]                                             
                                                                                                                                   
                                        [#compare(#s(@x), #0())] =  [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0] @x + [0]                                             
                                                                    [0 0 1 0]      [1]                                             
                                                                    [1 0 0 0]      [1]                                             
                                                                 >= [0]                                                            
                                                                    [0]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                 =  [#GT()]                                                        
                                                                                                                                   
                                      [#compare(#s(@x), #s(@y))] =  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [0 0 1 0]      [0 0 1 0]      [0]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [0]                              
                                                                 >= [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [0 0 1 0]      [0 0 1 0]      [0]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [0]                              
                                                                 =  [#compare(@x, @y)]                                             
                                                                                                                                   
                                                [split#1(nil())] =  [2]                                                            
                                                                    [1]                                                            
                                                                    [2]                                                            
                                                                    [1]                                                            
                                                                 >  [1]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                 =  [nil()]                                                        
                                                                                                                                   
                                          [split#1(::(@x, @xs))] =  [0 0 0 1]      [0 0 1 0]       [1]                             
                                                                    [0 0 0 0] @x + [0 0 0 0] @xs + [1]                             
                                                                    [0 0 0 0]      [0 1 0 1]       [2]                             
                                                                    [0 0 0 0]      [0 0 0 1]       [2]                             
                                                                 >= [0 0 0 1]      [0 0 1 0]       [1]                             
                                                                    [0 0 0 0] @x + [0 0 0 0] @xs + [1]                             
                                                                    [0 0 0 0]      [0 1 0 1]       [2]                             
                                                                    [0 0 0 0]      [0 0 0 1]       [2]                             
                                                                 =  [insert(@x, split(@xs))]                                       
                                                                                                                                   
                                              [#greater(@x, @y)] =  [0 0 0 0]      [0 0 0 0]      [1]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [1 0 0 0]      [1 1 0 0]      [0]                              
                                                                    [0 0 1 0]      [0 0 1 0]      [0]                              
                                                                 >  [0 0 0 0]      [0 0 0 0]      [0]                              
                                                                    [0 0 0 0] @x + [0 0 0 0] @y + [0]                              
                                                                    [1 0 0 0]      [1 0 0 0]      [0]                              
                                                                    [0 0 1 0]      [0 0 1 0]      [0]                              
                                                                 =  [#ckgt(#compare(@x, @y))]                                      
                                                                                                                                   
              [insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] =  [0 0 0 1]         [0 1 0 0]       [0 0 0 0]          [0]       
                                                                    [0 0 0 0] @valX + [0 1 0 0] @ls + [0 0 0 0] @vals1 + [0]       
                                                                    [0 0 0 0]         [0 0 1 0]       [0 0 0 1]          [1]       
                                                                    [0 0 0 0]         [0 1 0 1]       [0 0 0 0]          [1]       
                                                                 >= [0 1 0 0]       [0 0 0 0]          [0]                         
                                                                    [0 1 0 0] @ls + [0 0 0 0] @vals1 + [0]                         
                                                                    [0 0 1 0]       [0 0 0 1]          [1]                         
                                                                    [0 0 0 1]       [0 0 0 0]          [1]                         
                                                                 =  [::(tuple#2(::(@valX, @vals1), @key1), @ls)]                   
                                                                                                                                   
             [insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] =  [0 0 0 1]         [0 1 0 0]       [0 0 0 0]          [0]       
                                                                    [0 0 0 0] @valX + [0 1 0 0] @ls + [0 0 0 0] @vals1 + [0]       
                                                                    [0 0 0 0]         [0 0 1 0]       [0 0 0 1]          [1]       
                                                                    [0 0 0 0]         [0 1 0 1]       [0 0 0 0]          [1]       
                                                                 >= [0 1 0 0]       [0 0 0 0]          [0]                         
                                                                    [0 1 0 0] @ls + [0 0 0 0] @vals1 + [0]                         
                                                                    [0 0 1 0]       [0 0 0 1]          [1]                         
                                                                    [0 1 0 1]       [0 0 0 0]          [1]                         
                                                                 =  [::(tuple#2(@vals1, @key1), insert(@x, @ls))]                  
                                                                                                                                   
                       [insert#1(tuple#2(@valX, @keyX), @l, @x)] =  [1 0 0 0]      [0 0 0 1]         [0]                           
                                                                    [0 1 0 0] @l + [0 0 0 0] @valX + [0]                           
                                                                    [0 0 1 0]      [0 0 0 0]         [1]                           
                                                                    [0 1 0 1]      [0 0 0 0]         [0]                           
                                                                 >= [1 0 0 0]      [0 0 0 1]         [0]                           
                                                                    [0 1 0 0] @l + [0 0 0 0] @valX + [0]                           
                                                                    [0 0 1 0]      [0 0 0 0]         [1]                           
                                                                    [0 1 0 1]      [0 0 0 0]         [0]                           
                                                                 =  [insert#2(@l, @keyX, @valX, @x)]                               
                                                                                                                                   
                                            [quicksort#1(nil())] =  [2]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                 >  [1]                                                            
                                                                    [1]                                                            
                                                                    [1]                                                            
                                                                    [0]                                                            
                                                                 =  [nil()]                                                        
                                                                                                                                   
                                      [quicksort#1(::(@z, @zs))] =  [0 0 0 1]      [0 0 1 1]       [2]                             
                                                                    [0 0 0 0] @z + [0 0 0 0] @zs + [1]                             
                                                                    [0 0 0 1]      [0 0 1 1]       [1]                             
                                                                    [0 0 0 0]      [0 0 0 1]       [1]                             
                                                                 >= [0 0 0 1]      [0 0 0 0]       [2]                             
                                                                    [0 0 0 0] @z + [0 0 0 0] @zs + [1]                             
                                                                    [0 0 0 1]      [0 0 1 1]       [1]                             
                                                                    [0 0 0 0]      [0 0 0 1]       [1]                             
                                                                 =  [quicksort#2(splitqs(@z, @zs), @z)]                            
                                                                                                                                   
                                          [append#1(nil(), @ys)] =  [1 1 0 0]       [0]                                            
                                                                    [0 1 0 0] @ys + [0]                                            
                                                                    [0 0 1 0]       [1]                                            
                                                                    [0 0 0 1]       [0]                                            
                                                                 >= [1 0 0 0]       [0]                                            
                                                                    [0 1 0 0] @ys + [0]                                            
                                                                    [0 0 1 0]       [0]                                            
                                                                    [0 0 0 1]       [0]                                            
                                                                 =  [@ys]                                                          
                                                                                                                                   
                                    [append#1(::(@x, @xs), @ys)] =  [0 0 0 0]      [1 1 0 0]       [0 0 0 0]       [0]             
                                                                    [0 0 0 0] @x + [0 1 0 0] @ys + [0 0 0 0] @xs + [0]             
                                                                    [0 0 0 1]      [0 0 1 0]       [0 0 1 0]       [0]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                 >= [0 0 0 0]      [0 1 0 0]       [0 0 0 0]       [0]             
                                                                    [0 0 0 0] @x + [0 1 0 0] @ys + [0 0 0 0] @xs + [0]             
                                                                    [0 0 0 1]      [0 0 1 0]       [0 0 1 0]       [0]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                 =  [::(@x, append(@xs, @ys))]                                     
                                                                                                                                   
                                           [splitqs(@pivot, @l)] =  [0 0 0 1]      [0]                                             
                                                                    [0 0 0 0] @l + [1]                                             
                                                                    [0 0 1 0]      [1]                                             
                                                                    [1 0 0 1]      [0]                                             
                                                                 >= [0 0 0 1]      [0]                                             
                                                                    [0 0 0 0] @l + [1]                                             
                                                                    [0 0 1 0]      [1]                                             
                                                                    [1 0 0 1]      [0]                                             
                                                                 =  [splitqs#1(@l, @pivot)]                                        
                                                                                                                                   
                                                 [quicksort(@l)] =  [0 0 1 1]      [1]                                             
                                                                    [0 0 0 0] @l + [1]                                             
                                                                    [0 0 1 1]      [0]                                             
                                                                    [0 0 0 1]      [0]                                             
                                                                 >= [0 0 1 1]      [1]                                             
                                                                    [0 0 0 0] @l + [1]                                             
                                                                    [0 0 1 1]      [0]                                             
                                                                    [0 0 0 1]      [0]                                             
                                                                 =  [quicksort#1(@l)]                                              
                                                                                                                                   
                              [splitqs#3(#true(), @ls, @rs, @x)] =  [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                    [0 0 0 0] @x + [0 0 0 0] @ls + [0 0 0 0] @rs + [1]             
                                                                    [0 0 0 1]      [0 0 1 0]       [0 0 1 0]       [0]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 0]       [1]             
                                                                 >= [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                    [0 0 0 0] @x + [0 0 0 0] @ls + [0 0 0 0] @rs + [1]             
                                                                    [0 0 0 1]      [0 0 1 0]       [0 0 1 0]       [0]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 0]       [0]             
                                                                 =  [tuple#2(@ls, ::(@x, @rs))]                                    
                                                                                                                                   
                             [splitqs#3(#false(), @ls, @rs, @x)] =  [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                    [0 0 0 0] @x + [0 0 0 0] @ls + [0 0 0 0] @rs + [1]             
                                                                    [0 0 0 1]      [0 0 1 0]       [0 0 1 0]       [0]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 0]       [1]             
                                                                 >= [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                    [0 0 0 0] @x + [0 0 0 0] @ls + [0 0 0 0] @rs + [1]             
                                                                    [0 0 0 1]      [0 0 1 0]       [0 0 1 0]       [0]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 0]       [1]             
                                                                 =  [tuple#2(::(@x, @ls), @rs)]                                    
                                                                                                                                   
                      [splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] =  [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                    [0 0 0 0] @x + [0 0 0 0] @ls + [0 0 0 0] @rs + [1]             
                                                                    [0 0 0 1]      [0 0 1 0]       [0 0 1 0]       [0]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                 >= [0 0 0 0]      [0 0 0 1]       [0 0 0 1]       [1]             
                                                                    [0 0 0 0] @x + [0 0 0 0] @ls + [0 0 0 0] @rs + [1]             
                                                                    [0 0 0 1]      [0 0 1 0]       [0 0 1 0]       [0]             
                                                                    [0 0 0 0]      [0 0 0 1]       [0 0 0 0]       [1]             
                                                                 =  [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]                
                                                                                                                                   
                                      [splitqs#1(nil(), @pivot)] =  [0]                                                            
                                                                    [1]                                                            
                                                                    [2]                                                            
                                                                    [1]                                                            
                                                                 >= [0]                                                            
                                                                    [1]                                                            
                                                                    [2]                                                            
                                                                    [0]                                                            
                                                                 =  [tuple#2(nil(), nil())]                                        
                                                                                                                                   
                                [splitqs#1(::(@x, @xs), @pivot)] =  [0 0 0 0]      [0 0 0 1]       [1]                             
                                                                    [0 0 0 0] @x + [0 0 0 0] @xs + [1]                             
                                                                    [0 0 0 1]      [0 0 1 0]       [1]                             
                                                                    [0 0 0 0]      [0 1 0 1]       [1]                             
                                                                 >= [0 0 0 0]      [0 0 0 1]       [1]                             
                                                                    [0 0 0 0] @x + [0 0 0 0] @xs + [1]                             
                                                                    [0 0 0 1]      [0 0 1 0]       [1]                             
                                                                    [0 0 0 0]      [0 0 0 1]       [1]                             
                                                                 =  [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]                  
                                                                                                                                   
                                            [splitAndSort^#(@l)] =  [1 1 0 1]      [1]                                             
                                                                    [1 1 1 1] @l + [1]                                             
                                                                    [1 1 1 1]      [1]                                             
                                                                    [1 1 1 1]      [1]                                             
                                                                 >= [0 1 0 1]      [1]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                 =  [sortAll^#(split(@l))]                                         
                                                                                                                                   
                                                 [sortAll^#(@l)] =  [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                 >= [0 0 1 0]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                 =  [sortAll#1^#(@l)]                                              
                                                                                                                                   
                        [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [0 0 1 0]       [0 0 0 1]         [0]                          
                                                                    [0 0 0 0] @xs + [0 0 0 0] @vals + [0]                          
                                                                    [0 0 0 0]       [0 0 0 0]         [0]                          
                                                                    [0 0 0 0]       [0 0 0 0]         [0]                          
                                                                 >= [0 0 1 0]       [0]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 =  [sortAll^#(@xs)]                                               
                                                                                                                                   
                        [sortAll#2^#(tuple#2(@vals, @key), @xs)] =  [0 0 1 0]       [0 0 0 1]         [0]                          
                                                                    [0 0 0 0] @xs + [0 0 0 0] @vals + [0]                          
                                                                    [0 0 0 0]       [0 0 0 0]         [0]                          
                                                                    [0 0 0 0]       [0 0 0 0]         [0]                          
                                                                 >= [0 0 0 1]         [0]                                          
                                                                    [0 0 0 0] @vals + [0]                                          
                                                                    [0 0 0 0]         [0]                                          
                                                                    [0 0 0 0]         [0]                                          
                                                                 =  [quicksort^#(@vals)]                                           
                                                                                                                                   
                                               [quicksort^#(@l)] =  [0 0 0 1]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                 >= [0 0 0 1]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                 =  [quicksort#1^#(@l)]                                            
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [0 0 0 1]       [0 0 0 1]       [1]                            
                                                                    [0 0 0 0] @ys + [0 0 0 0] @xs + [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                 >  [0 0 0 1]       [0]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 =  [quicksort^#(@xs)]                                             
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [0 0 0 1]       [0 0 0 1]       [1]                            
                                                                    [0 0 0 0] @ys + [0 0 0 0] @xs + [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                 >  [0 0 0 1]       [0]                                            
                                                                    [0 0 0 0] @ys + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 =  [quicksort^#(@ys)]                                             
                                                                                                                                   
                          [quicksort#2^#(tuple#2(@xs, @ys), @z)] =  [0 0 0 1]       [0 0 0 1]       [1]                            
                                                                    [0 0 0 0] @ys + [0 0 0 0] @xs + [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                    [0 0 0 0]       [0 0 0 0]       [0]                            
                                                                 >= [0 0 0 1]       [1]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 =  [append^#(quicksort(@xs), ::(@z, quicksort(@ys)))]             
                                                                                                                                   
                                             [append^#(@l, @ys)] =  [0 0 0 1]      [1]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                 >  [0 0 0 1]      [0]                                             
                                                                    [0 0 0 0] @l + [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                    [0 0 0 0]      [0]                                             
                                                                 =  [c_5(append#1^#(@l, @ys))]                                     
                                                                                                                                   
                                  [append#1^#(::(@x, @xs), @ys)] =  [0 0 0 1]       [1]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [1]                                            
                                                                    [0 1 0 0]       [1]                                            
                                                                 >= [0 0 0 1]       [1]                                            
                                                                    [0 0 0 0] @xs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 =  [c_6(append^#(@xs, @ys))]                                      
                                                                                                                                   
                                      [sortAll#1^#(::(@x, @xs))] =  [0 0 0 1]      [0 0 1 0]       [0]                             
                                                                    [0 0 0 0] @x + [0 0 0 0] @xs + [0]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [0]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [0]                             
                                                                 >= [0 0 0 1]      [0 0 1 0]       [0]                             
                                                                    [0 0 0 0] @x + [0 0 0 0] @xs + [0]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [0]                             
                                                                    [0 0 0 0]      [0 0 0 0]       [0]                             
                                                                 =  [sortAll#2^#(@x, @xs)]                                         
                                                                                                                                   
                                    [quicksort#1^#(::(@z, @zs))] =  [0 0 0 1]       [1]                                            
                                                                    [0 0 0 0] @zs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 >= [0 0 0 1]       [1]                                            
                                                                    [0 0 0 0] @zs + [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                    [0 0 0 0]       [0]                                            
                                                                 =  [quicksort#2^#(splitqs(@z, @zs), @z)]                          
                                                                                                                                   
   
   We return to the main proof.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(1)).
   
   Weak DPs:
     { splitAndSort^#(@l) -> sortAll^#(split(@l))
     , sortAll^#(@l) -> sortAll#1^#(@l)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
     , sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
     , quicksort^#(@l) -> quicksort#1^#(@l)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
     , quicksort#2^#(tuple#2(@xs, @ys), @z) ->
       append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
     , append^#(@l, @ys) -> c_5(append#1^#(@l, @ys))
     , append#1^#(::(@x, @xs), @ys) -> c_6(append^#(@xs, @ys))
     , sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
     , quicksort#1^#(::(@z, @zs)) ->
       quicksort#2^#(splitqs(@z, @zs), @z) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
     , #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , quicksort#2(tuple#2(@xs, @ys), @z) ->
       append(quicksort(@xs), ::(@z, quicksort(@ys)))
     , split(@l) -> split#1(@l)
     , append(@l, @ys) -> append#1(@l, @ys)
     , insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
       insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
     , #ckgt(#EQ()) -> #false()
     , #ckgt(#LT()) -> #false()
     , #ckgt(#GT()) -> #true()
     , insert(@x, @l) -> insert#1(@x, @l, @x)
     , insert#2(nil(), @keyX, @valX, @x) ->
       ::(tuple#2(::(@valX, nil()), @keyX), nil())
     , insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
       insert#3(@l1, @keyX, @ls, @valX, @x)
     , #and(#true(), #true()) -> #true()
     , #and(#true(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#false(), #false()) -> #false()
     , #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
     , #compare(#pos(@x), #0()) -> #GT()
     , #compare(#pos(@x), #neg(@y)) -> #GT()
     , #compare(#0(), #pos(@y)) -> #LT()
     , #compare(#0(), #0()) -> #EQ()
     , #compare(#0(), #neg(@y)) -> #GT()
     , #compare(#0(), #s(@y)) -> #LT()
     , #compare(#neg(@x), #pos(@y)) -> #LT()
     , #compare(#neg(@x), #0()) -> #LT()
     , #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
     , #compare(#s(@x), #0()) -> #GT()
     , #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
     , split#1(nil()) -> nil()
     , split#1(::(@x, @xs)) -> insert(@x, split(@xs))
     , #greater(@x, @y) -> #ckgt(#compare(@x, @y))
     , insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(::(@valX, @vals1), @key1), @ls)
     , insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
       ::(tuple#2(@vals1, @key1), insert(@x, @ls))
     , insert#1(tuple#2(@valX, @keyX), @l, @x) ->
       insert#2(@l, @keyX, @valX, @x)
     , quicksort#1(nil()) -> nil()
     , quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
     , append#1(nil(), @ys) -> @ys
     , append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
     , splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
     , quicksort(@l) -> quicksort#1(@l)
     , splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
     , splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
     , splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
       splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
     , splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
     , splitqs#1(::(@x, @xs), @pivot) ->
       splitqs#2(splitqs(@pivot, @xs), @pivot, @x) }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(1))
   
   Empty rules are trivially bounded


Hurray, we answered YES(O(1),O(n^6))