WORST_CASE(?,O(n^1))
* Step 1: Desugar WORST_CASE(?,O(n^1))
    + Considered Problem:
        type bstring =
            E | Z of bstring | O of bstring
        ;;
        
        let rec flip x =
          match x with
          | E -> E
          | Z(x') -> O(flip x')
          | O(x') -> Z(flip x')
        ;;
        
    + Applied Processor:
        Desugar {analysedFunction = Nothing}
    + Details:
        none
* Step 2: Defunctionalization WORST_CASE(?,O(n^1))
    + Considered Problem:
        λx : bstring.
          (λflip : bstring -> bstring. flip x)
            (μflip : bstring -> bstring.
               λx : bstring.
                 case x of  | E -> E | Z -> λx' : bstring. O(flip x') | O -> λx' : bstring. Z(flip x')) : bstring
                                                                                                           -> bstring
        where
          E :: bstring
          O :: bstring -> bstring
          Z :: bstring -> bstring
    + Applied Processor:
        Defunctionalization
    + Details:
        none
* Step 3: Inline WORST_CASE(?,O(n^1))
    + Considered Problem:
        1: main_1(x0) x1 -> x1 x0
        2: cond_flip_x(E()) -> E()
        3: cond_flip_x(Z(x2)) -> O(flip() x2)
        4: cond_flip_x(O(x2)) -> Z(flip() x2)
        5: flip_1() x1 -> cond_flip_x(x1)
        6: flip() x0 -> flip_1() x0
        7: main(x0) -> main_1(x0) flip()
        where
          E           :: bstring
          O           :: bstring -> bstring
          Z           :: bstring -> bstring
          flip_1      :: bstring -> bstring
          main_1      :: bstring -> (bstring -> bstring) -> bstring
          cond_flip_x :: bstring -> bstring
          flip        :: bstring -> bstring
          main        :: bstring -> bstring
    + Applied Processor:
        Inline {inlineType = InlineRewrite, inlineSelect = <inline non-recursive>}
    + Details:
        none
* Step 4: Inline WORST_CASE(?,O(n^1))
    + Considered Problem:
        1: main_1(x0) x1 -> x1 x0
        2: cond_flip_x(E()) -> E()
        3: cond_flip_x(Z(x2)) -> O(flip() x2)
        4: cond_flip_x(O(x2)) -> Z(flip() x2)
        5: flip_1() x1 -> cond_flip_x(x1)
        6: flip() x2 -> cond_flip_x(x2)
        7: main(x0) -> flip() x0
        where
          E           :: bstring
          O           :: bstring -> bstring
          Z           :: bstring -> bstring
          flip_1      :: bstring -> bstring
          main_1      :: bstring -> (bstring -> bstring) -> bstring
          cond_flip_x :: bstring -> bstring
          flip        :: bstring -> bstring
          main        :: bstring -> bstring
    + Applied Processor:
        Inline {inlineType = InlineFull, inlineSelect = <inline case-expression>}
    + Details:
        none
* Step 5: UsableRules WORST_CASE(?,O(n^1))
    + Considered Problem:
        1: main_1(x0) x1 -> x1 x0
        2: cond_flip_x(E()) -> E()
        3: cond_flip_x(Z(x2)) -> O(flip() x2)
        4: cond_flip_x(O(x2)) -> Z(flip() x2)
        5: flip_1() E() -> E()
        6: flip_1() Z(x4) -> O(flip() x4)
        7: flip_1() O(x4) -> Z(flip() x4)
        8: flip() E() -> E()
        9: flip() Z(x4) -> O(flip() x4)
        10: flip() O(x4) -> Z(flip() x4)
        11: main(x0) -> flip() x0
        where
          E           :: bstring
          O           :: bstring -> bstring
          Z           :: bstring -> bstring
          flip_1      :: bstring -> bstring
          main_1      :: bstring -> (bstring -> bstring) -> bstring
          cond_flip_x :: bstring -> bstring
          flip        :: bstring -> bstring
          main        :: bstring -> bstring
    + Applied Processor:
        UsableRules {urType = Syntactic}
    + Details:
        none
* Step 6: UncurryATRS WORST_CASE(?,O(n^1))
    + Considered Problem:
        8: flip() E() -> E()
        9: flip() Z(x4) -> O(flip() x4)
        10: flip() O(x4) -> Z(flip() x4)
        11: main(x0) -> flip() x0
        where
          E    :: bstring
          O    :: bstring -> bstring
          Z    :: bstring -> bstring
          flip :: bstring -> bstring
          main :: bstring -> bstring
    + Applied Processor:
        UncurryATRS
    + Details:
        none
* Step 7: UsableRules WORST_CASE(?,O(n^1))
    + Considered Problem:
        1: flip#1(E()) -> E()
        2: flip#1(Z(x4)) -> O(flip#1(x4))
        3: flip#1(O(x4)) -> Z(flip#1(x4))
        4: main(x0) -> flip#1(x0)
        where
          E      :: bstring
          O      :: bstring -> bstring
          Z      :: bstring -> bstring
          flip#1 :: bstring -> bstring
          main   :: bstring -> bstring
    + Applied Processor:
        UsableRules {urType = DFA}
    + Details:
        none
* Step 8: Compression WORST_CASE(?,O(n^1))
    + Considered Problem:
        1: flip#1(E()) -> E()
        2: flip#1(Z(x4)) -> O(flip#1(x4))
        3: flip#1(O(x4)) -> Z(flip#1(x4))
        4: main(x0) -> flip#1(x0)
        where
          E      :: bstring
          O      :: bstring -> bstring
          Z      :: bstring -> bstring
          flip#1 :: bstring -> bstring
          main   :: bstring -> bstring
    + Applied Processor:
        Compression
    + Details:
        none
* Step 9: ToTctProblem WORST_CASE(?,O(n^1))
    + Considered Problem:
        1: flip#1(E()) -> E()
        2: flip#1(Z(x4)) -> O(flip#1(x4))
        3: flip#1(O(x4)) -> Z(flip#1(x4))
        4: main(x0) -> flip#1(x0)
        where
          E      :: bstring
          O      :: bstring -> bstring
          Z      :: bstring -> bstring
          flip#1 :: bstring -> bstring
          main   :: bstring -> bstring
    + Applied Processor:
        ToTctProblem
    + Details:
        none
* Step 10: Ara WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            flip#1(E()) -> E()
            flip#1(O(x4)) -> Z(flip#1(x4))
            flip#1(Z(x4)) -> O(flip#1(x4))
            main(x0) -> flip#1(x0)
        - Signature:
            {flip#1/1,main/1} / {E/0,O/1,Z/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {main} and constructors {E,O,Z}
    + Applied Processor:
        Ara {minDegree = 1, maxDegree = 2, araTimeout = 5, araRuleShifting = Nothing}
    + Details:
        Signatures used:
        ----------------
          F (TrsFun "E") :: [] -(0)-> "A"(1)
          F (TrsFun "E") :: [] -(0)-> "A"(0)
          F (TrsFun "O") :: ["A"(1)] -(1)-> "A"(1)
          F (TrsFun "O") :: ["A"(0)] -(0)-> "A"(0)
          F (TrsFun "Z") :: ["A"(1)] -(1)-> "A"(1)
          F (TrsFun "Z") :: ["A"(0)] -(0)-> "A"(0)
          F (TrsFun "flip#1") :: ["A"(1)] -(1)-> "A"(0)
          F (TrsFun "main") :: ["A"(1)] -(2)-> "A"(0)
        
        
        Cost-free Signatures used:
        --------------------------
        
        
        
        Base Constructor Signatures used:
        ---------------------------------
        
        

WORST_CASE(?,O(n^1))