YES
* Step 1: FromIts YES
    + Considered Problem:
        Rules:
          0.  evalNestedLoopstart(A,B,C,D,E,F,G,H)    -> evalNestedLoopentryin(A,B,C,D,E,F,G,H)   True                         (1,1)
          1.  evalNestedLoopentryin(A,B,C,D,E,F,G,H)  -> evalNestedLoopbb9in(A,B,C,0,E,F,G,H)     [A >= 0 && B >= 0 && C >= 0] (?,1)
          2.  evalNestedLoopbb9in(A,B,C,D,E,F,G,H)    -> evalNestedLoopreturnin(A,B,C,D,E,F,G,H)  [D >= A]                     (?,1)
          3.  evalNestedLoopbb9in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb10in(A,B,C,D,E,F,G,H)    [A >= 1 + D]                 (?,1)
          4.  evalNestedLoopbb10in(A,B,C,D,E,F,G,H)   -> evalNestedLoopbb6in(A,B,C,D,0,D,G,H)     [0 >= 1 + I]                 (?,1)
          5.  evalNestedLoopbb10in(A,B,C,D,E,F,G,H)   -> evalNestedLoopbb6in(A,B,C,D,0,D,G,H)     [I >= 1]                     (?,1)
          6.  evalNestedLoopbb10in(A,B,C,D,E,F,G,H)   -> evalNestedLoopreturnin(A,B,C,D,E,F,G,H)  True                         (?,1)
          7.  evalNestedLoopbb6in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb8in(A,B,C,D,E,F,G,H)     [E >= B]                     (?,1)
          8.  evalNestedLoopbb6in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb7in(A,B,C,D,E,F,G,H)     [B >= 1 + E]                 (?,1)
          9.  evalNestedLoopbb7in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb1in(A,B,C,D,E,F,G,H)     [0 >= 1 + I]                 (?,1)
          10. evalNestedLoopbb7in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb1in(A,B,C,D,E,F,G,H)     [I >= 1]                     (?,1)
          11. evalNestedLoopbb7in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb8in(A,B,C,D,E,F,G,H)     True                         (?,1)
          12. evalNestedLoopbb1in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb3in(A,B,C,D,E,F,1 + E,F) True                         (?,1)
          13. evalNestedLoopbb3in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb6in(A,B,C,D,G,H,G,H)     [H >= C]                     (?,1)
          14. evalNestedLoopbb3in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb4in(A,B,C,D,E,F,G,H)     [C >= 1 + H]                 (?,1)
          15. evalNestedLoopbb4in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb2in(A,B,C,D,E,F,G,H)     [0 >= 1 + I]                 (?,1)
          16. evalNestedLoopbb4in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb2in(A,B,C,D,E,F,G,H)     [I >= 1]                     (?,1)
          17. evalNestedLoopbb4in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb6in(A,B,C,D,G,H,G,H)     True                         (?,1)
          18. evalNestedLoopbb2in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb3in(A,B,C,D,E,F,G,1 + H) True                         (?,1)
          19. evalNestedLoopbb8in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb9in(A,B,C,1 + F,E,F,G,H) True                         (?,1)
          20. evalNestedLoopreturnin(A,B,C,D,E,F,G,H) -> evalNestedLoopstop(A,B,C,D,E,F,G,H)      True                         (?,1)
        Signature:
          {(evalNestedLoopbb10in,8)
          ;(evalNestedLoopbb1in,8)
          ;(evalNestedLoopbb2in,8)
          ;(evalNestedLoopbb3in,8)
          ;(evalNestedLoopbb4in,8)
          ;(evalNestedLoopbb6in,8)
          ;(evalNestedLoopbb7in,8)
          ;(evalNestedLoopbb8in,8)
          ;(evalNestedLoopbb9in,8)
          ;(evalNestedLoopentryin,8)
          ;(evalNestedLoopreturnin,8)
          ;(evalNestedLoopstart,8)
          ;(evalNestedLoopstop,8)}
        Flow Graph:
          [0->{1},1->{2,3},2->{20},3->{4,5,6},4->{7,8},5->{7,8},6->{20},7->{19},8->{9,10,11},9->{12},10->{12}
          ,11->{19},12->{13,14},13->{7,8},14->{15,16,17},15->{18},16->{18},17->{7,8},18->{13,14},19->{2,3},20->{}]
        
    + Applied Processor:
        FromIts
    + Details:
        ()
* Step 2: Decompose YES
    + Considered Problem:
        Rules:
          evalNestedLoopstart(A,B,C,D,E,F,G,H)     -> evalNestedLoopentryin(A,B,C,D,E,F,G,H)     True
          evalNestedLoopentryin(A,B,C,D,E,F,G,H)   -> evalNestedLoopbb9in(A,B,C,0,E,F,G,H)       [A >= 0
                                                                                                  && B >= 0
                                                                                                  && C >= 0]
          evalNestedLoopbb9in(A,B,C,D,E,F,G,H)     -> evalNestedLoopreturnin(A,B,C,D,E,F,G,H)    [D >= A]
          evalNestedLoopbb9in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb10in(A,B,C,D,E,F,G,H)      [A >= 1 + D]
          evalNestedLoopbb10in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb6in(A,B,C,D,0,D,G,H)       [0 >= 1 + I]
          evalNestedLoopbb10in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb6in(A,B,C,D,0,D,G,H)       [I >= 1]
          evalNestedLoopbb10in(A,B,C,D,E,F,G,H)    -> evalNestedLoopreturnin(A,B,C,D,E,F,G,H)    True
          evalNestedLoopbb6in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb8in(A,B,C,D,E,F,G,H)       [E >= B]
          evalNestedLoopbb6in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb7in(A,B,C,D,E,F,G,H)       [B >= 1 + E]
          evalNestedLoopbb7in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb1in(A,B,C,D,E,F,G,H)       [0 >= 1 + I]
          evalNestedLoopbb7in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb1in(A,B,C,D,E,F,G,H)       [I >= 1]
          evalNestedLoopbb7in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb8in(A,B,C,D,E,F,G,H)       True
          evalNestedLoopbb1in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb3in(A,B,C,D,E,F,1 + E,F)   True
          evalNestedLoopbb3in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb6in(A,B,C,D,G,H,G,H)       [H >= C]
          evalNestedLoopbb3in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb4in(A,B,C,D,E,F,G,H)       [C >= 1 + H]
          evalNestedLoopbb4in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb2in(A,B,C,D,E,F,G,H)       [0 >= 1 + I]
          evalNestedLoopbb4in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb2in(A,B,C,D,E,F,G,H)       [I >= 1]
          evalNestedLoopbb4in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb6in(A,B,C,D,G,H,G,H)       True
          evalNestedLoopbb2in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb3in(A,B,C,D,E,F,G,1 + H)   True
          evalNestedLoopbb8in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb9in(A,B,C,1 + F,E,F,G,H)   True
          evalNestedLoopreturnin(A,B,C,D,E,F,G,H)  -> evalNestedLoopstop(A,B,C,D,E,F,G,H)        True
        Signature:
          {(evalNestedLoopbb10in,8)
          ;(evalNestedLoopbb1in,8)
          ;(evalNestedLoopbb2in,8)
          ;(evalNestedLoopbb3in,8)
          ;(evalNestedLoopbb4in,8)
          ;(evalNestedLoopbb6in,8)
          ;(evalNestedLoopbb7in,8)
          ;(evalNestedLoopbb8in,8)
          ;(evalNestedLoopbb9in,8)
          ;(evalNestedLoopentryin,8)
          ;(evalNestedLoopreturnin,8)
          ;(evalNestedLoopstart,8)
          ;(evalNestedLoopstop,8)}
        Rule Graph:
          [0->{1},1->{2,3},2->{20},3->{4,5,6},4->{7,8},5->{7,8},6->{20},7->{19},8->{9,10,11},9->{12},10->{12}
          ,11->{19},12->{13,14},13->{7,8},14->{15,16,17},15->{18},16->{18},17->{7,8},18->{13,14},19->{2,3},20->{}]
    + Applied Processor:
        Decompose NoGreedy
    + Details:
        We construct a looptree:
          P: [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
          |
          `- p:[3,19,7,4,5,13,12,9,8,17,14,18,15,16,10,11] c: [3,4,5,7,11,19]
             |
             `- p:[8,13,12,9,10,18,15,14,16,17] c: [8,9,10,12,13,17]
                |
                `- p:[14,18,15,16] c: [14,15,16,18]
* Step 3: CloseWith YES
    + Considered Problem:
        (Rules:
          evalNestedLoopstart(A,B,C,D,E,F,G,H)     -> evalNestedLoopentryin(A,B,C,D,E,F,G,H)     True
          evalNestedLoopentryin(A,B,C,D,E,F,G,H)   -> evalNestedLoopbb9in(A,B,C,0,E,F,G,H)       [A >= 0
                                                                                                  && B >= 0
                                                                                                  && C >= 0]
          evalNestedLoopbb9in(A,B,C,D,E,F,G,H)     -> evalNestedLoopreturnin(A,B,C,D,E,F,G,H)    [D >= A]
          evalNestedLoopbb9in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb10in(A,B,C,D,E,F,G,H)      [A >= 1 + D]
          evalNestedLoopbb10in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb6in(A,B,C,D,0,D,G,H)       [0 >= 1 + I]
          evalNestedLoopbb10in(A,B,C,D,E,F,G,H)    -> evalNestedLoopbb6in(A,B,C,D,0,D,G,H)       [I >= 1]
          evalNestedLoopbb10in(A,B,C,D,E,F,G,H)    -> evalNestedLoopreturnin(A,B,C,D,E,F,G,H)    True
          evalNestedLoopbb6in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb8in(A,B,C,D,E,F,G,H)       [E >= B]
          evalNestedLoopbb6in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb7in(A,B,C,D,E,F,G,H)       [B >= 1 + E]
          evalNestedLoopbb7in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb1in(A,B,C,D,E,F,G,H)       [0 >= 1 + I]
          evalNestedLoopbb7in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb1in(A,B,C,D,E,F,G,H)       [I >= 1]
          evalNestedLoopbb7in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb8in(A,B,C,D,E,F,G,H)       True
          evalNestedLoopbb1in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb3in(A,B,C,D,E,F,1 + E,F)   True
          evalNestedLoopbb3in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb6in(A,B,C,D,G,H,G,H)       [H >= C]
          evalNestedLoopbb3in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb4in(A,B,C,D,E,F,G,H)       [C >= 1 + H]
          evalNestedLoopbb4in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb2in(A,B,C,D,E,F,G,H)       [0 >= 1 + I]
          evalNestedLoopbb4in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb2in(A,B,C,D,E,F,G,H)       [I >= 1]
          evalNestedLoopbb4in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb6in(A,B,C,D,G,H,G,H)       True
          evalNestedLoopbb2in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb3in(A,B,C,D,E,F,G,1 + H)   True
          evalNestedLoopbb8in(A,B,C,D,E,F,G,H)     -> evalNestedLoopbb9in(A,B,C,1 + F,E,F,G,H)   True
          evalNestedLoopreturnin(A,B,C,D,E,F,G,H)  -> evalNestedLoopstop(A,B,C,D,E,F,G,H)        True
        Signature:
          {(evalNestedLoopbb10in,8)
          ;(evalNestedLoopbb1in,8)
          ;(evalNestedLoopbb2in,8)
          ;(evalNestedLoopbb3in,8)
          ;(evalNestedLoopbb4in,8)
          ;(evalNestedLoopbb6in,8)
          ;(evalNestedLoopbb7in,8)
          ;(evalNestedLoopbb8in,8)
          ;(evalNestedLoopbb9in,8)
          ;(evalNestedLoopentryin,8)
          ;(evalNestedLoopreturnin,8)
          ;(evalNestedLoopstart,8)
          ;(evalNestedLoopstop,8)}
        Rule Graph:
          [0->{1},1->{2,3},2->{20},3->{4,5,6},4->{7,8},5->{7,8},6->{20},7->{19},8->{9,10,11},9->{12},10->{12}
          ,11->{19},12->{13,14},13->{7,8},14->{15,16,17},15->{18},16->{18},17->{7,8},18->{13,14},19->{2,3},20->{}]
        ,We construct a looptree:
          P: [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
          |
          `- p:[3,19,7,4,5,13,12,9,8,17,14,18,15,16,10,11] c: [3,4,5,7,11,19]
             |
             `- p:[8,13,12,9,10,18,15,14,16,17] c: [8,9,10,12,13,17]
                |
                `- p:[14,18,15,16] c: [14,15,16,18])
    + Applied Processor:
        CloseWith True
    + Details:
        ()

YES