YES(?,O(1))
* Step 1: UnsatPaths WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(A,B,C,D,E)  -> f4(0,B,C,D,E)      True                                                              (1,1)
          1. f24(A,B,C,D,E) -> f24(A,1 + B,B,D,E) [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && 199 >= B] (?,1)
          2. f24(A,B,C,D,E) -> f37(A,B,C,D,E)     [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && B >= 200] (?,1)
          3. f4(A,B,C,D,E)  -> f4(1 + A,B,C,A,A)  [A >= 0 && 99 >= A]                                               (?,1)
          4. f4(A,B,C,D,E)  -> f24(A,100,C,D,E)   [A >= 0 && A >= 100]                                              (?,1)
        Signature:
          {(f0,5);(f24,5);(f37,5);(f4,5)}
        Flow Graph:
          [0->{3,4},1->{1,2},2->{},3->{3,4},4->{1,2}]
        
    + Applied Processor:
        UnsatPaths
    + Details:
        We remove following edges from the transition graph: [(0,4),(4,2)]
* Step 2: TrivialSCCs WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(A,B,C,D,E)  -> f4(0,B,C,D,E)      True                                                              (1,1)
          1. f24(A,B,C,D,E) -> f24(A,1 + B,B,D,E) [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && 199 >= B] (?,1)
          2. f24(A,B,C,D,E) -> f37(A,B,C,D,E)     [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && B >= 200] (?,1)
          3. f4(A,B,C,D,E)  -> f4(1 + A,B,C,A,A)  [A >= 0 && 99 >= A]                                               (?,1)
          4. f4(A,B,C,D,E)  -> f24(A,100,C,D,E)   [A >= 0 && A >= 100]                                              (?,1)
        Signature:
          {(f0,5);(f24,5);(f37,5);(f4,5)}
        Flow Graph:
          [0->{3},1->{1,2},2->{},3->{3,4},4->{1}]
        
    + Applied Processor:
        TrivialSCCs
    + Details:
        All trivial SCCs of the transition graph admit timebound 1.
* Step 3: PolyRank WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(A,B,C,D,E)  -> f4(0,B,C,D,E)      True                                                              (1,1)
          1. f24(A,B,C,D,E) -> f24(A,1 + B,B,D,E) [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && 199 >= B] (?,1)
          2. f24(A,B,C,D,E) -> f37(A,B,C,D,E)     [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && B >= 200] (1,1)
          3. f4(A,B,C,D,E)  -> f4(1 + A,B,C,A,A)  [A >= 0 && 99 >= A]                                               (?,1)
          4. f4(A,B,C,D,E)  -> f24(A,100,C,D,E)   [A >= 0 && A >= 100]                                              (1,1)
        Signature:
          {(f0,5);(f24,5);(f37,5);(f4,5)}
        Flow Graph:
          [0->{3},1->{1,2},2->{},3->{3,4},4->{1}]
        
    + Applied Processor:
        PolyRank {useFarkas = True, withSizebounds = [], shape = Linear}
    + Details:
        We apply a polynomial interpretation of shape linear:
           p(f0) = 100        
          p(f24) = 100 + -1*x1
          p(f37) = 100 + -1*x1
           p(f4) = 100 + -1*x1
        
        Following rules are strictly oriented:
        [A >= 0 && 99 >= A] ==>                  
              f4(A,B,C,D,E)   = 100 + -1*A       
                              > 99 + -1*A        
                              = f4(1 + A,B,C,A,A)
        
        
        Following rules are weakly oriented:
                                                                     True ==>                   
                                                            f0(A,B,C,D,E)   = 100               
                                                                           >= 100               
                                                                            = f4(0,B,C,D,E)     
        
        [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && 199 >= B] ==>                   
                                                           f24(A,B,C,D,E)   = 100 + -1*A        
                                                                           >= 100 + -1*A        
                                                                            = f24(A,1 + B,B,D,E)
        
        [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && B >= 200] ==>                   
                                                           f24(A,B,C,D,E)   = 100 + -1*A        
                                                                           >= 100 + -1*A        
                                                                            = f37(A,B,C,D,E)    
        
                                                     [A >= 0 && A >= 100] ==>                   
                                                            f4(A,B,C,D,E)   = 100 + -1*A        
                                                                           >= 100 + -1*A        
                                                                            = f24(A,100,C,D,E)  
        
        
* Step 4: PolyRank WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(A,B,C,D,E)  -> f4(0,B,C,D,E)      True                                                              (1,1)  
          1. f24(A,B,C,D,E) -> f24(A,1 + B,B,D,E) [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && 199 >= B] (?,1)  
          2. f24(A,B,C,D,E) -> f37(A,B,C,D,E)     [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && B >= 200] (1,1)  
          3. f4(A,B,C,D,E)  -> f4(1 + A,B,C,A,A)  [A >= 0 && 99 >= A]                                               (100,1)
          4. f4(A,B,C,D,E)  -> f24(A,100,C,D,E)   [A >= 0 && A >= 100]                                              (1,1)  
        Signature:
          {(f0,5);(f24,5);(f37,5);(f4,5)}
        Flow Graph:
          [0->{3},1->{1,2},2->{},3->{3,4},4->{1}]
        
    + Applied Processor:
        PolyRank {useFarkas = True, withSizebounds = [], shape = Linear}
    + Details:
        We apply a polynomial interpretation of shape linear:
           p(f0) = 100        
          p(f24) = 200 + -1*x2
          p(f37) = 200 + -1*x2
           p(f4) = 100        
        
        Following rules are strictly oriented:
        [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && 199 >= B] ==>                   
                                                           f24(A,B,C,D,E)   = 200 + -1*B        
                                                                            > 199 + -1*B        
                                                                            = f24(A,1 + B,B,D,E)
        
        
        Following rules are weakly oriented:
                                                                     True ==>                  
                                                            f0(A,B,C,D,E)   = 100              
                                                                           >= 100              
                                                                            = f4(0,B,C,D,E)    
        
        [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && B >= 200] ==>                  
                                                           f24(A,B,C,D,E)   = 200 + -1*B       
                                                                           >= 200 + -1*B       
                                                                            = f37(A,B,C,D,E)   
        
                                                      [A >= 0 && 99 >= A] ==>                  
                                                            f4(A,B,C,D,E)   = 100              
                                                                           >= 100              
                                                                            = f4(1 + A,B,C,A,A)
        
                                                     [A >= 0 && A >= 100] ==>                  
                                                            f4(A,B,C,D,E)   = 100              
                                                                           >= 100              
                                                                            = f24(A,100,C,D,E) 
        
        
* Step 5: KnowledgePropagation WORST_CASE(?,O(1))
    + Considered Problem:
        Rules:
          0. f0(A,B,C,D,E)  -> f4(0,B,C,D,E)      True                                                              (1,1)  
          1. f24(A,B,C,D,E) -> f24(A,1 + B,B,D,E) [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && 199 >= B] (100,1)
          2. f24(A,B,C,D,E) -> f37(A,B,C,D,E)     [-100 + B >= 0 && -200 + A + B >= 0 && -100 + A >= 0 && B >= 200] (1,1)  
          3. f4(A,B,C,D,E)  -> f4(1 + A,B,C,A,A)  [A >= 0 && 99 >= A]                                               (100,1)
          4. f4(A,B,C,D,E)  -> f24(A,100,C,D,E)   [A >= 0 && A >= 100]                                              (1,1)  
        Signature:
          {(f0,5);(f24,5);(f37,5);(f4,5)}
        Flow Graph:
          [0->{3},1->{1,2},2->{},3->{3,4},4->{1}]
        
    + Applied Processor:
        KnowledgePropagation
    + Details:
        The problem is already solved.

YES(?,O(1))