MAYBE
* Step 1: Failure MAYBE
  + Considered Problem:
      - Strict TRS:
          #abs(#0()) -> #0()
          #abs(#neg(@x)) -> #pos(@x)
          #abs(#pos(@x)) -> #pos(@x)
          #abs(#s(@x)) -> #pos(#s(@x))
          #greater(@x,@y) -> #ckgt(#compare(@x,@y))
          append(@l,@ys) -> append#1(@l,@ys)
          append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys))
          append#1(nil(),@ys) -> @ys
          appendD(@l,@ys) -> appendD#1(@l,@ys)
          appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys))
          appendD#1(nil(),@ys) -> @ys
          quicksort(@l) -> quicksort#1(@l)
          quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z)
          quicksort#1(nil()) -> nil()
          quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys)))
          quicksortD(@l) -> quicksortD#1(@l)
          quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z)
          quicksortD#1(nil()) -> nil()
          quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys)))
          split(@pivot,@l) -> split#1(@l,@pivot)
          split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x)
          split#1(nil(),@pivot) -> tuple#2(nil(),nil())
          split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x)
          split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs)
          split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs))
          splitD(@pivot,@l) -> splitD#1(@l,@pivot)
          splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x)
          splitD#1(nil(),@pivot) -> tuple#2(nil(),nil())
          splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x)
          splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs)
          splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs))
          testList(@x) -> ::(#abs(#0())
                            ,::(#abs(#pos(#s(#s(#s(#s(#0()))))))
                               ,::(#abs(#pos(#s(#s(#s(#s(#s(#0())))))))
                                  ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))))
                                     ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0())))))))))
                                        ,::(#abs(#pos(#s(#0())))
                                           ,::(#abs(#pos(#s(#s(#0()))))
                                              ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))
                                                 ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0()))))))))
                                                    ,::(#abs(#pos(#s(#s(#s(#0()))))),nil()))))))))))
          testQuicksort(@x) -> quicksort(testList(#unit()))
          testQuicksort2(@x) -> quicksort(testList(#unit()))
      - Weak TRS:
          #ckgt(#EQ()) -> #false()
          #ckgt(#GT()) -> #true()
          #ckgt(#LT()) -> #false()
          #compare(#0(),#0()) -> #EQ()
          #compare(#0(),#neg(@y)) -> #GT()
          #compare(#0(),#pos(@y)) -> #LT()
          #compare(#0(),#s(@y)) -> #LT()
          #compare(#neg(@x),#0()) -> #LT()
          #compare(#neg(@x),#neg(@y)) -> #compare(@y,@x)
          #compare(#neg(@x),#pos(@y)) -> #LT()
          #compare(#pos(@x),#0()) -> #GT()
          #compare(#pos(@x),#neg(@y)) -> #GT()
          #compare(#pos(@x),#pos(@y)) -> #compare(@x,@y)
          #compare(#s(@x),#0()) -> #GT()
          #compare(#s(@x),#s(@y)) -> #compare(@x,@y)
      - Signature:
          {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1
          ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2
          ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1} / {#0/0,#EQ/0,#GT/0,#LT/0
          ,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2}
      - Obligation:
          innermost runtime complexity wrt. defined symbols {#abs,#ckgt,#compare,#greater,append,append#1,appendD
          ,appendD#1,quicksort,quicksort#1,quicksort#2,quicksortD,quicksortD#1,quicksortD#2,split,split#1,split#2
          ,split#3,splitD,splitD#1,splitD#2,splitD#3,testList,testQuicksort,testQuicksort2} and constructors {#0,#EQ
          ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2}
  + Applied Processor:
      Ara {heuristics_ = NoHeuristics, minDegree = 1, maxDegree = 3, araTimeout = 60, araFindStrictRules = Nothing, araSmtSolver = MiniSMT}
  + Details:
      The input can not be schown compatible.
MAYBE