YES(?,O(1))
* Step 1: ArgumentFilter WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T)  -> f7(8,0,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T)                                                            True     (1,1)
          1. f7(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T)  -> f7(A,1 + B,U + V,W,X + Y,Z,A1 + B1,C1,D1 + E1,F1,D1 + E1 + U + V,-1*D1 + -1*E1 + U + V,A1 + B1 + X + Y [7 >= B] (?,1)
                                                         ,-1*A1 + -1*B1 + X + Y,-3196,G1,H1,I1 + J1,J1 + K1,J1)                                                                   
          2. f62(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T) -> f62(A,1 + B,U + V,W,X + Y,Z,A1 + B1,C1,D1 + E1,F1,D1 + E1 + U + V,-1*D1 + -1*E1 + U + V,A1 + B1 + X + Y[7 >= B] (?,1)
                                                         ,-1*A1 + -1*B1 + X + Y,-3196,G1,H1,I1 + J1,J1 + K1,J1)                                                                   
          3. f62(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T) -> f118(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T)                                                          [B >= 8] (?,1)
          4. f7(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T)  -> f62(A,0,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T)                                                           [B >= 8] (?,1)
        Signature:
          {(f0,20);(f118,20);(f62,20);(f7,20)}
        Flow Graph:
          [0->{1,4},1->{1,4},2->{2,3},3->{},4->{2,3}]
        
    + Applied Processor:
        ArgumentFilter [0,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
    + Details:
        We remove following argument positions: [0,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19].
* Step 2: UnsatPaths WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(B)  -> f7(0)      True     (1,1)
          1. f7(B)  -> f7(1 + B)  [7 >= B] (?,1)
          2. f62(B) -> f62(1 + B) [7 >= B] (?,1)
          3. f62(B) -> f118(B)    [B >= 8] (?,1)
          4. f7(B)  -> f62(0)     [B >= 8] (?,1)
        Signature:
          {(f0,20);(f118,20);(f62,20);(f7,20)}
        Flow Graph:
          [0->{1,4},1->{1,4},2->{2,3},3->{},4->{2,3}]
        
    + Applied Processor:
        UnsatPaths
    + Details:
        We remove following edges from the transition graph: [(0,4),(4,3)]
* Step 3: FromIts WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(B)  -> f7(0)      True     (1,1)
          1. f7(B)  -> f7(1 + B)  [7 >= B] (?,1)
          2. f62(B) -> f62(1 + B) [7 >= B] (?,1)
          3. f62(B) -> f118(B)    [B >= 8] (?,1)
          4. f7(B)  -> f62(0)     [B >= 8] (?,1)
        Signature:
          {(f0,20);(f118,20);(f62,20);(f7,20)}
        Flow Graph:
          [0->{1},1->{1,4},2->{2,3},3->{},4->{2}]
        
    + Applied Processor:
        FromIts
    + Details:
        ()
* Step 4: Unfold WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          f0(B)  -> f7(0)       True
          f7(B)  -> f7(1 + B)   [7 >= B]
          f62(B) -> f62(1 + B)  [7 >= B]
          f62(B) -> f118(B)     [B >= 8]
          f7(B)  -> f62(0)      [B >= 8]
        Signature:
          {(f0,20);(f118,20);(f62,20);(f7,20)}
        Rule Graph:
          [0->{1},1->{1,4},2->{2,3},3->{},4->{2}]
    + Applied Processor:
        Unfold
    + Details:
        ()
* Step 5: AddSinks WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          f0.0(B)  -> f7.1(0)       True
          f7.1(B)  -> f7.1(1 + B)   [7 >= B]
          f7.1(B)  -> f7.4(1 + B)   [7 >= B]
          f62.2(B) -> f62.2(1 + B)  [7 >= B]
          f62.2(B) -> f62.3(1 + B)  [7 >= B]
          f62.3(B) -> f118.5(B)     [B >= 8]
          f7.4(B)  -> f62.2(0)      [B >= 8]
        Signature:
          {(f0.0,1);(f118.5,1);(f62.2,1);(f62.3,1);(f7.1,1);(f7.4,1)}
        Rule Graph:
          [0->{1,2},1->{1,2},2->{6},3->{3,4},4->{5},5->{},6->{3,4}]
    + Applied Processor:
        AddSinks
    + Details:
        ()
* Step 6: Decompose WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          f0.0(B)   -> f7.1(0)       True
          f7.1(B)   -> f7.1(1 + B)   [7 >= B]
          f7.1(B)   -> f7.4(1 + B)   [7 >= B]
          f62.2(B)  -> f62.2(1 + B)  [7 >= B]
          f62.2(B)  -> f62.3(1 + B)  [7 >= B]
          f62.3(B)  -> f118.5(B)     [B >= 8]
          f7.4(B)   -> f62.2(0)      [B >= 8]
          f118.5(B) -> exitus616(B)  True
        Signature:
          {(exitus616,1);(f0.0,1);(f118.5,1);(f62.2,1);(f62.3,1);(f7.1,1);(f7.4,1)}
        Rule Graph:
          [0->{1,2},1->{1,2},2->{6},3->{3,4},4->{5},5->{7},6->{3,4}]
    + Applied Processor:
        Decompose Greedy
    + Details:
        We construct a looptree:
          P: [0,1,2,3,4,5,6,7]
          |
          +- p:[1] c: [1]
          |
          `- p:[3] c: [3]
* Step 7: AbstractSize WORST_CASE(?,O(1))
    + Considered Problem:
        (Rules:
          f0.0(B)   -> f7.1(0)       True
          f7.1(B)   -> f7.1(1 + B)   [7 >= B]
          f7.1(B)   -> f7.4(1 + B)   [7 >= B]
          f62.2(B)  -> f62.2(1 + B)  [7 >= B]
          f62.2(B)  -> f62.3(1 + B)  [7 >= B]
          f62.3(B)  -> f118.5(B)     [B >= 8]
          f7.4(B)   -> f62.2(0)      [B >= 8]
          f118.5(B) -> exitus616(B)  True
        Signature:
          {(exitus616,1);(f0.0,1);(f118.5,1);(f62.2,1);(f62.3,1);(f7.1,1);(f7.4,1)}
        Rule Graph:
          [0->{1,2},1->{1,2},2->{6},3->{3,4},4->{5},5->{7},6->{3,4}]
        ,We construct a looptree:
          P: [0,1,2,3,4,5,6,7]
          |
          +- p:[1] c: [1]
          |
          `- p:[3] c: [3])
    + Applied Processor:
        AbstractSize Minimize
    + Details:
        ()
* Step 8: AbstractFlow WORST_CASE(?,O(1))
    + Considered Problem:
        Program:
          Domain: [B,0.0,0.1]
           f0.0    ~>  f7.1        [B <= 0*K]
           f7.1    ~>  f7.1        [B <= K + B]
           f7.1    ~>  f7.4        [B <= K + B]
           f62.2   ~>  f62.2       [B <= K + B]
           f62.2   ~>  f62.3       [B <= K + B]
           f62.3   ~>  f118.5      [B <= B]
           f7.4    ~>  f62.2       [B <= 0*K]
           f118.5  ~>  exitus616   [B <= B]
          + Loop: [0.0 <= 7*K + B]
               f7.1  ~>  f7.1   [B <= K + B]
          + Loop: [0.1 <= 7*K + B]
               f62.2  ~>  f62.2   [B <= K + B]
    + Applied Processor:
        AbstractFlow
    + Details:
        ()
* Step 9: Lare WORST_CASE(?,O(1))
    + Considered Problem:
        Program:
          Domain: [tick,huge,K,B,0.0,0.1]
           f0.0    ~>  f7.1        [K ~=> B]
           f7.1    ~>  f7.1        [B ~+> B,K ~+> B]
           f7.1    ~>  f7.4        [B ~+> B,K ~+> B]
           f62.2   ~>  f62.2       [B ~+> B,K ~+> B]
           f62.2   ~>  f62.3       [B ~+> B,K ~+> B]
           f62.3   ~>  f118.5      []
           f7.4    ~>  f62.2       [K ~=> B]
           f118.5  ~>  exitus616   []
          + Loop: [B ~+> 0.0,K ~*> 0.0]
               f7.1  ~>  f7.1   [B ~+> B,K ~+> B]
          + Loop: [B ~+> 0.1,K ~*> 0.1]
               f62.2  ~>  f62.2   [B ~+> B,K ~+> B]
    + Applied Processor:
        Lare
    + Details:
         f0.0  ~>  exitus616   [tick ~+> tick
                               ,K ~+> B
                               ,K ~+> 0.0
                               ,K ~+> 0.1
                               ,K ~+> tick
                               ,K ~*> B
                               ,K ~*> 0.0
                               ,K ~*> 0.1
                               ,K ~*> tick]
        + <f7.1  ~>  f7.1>  [B ~+> B
                            ,B ~+> 0.0
                            ,B ~+> tick
                            ,tick ~+> tick
                            ,K ~+> B
                            ,B ~*> B
                            ,K ~*> B
                            ,K ~*> 0.0
                            ,K ~*> tick]
        + <f62.2  ~>  f62.2>  [B ~+> B
                              ,B ~+> 0.1
                              ,B ~+> tick
                              ,tick ~+> tick
                              ,K ~+> B
                              ,B ~*> B
                              ,K ~*> B
                              ,K ~*> 0.1
                              ,K ~*> tick]

YES(?,O(1))