WORST_CASE(?,O(n^1))
* Step 1: Bounds WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            add0(x,Nil()) -> x
            add0(x',Cons(x,xs)) -> add0(Cons(Cons(Nil(),Nil()),x'),xs)
            goal(x,y) -> add0(x,y)
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
        - Signature:
            {add0/2,goal/2,notEmpty/1} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {add0,goal,notEmpty} and constructors {Cons,False,Nil
            ,True}
    + Applied Processor:
        Bounds {initialAutomaton = perSymbol, enrichment = match}
    + Details:
        The problem is match-bounded by 1.
        The enriched problem is compatible with follwoing automaton.
          Cons_0(1,1) -> 1
          Cons_0(1,1) -> 5
          Cons_0(1,1) -> 6
          Cons_0(1,2) -> 1
          Cons_0(1,2) -> 5
          Cons_0(1,2) -> 6
          Cons_0(1,3) -> 1
          Cons_0(1,3) -> 5
          Cons_0(1,3) -> 6
          Cons_0(1,4) -> 1
          Cons_0(1,4) -> 5
          Cons_0(1,4) -> 6
          Cons_0(2,1) -> 1
          Cons_0(2,1) -> 5
          Cons_0(2,1) -> 6
          Cons_0(2,2) -> 1
          Cons_0(2,2) -> 5
          Cons_0(2,2) -> 6
          Cons_0(2,3) -> 1
          Cons_0(2,3) -> 5
          Cons_0(2,3) -> 6
          Cons_0(2,4) -> 1
          Cons_0(2,4) -> 5
          Cons_0(2,4) -> 6
          Cons_0(3,1) -> 1
          Cons_0(3,1) -> 5
          Cons_0(3,1) -> 6
          Cons_0(3,2) -> 1
          Cons_0(3,2) -> 5
          Cons_0(3,2) -> 6
          Cons_0(3,3) -> 1
          Cons_0(3,3) -> 5
          Cons_0(3,3) -> 6
          Cons_0(3,4) -> 1
          Cons_0(3,4) -> 5
          Cons_0(3,4) -> 6
          Cons_0(4,1) -> 1
          Cons_0(4,1) -> 5
          Cons_0(4,1) -> 6
          Cons_0(4,2) -> 1
          Cons_0(4,2) -> 5
          Cons_0(4,2) -> 6
          Cons_0(4,3) -> 1
          Cons_0(4,3) -> 5
          Cons_0(4,3) -> 6
          Cons_0(4,4) -> 1
          Cons_0(4,4) -> 5
          Cons_0(4,4) -> 6
          Cons_1(9,1) -> 5
          Cons_1(9,1) -> 6
          Cons_1(9,1) -> 8
          Cons_1(9,2) -> 5
          Cons_1(9,2) -> 6
          Cons_1(9,2) -> 8
          Cons_1(9,3) -> 5
          Cons_1(9,3) -> 6
          Cons_1(9,3) -> 8
          Cons_1(9,4) -> 5
          Cons_1(9,4) -> 6
          Cons_1(9,4) -> 8
          Cons_1(9,8) -> 5
          Cons_1(9,8) -> 6
          Cons_1(9,8) -> 8
          Cons_1(10,11) -> 9
          False_0() -> 2
          False_0() -> 5
          False_0() -> 6
          False_1() -> 7
          Nil_0() -> 3
          Nil_0() -> 5
          Nil_0() -> 6
          Nil_1() -> 10
          Nil_1() -> 11
          True_0() -> 4
          True_0() -> 5
          True_0() -> 6
          True_1() -> 7
          add0_0(1,1) -> 5
          add0_0(1,2) -> 5
          add0_0(1,3) -> 5
          add0_0(1,4) -> 5
          add0_0(2,1) -> 5
          add0_0(2,2) -> 5
          add0_0(2,3) -> 5
          add0_0(2,4) -> 5
          add0_0(3,1) -> 5
          add0_0(3,2) -> 5
          add0_0(3,3) -> 5
          add0_0(3,4) -> 5
          add0_0(4,1) -> 5
          add0_0(4,2) -> 5
          add0_0(4,3) -> 5
          add0_0(4,4) -> 5
          add0_1(1,1) -> 6
          add0_1(1,2) -> 6
          add0_1(1,3) -> 6
          add0_1(1,4) -> 6
          add0_1(2,1) -> 6
          add0_1(2,2) -> 6
          add0_1(2,3) -> 6
          add0_1(2,4) -> 6
          add0_1(3,1) -> 6
          add0_1(3,2) -> 6
          add0_1(3,3) -> 6
          add0_1(3,4) -> 6
          add0_1(4,1) -> 6
          add0_1(4,2) -> 6
          add0_1(4,3) -> 6
          add0_1(4,4) -> 6
          add0_1(8,1) -> 5
          add0_1(8,1) -> 6
          add0_1(8,2) -> 5
          add0_1(8,2) -> 6
          add0_1(8,3) -> 5
          add0_1(8,3) -> 6
          add0_1(8,4) -> 5
          add0_1(8,4) -> 6
          goal_0(1,1) -> 6
          goal_0(1,2) -> 6
          goal_0(1,3) -> 6
          goal_0(1,4) -> 6
          goal_0(2,1) -> 6
          goal_0(2,2) -> 6
          goal_0(2,3) -> 6
          goal_0(2,4) -> 6
          goal_0(3,1) -> 6
          goal_0(3,2) -> 6
          goal_0(3,3) -> 6
          goal_0(3,4) -> 6
          goal_0(4,1) -> 6
          goal_0(4,2) -> 6
          goal_0(4,3) -> 6
          goal_0(4,4) -> 6
          notEmpty_0(1) -> 7
          notEmpty_0(2) -> 7
          notEmpty_0(3) -> 7
          notEmpty_0(4) -> 7
          1 -> 5
          1 -> 6
          2 -> 5
          2 -> 6
          3 -> 5
          3 -> 6
          4 -> 5
          4 -> 6
          8 -> 5
          8 -> 6
* Step 2: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            add0(x,Nil()) -> x
            add0(x',Cons(x,xs)) -> add0(Cons(Cons(Nil(),Nil()),x'),xs)
            goal(x,y) -> add0(x,y)
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
        - Signature:
            {add0/2,goal/2,notEmpty/1} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {add0,goal,notEmpty} and constructors {Cons,False,Nil
            ,True}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^1))