* Step 1: Sum WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            cond_scanr_f_z_xs_1(Cons(0(),x11),0()) -> Cons(0(),Cons(0(),x11))
            cond_scanr_f_z_xs_1(Cons(0(),x11),M(x2)) -> Cons(0(),Cons(0(),x11))
            cond_scanr_f_z_xs_1(Cons(0(),x11),S(x2)) -> Cons(S(x2),Cons(0(),x11))
            cond_scanr_f_z_xs_1(Cons(S(x2),x11),0()) -> Cons(S(x2),Cons(S(x2),x11))
            cond_scanr_f_z_xs_1(Cons(S(x2),x11),S(x4)) -> Cons(plus#2(S(x4),S(x2)),Cons(S(x2),x11))
            cond_scanr_f_z_xs_1(Cons(S(x40),x23),M(0())) -> Cons(S(x40),Cons(S(x40),x23))
            cond_scanr_f_z_xs_1(Cons(S(x8),x23),M(S(x4))) -> Cons(minus#2(x8,x4),Cons(S(x8),x23))
            foldl#3(x2,Nil()) -> x2
            foldl#3(x6,Cons(x4,x2)) -> foldl#3(max#2(x6,x4),x2)
            main(x1) -> foldl#3(0(),scanr#3(x1))
            max#2(0(),x8) -> x8
            max#2(S(x12),0()) -> S(x12)
            max#2(S(x4),S(x2)) -> S(max#2(x4,x2))
            minus#2(0(),x16) -> 0()
            minus#2(S(x20),0()) -> S(x20)
            minus#2(S(x4),S(x2)) -> minus#2(x4,x2)
            plus#2(0(),S(x2)) -> S(x2)
            plus#2(S(x4),S(x2)) -> S(plus#2(x4,S(x2)))
            scanr#3(Cons(x4,x2)) -> cond_scanr_f_z_xs_1(scanr#3(x2),x4)
            scanr#3(Nil()) -> Cons(0(),Nil())
        - Signature:
            {cond_scanr_f_z_xs_1/2,foldl#3/2,main/1,max#2/2,minus#2/2,plus#2/2,scanr#3/1} / {0/0,Cons/2,M/1,Nil/0,S/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {cond_scanr_f_z_xs_1,foldl#3,main,max#2,minus#2,plus#2
            ,scanr#3} and constructors {0,Cons,M,Nil,S}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 2: DecreasingLoops WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            cond_scanr_f_z_xs_1(Cons(0(),x11),0()) -> Cons(0(),Cons(0(),x11))
            cond_scanr_f_z_xs_1(Cons(0(),x11),M(x2)) -> Cons(0(),Cons(0(),x11))
            cond_scanr_f_z_xs_1(Cons(0(),x11),S(x2)) -> Cons(S(x2),Cons(0(),x11))
            cond_scanr_f_z_xs_1(Cons(S(x2),x11),0()) -> Cons(S(x2),Cons(S(x2),x11))
            cond_scanr_f_z_xs_1(Cons(S(x2),x11),S(x4)) -> Cons(plus#2(S(x4),S(x2)),Cons(S(x2),x11))
            cond_scanr_f_z_xs_1(Cons(S(x40),x23),M(0())) -> Cons(S(x40),Cons(S(x40),x23))
            cond_scanr_f_z_xs_1(Cons(S(x8),x23),M(S(x4))) -> Cons(minus#2(x8,x4),Cons(S(x8),x23))
            foldl#3(x2,Nil()) -> x2
            foldl#3(x6,Cons(x4,x2)) -> foldl#3(max#2(x6,x4),x2)
            main(x1) -> foldl#3(0(),scanr#3(x1))
            max#2(0(),x8) -> x8
            max#2(S(x12),0()) -> S(x12)
            max#2(S(x4),S(x2)) -> S(max#2(x4,x2))
            minus#2(0(),x16) -> 0()
            minus#2(S(x20),0()) -> S(x20)
            minus#2(S(x4),S(x2)) -> minus#2(x4,x2)
            plus#2(0(),S(x2)) -> S(x2)
            plus#2(S(x4),S(x2)) -> S(plus#2(x4,S(x2)))
            scanr#3(Cons(x4,x2)) -> cond_scanr_f_z_xs_1(scanr#3(x2),x4)
            scanr#3(Nil()) -> Cons(0(),Nil())
        - Signature:
            {cond_scanr_f_z_xs_1/2,foldl#3/2,main/1,max#2/2,minus#2/2,plus#2/2,scanr#3/1} / {0/0,Cons/2,M/1,Nil/0,S/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {cond_scanr_f_z_xs_1,foldl#3,main,max#2,minus#2,plus#2
            ,scanr#3} and constructors {0,Cons,M,Nil,S}
    + Applied Processor:
        DecreasingLoops {bound = AnyLoop, narrow = 10}
    + Details:
        The system has following decreasing Loops:
          foldl#3(x,z){z -> Cons(y,z)} =
            foldl#3(x,Cons(y,z)) ->^+ foldl#3(max#2(x,y),z)
              = C[foldl#3(max#2(x,y),z) = foldl#3(x,z){x -> max#2(x,y)}]

WORST_CASE(Omega(n^1),?)