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) -> f5(K,0,0,D,E,F,G,H,I,J)         True                                                         (1,1)
          1. f5(A,B,C,D,E,F,G,H,I,J) -> f5(A,1 + B,1 + C,1,E,F,G,H,I,J) [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C] (?,1)
          2. f5(A,B,C,D,E,F,G,H,I,J) -> f5(A,B,1 + C,0,E,F,G,H,I,J)     [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C] (?,1)
          3. f5(A,B,C,D,E,F,G,H,I,J) -> f27(A,B,C,D,B,B,K,L,L,L)        [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && C >= 16] (?,1)
        Signature:
          {(f0,10);(f27,10);(f5,10)}
        Flow Graph:
          [0->{1,2,3},1->{1,2,3},2->{1,2,3},3->{}]
        
    + Applied Processor:
        ArgumentFilter [0,3,4,5,6,7,8,9]
    + Details:
        We remove following argument positions: [0,3,4,5,6,7,8,9].
* Step 2: UnsatPaths WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(B,C) -> f5(0,0)         True                                                         (1,1)
          1. f5(B,C) -> f5(1 + B,1 + C) [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C] (?,1)
          2. f5(B,C) -> f5(B,1 + C)     [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C] (?,1)
          3. f5(B,C) -> f27(B,C)        [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && C >= 16] (?,1)
        Signature:
          {(f0,10);(f27,10);(f5,10)}
        Flow Graph:
          [0->{1,2,3},1->{1,2,3},2->{1,2,3},3->{}]
        
    + Applied Processor:
        UnsatPaths
    + Details:
        We remove following edges from the transition graph: [(0,3)]
* Step 3: FromIts WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(B,C) -> f5(0,0)         True                                                         (1,1)
          1. f5(B,C) -> f5(1 + B,1 + C) [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C] (?,1)
          2. f5(B,C) -> f5(B,1 + C)     [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C] (?,1)
          3. f5(B,C) -> f27(B,C)        [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && C >= 16] (?,1)
        Signature:
          {(f0,10);(f27,10);(f5,10)}
        Flow Graph:
          [0->{1,2},1->{1,2,3},2->{1,2,3},3->{}]
        
    + Applied Processor:
        FromIts
    + Details:
        ()
* Step 4: AddSinks WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          f0(B,C) -> f5(0,0)          True
          f5(B,C) -> f5(1 + B,1 + C)  [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C]
          f5(B,C) -> f5(B,1 + C)      [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C]
          f5(B,C) -> f27(B,C)         [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && C >= 16]
        Signature:
          {(f0,10);(f27,10);(f5,10)}
        Rule Graph:
          [0->{1,2},1->{1,2,3},2->{1,2,3},3->{}]
    + Applied Processor:
        AddSinks
    + Details:
        ()
* Step 5: Decompose WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          f0(B,C)  -> f5(0,0)          True
          f5(B,C)  -> f5(1 + B,1 + C)  [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C]
          f5(B,C)  -> f5(B,1 + C)      [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C]
          f5(B,C)  -> f27(B,C)         [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && C >= 16]
          f27(B,C) -> exitus616(B,C)   True
        Signature:
          {(exitus616,2);(f0,10);(f27,10);(f5,10)}
        Rule Graph:
          [0->{1,2},1->{1,2,3},2->{1,2,3},3->{4}]
    + Applied Processor:
        Decompose Greedy
    + Details:
        We construct a looptree:
          P: [0,1,2,3,4]
          |
          `- p:[1,2] c: [1,2]
* Step 6: AbstractSize WORST_CASE(?,O(1))
    + Considered Problem:
        (Rules:
          f0(B,C)  -> f5(0,0)          True
          f5(B,C)  -> f5(1 + B,1 + C)  [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C]
          f5(B,C)  -> f5(B,1 + C)      [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && 15 >= C]
          f5(B,C)  -> f27(B,C)         [C >= 0 && B + C >= 0 && -1*B + C >= 0 && B >= 0 && C >= 16]
          f27(B,C) -> exitus616(B,C)   True
        Signature:
          {(exitus616,2);(f0,10);(f27,10);(f5,10)}
        Rule Graph:
          [0->{1,2},1->{1,2,3},2->{1,2,3},3->{4}]
        ,We construct a looptree:
          P: [0,1,2,3,4]
          |
          `- p:[1,2] c: [1,2])
    + Applied Processor:
        AbstractSize Minimize
    + Details:
        ()
* Step 7: AbstractFlow WORST_CASE(?,O(1))
    + Considered Problem:
        Program:
          Domain: [B,C,0.0]
           f0   ~>  f5          [B <= 0*K, C <= 0*K]
           f5   ~>  f5          [B <= 16*K, C <= 16*K]
           f5   ~>  f5          [B <= B, C <= 16*K]
           f5   ~>  f27         [B <= B, C <= C]
           f27  ~>  exitus616   [B <= B, C <= C]
          + Loop: [0.0 <= 15*K + B + C]
               f5  ~>  f5   [B <= 16*K, C <= 16*K]
               f5  ~>  f5   [B <= B, C <= 16*K]
    + Applied Processor:
        AbstractFlow
    + Details:
        ()
* Step 8: Lare WORST_CASE(?,O(1))
    + Considered Problem:
        Program:
          Domain: [tick,huge,K,B,C,0.0]
           f0   ~>  f5          [K ~=> B,K ~=> C]
           f5   ~>  f5          [K ~=> B,K ~=> C]
           f5   ~>  f5          [K ~=> C]
           f5   ~>  f27         []
           f27  ~>  exitus616   []
          + Loop: [B ~+> 0.0,C ~+> 0.0,K ~*> 0.0]
               f5  ~>  f5   [K ~=> B,K ~=> C]
               f5  ~>  f5   [K ~=> C]
    + Applied Processor:
        Lare
    + Details:
         f0  ~>  exitus616   [K ~=> B,K ~=> C,tick ~+> tick,K ~+> 0.0,K ~+> tick,K ~*> 0.0,K ~*> tick]
        + <f5  ~>  f5>  [K ~=> B
                        ,K ~=> C
                        ,B ~+> 0.0
                        ,B ~+> tick
                        ,C ~+> 0.0
                        ,C ~+> tick
                        ,tick ~+> tick
                        ,K ~*> 0.0
                        ,K ~*> tick]

YES(?,O(1))