YES
* Step 1: UnsatRules YES
    + Considered Problem:
        Rules:
          0.  evalcomplexstart(A,B,C,D,E)    -> evalcomplexentryin(A,B,C,D,E)          True                          (1,1)
          1.  evalcomplexentryin(A,B,C,D,E)  -> evalcomplexbb10in(B,A,C,D,E)           True                          (?,1)
          2.  evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexbb8in(A,B,A,B,E)            [29 >= B]                     (?,1)
          3.  evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexreturnin(A,B,C,D,E)         [B >= 30]                     (?,1)
          4.  evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb1in(A,B,C,D,E)            [D >= 1 + C]                  (?,1)
          5.  evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb9in(A,B,C,D,E)            [C >= D]                      (?,1)
          6.  evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,7 + C)        [C >= 6 && 2 >= C]            (?,1)
          7.  evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,7 + C)        [C >= 6]                      (?,1)
          8.  evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb6in(A,B,C,D,7 + C)        [C >= 6 && C >= 3 && 5 >= C]  (?,1)
          9.  evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,2 + C)        [5 >= C && 7 >= C]            (?,1)
          10. evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,2 + C)        [5 >= C && C >= 11]           (?,1)
          11. evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb6in(A,B,C,D,2 + C)        [5 >= C && C >= 8 && 10 >= C] (?,1)
          12. evalcomplexbb7in(A,B,C,D,E)    -> evalcomplexbb8in(A,B,E,1 + D,E)        True                          (?,1)
          13. evalcomplexbb6in(A,B,C,D,E)    -> evalcomplexbb8in(A,B,E,10 + D,E)       True                          (?,1)
          14. evalcomplexbb9in(A,B,C,D,E)    -> evalcomplexbb10in(-10 + C,2 + D,C,D,E) True                          (?,1)
          15. evalcomplexreturnin(A,B,C,D,E) -> evalcomplexstop(A,B,C,D,E)             True                          (?,1)
        Signature:
          {(evalcomplexbb10in,5)
          ;(evalcomplexbb1in,5)
          ;(evalcomplexbb6in,5)
          ;(evalcomplexbb7in,5)
          ;(evalcomplexbb8in,5)
          ;(evalcomplexbb9in,5)
          ;(evalcomplexentryin,5)
          ;(evalcomplexreturnin,5)
          ;(evalcomplexstart,5)
          ;(evalcomplexstop,5)}
        Flow Graph:
          [0->{1},1->{2,3},2->{4,5},3->{15},4->{6,7,8,9,10,11},5->{14},6->{12},7->{12},8->{13},9->{12},10->{12}
          ,11->{13},12->{4,5},13->{4,5},14->{2,3},15->{}]
        
    + Applied Processor:
        UnsatRules
    + Details:
        Following transitions have unsatisfiable constraints and are removed:  [6,8,10,11]
* Step 2: UnreachableRules YES
    + Considered Problem:
        Rules:
          0.  evalcomplexstart(A,B,C,D,E)    -> evalcomplexentryin(A,B,C,D,E)          True               (1,1)
          1.  evalcomplexentryin(A,B,C,D,E)  -> evalcomplexbb10in(B,A,C,D,E)           True               (?,1)
          2.  evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexbb8in(A,B,A,B,E)            [29 >= B]          (?,1)
          3.  evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexreturnin(A,B,C,D,E)         [B >= 30]          (?,1)
          4.  evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb1in(A,B,C,D,E)            [D >= 1 + C]       (?,1)
          5.  evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb9in(A,B,C,D,E)            [C >= D]           (?,1)
          7.  evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,7 + C)        [C >= 6]           (?,1)
          9.  evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,2 + C)        [5 >= C && 7 >= C] (?,1)
          12. evalcomplexbb7in(A,B,C,D,E)    -> evalcomplexbb8in(A,B,E,1 + D,E)        True               (?,1)
          13. evalcomplexbb6in(A,B,C,D,E)    -> evalcomplexbb8in(A,B,E,10 + D,E)       True               (?,1)
          14. evalcomplexbb9in(A,B,C,D,E)    -> evalcomplexbb10in(-10 + C,2 + D,C,D,E) True               (?,1)
          15. evalcomplexreturnin(A,B,C,D,E) -> evalcomplexstop(A,B,C,D,E)             True               (?,1)
        Signature:
          {(evalcomplexbb10in,5)
          ;(evalcomplexbb1in,5)
          ;(evalcomplexbb6in,5)
          ;(evalcomplexbb7in,5)
          ;(evalcomplexbb8in,5)
          ;(evalcomplexbb9in,5)
          ;(evalcomplexentryin,5)
          ;(evalcomplexreturnin,5)
          ;(evalcomplexstart,5)
          ;(evalcomplexstop,5)}
        Flow Graph:
          [0->{1},1->{2,3},2->{4,5},3->{15},4->{7,9},5->{14},7->{12},9->{12},12->{4,5},13->{4,5},14->{2,3},15->{}]
        
    + Applied Processor:
        UnreachableRules
    + Details:
        Following transitions are not reachable from the starting states and are revomed: [13]
* Step 3: FromIts YES
    + Considered Problem:
        Rules:
          0.  evalcomplexstart(A,B,C,D,E)    -> evalcomplexentryin(A,B,C,D,E)          True               (1,1)
          1.  evalcomplexentryin(A,B,C,D,E)  -> evalcomplexbb10in(B,A,C,D,E)           True               (?,1)
          2.  evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexbb8in(A,B,A,B,E)            [29 >= B]          (?,1)
          3.  evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexreturnin(A,B,C,D,E)         [B >= 30]          (?,1)
          4.  evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb1in(A,B,C,D,E)            [D >= 1 + C]       (?,1)
          5.  evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb9in(A,B,C,D,E)            [C >= D]           (?,1)
          7.  evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,7 + C)        [C >= 6]           (?,1)
          9.  evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,2 + C)        [5 >= C && 7 >= C] (?,1)
          12. evalcomplexbb7in(A,B,C,D,E)    -> evalcomplexbb8in(A,B,E,1 + D,E)        True               (?,1)
          14. evalcomplexbb9in(A,B,C,D,E)    -> evalcomplexbb10in(-10 + C,2 + D,C,D,E) True               (?,1)
          15. evalcomplexreturnin(A,B,C,D,E) -> evalcomplexstop(A,B,C,D,E)             True               (?,1)
        Signature:
          {(evalcomplexbb10in,5)
          ;(evalcomplexbb1in,5)
          ;(evalcomplexbb6in,5)
          ;(evalcomplexbb7in,5)
          ;(evalcomplexbb8in,5)
          ;(evalcomplexbb9in,5)
          ;(evalcomplexentryin,5)
          ;(evalcomplexreturnin,5)
          ;(evalcomplexstart,5)
          ;(evalcomplexstop,5)}
        Flow Graph:
          [0->{1},1->{2,3},2->{4,5},3->{15},4->{7,9},5->{14},7->{12},9->{12},12->{4,5},14->{2,3},15->{}]
        
    + Applied Processor:
        FromIts
    + Details:
        ()
* Step 4: Decompose YES
    + Considered Problem:
        Rules:
          evalcomplexstart(A,B,C,D,E)    -> evalcomplexentryin(A,B,C,D,E)            True
          evalcomplexentryin(A,B,C,D,E)  -> evalcomplexbb10in(B,A,C,D,E)             True
          evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexbb8in(A,B,A,B,E)              [29 >= B]
          evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexreturnin(A,B,C,D,E)           [B >= 30]
          evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb1in(A,B,C,D,E)              [D >= 1 + C]
          evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb9in(A,B,C,D,E)              [C >= D]
          evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,7 + C)          [C >= 6]
          evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,2 + C)          [5 >= C && 7 >= C]
          evalcomplexbb7in(A,B,C,D,E)    -> evalcomplexbb8in(A,B,E,1 + D,E)          True
          evalcomplexbb9in(A,B,C,D,E)    -> evalcomplexbb10in(-10 + C,2 + D,C,D,E)   True
          evalcomplexreturnin(A,B,C,D,E) -> evalcomplexstop(A,B,C,D,E)               True
        Signature:
          {(evalcomplexbb10in,5)
          ;(evalcomplexbb1in,5)
          ;(evalcomplexbb6in,5)
          ;(evalcomplexbb7in,5)
          ;(evalcomplexbb8in,5)
          ;(evalcomplexbb9in,5)
          ;(evalcomplexentryin,5)
          ;(evalcomplexreturnin,5)
          ;(evalcomplexstart,5)
          ;(evalcomplexstop,5)}
        Rule Graph:
          [0->{1},1->{2,3},2->{4,5},3->{15},4->{7,9},5->{14},7->{12},9->{12},12->{4,5},14->{2,3},15->{}]
    + Applied Processor:
        Decompose NoGreedy
    + Details:
        We construct a looptree:
          P: [0,1,2,3,4,5,7,9,12,14,15]
          |
          `- p:[2,14,5,12,7,4,9] c: [2,5,14]
             |
             `- p:[4,12,7,9] c: [9]
                |
                `- p:[4,12,7] c: [4,7,12]
* Step 5: CloseWith YES
    + Considered Problem:
        (Rules:
          evalcomplexstart(A,B,C,D,E)    -> evalcomplexentryin(A,B,C,D,E)            True
          evalcomplexentryin(A,B,C,D,E)  -> evalcomplexbb10in(B,A,C,D,E)             True
          evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexbb8in(A,B,A,B,E)              [29 >= B]
          evalcomplexbb10in(A,B,C,D,E)   -> evalcomplexreturnin(A,B,C,D,E)           [B >= 30]
          evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb1in(A,B,C,D,E)              [D >= 1 + C]
          evalcomplexbb8in(A,B,C,D,E)    -> evalcomplexbb9in(A,B,C,D,E)              [C >= D]
          evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,7 + C)          [C >= 6]
          evalcomplexbb1in(A,B,C,D,E)    -> evalcomplexbb7in(A,B,C,D,2 + C)          [5 >= C && 7 >= C]
          evalcomplexbb7in(A,B,C,D,E)    -> evalcomplexbb8in(A,B,E,1 + D,E)          True
          evalcomplexbb9in(A,B,C,D,E)    -> evalcomplexbb10in(-10 + C,2 + D,C,D,E)   True
          evalcomplexreturnin(A,B,C,D,E) -> evalcomplexstop(A,B,C,D,E)               True
        Signature:
          {(evalcomplexbb10in,5)
          ;(evalcomplexbb1in,5)
          ;(evalcomplexbb6in,5)
          ;(evalcomplexbb7in,5)
          ;(evalcomplexbb8in,5)
          ;(evalcomplexbb9in,5)
          ;(evalcomplexentryin,5)
          ;(evalcomplexreturnin,5)
          ;(evalcomplexstart,5)
          ;(evalcomplexstop,5)}
        Rule Graph:
          [0->{1},1->{2,3},2->{4,5},3->{15},4->{7,9},5->{14},7->{12},9->{12},12->{4,5},14->{2,3},15->{}]
        ,We construct a looptree:
          P: [0,1,2,3,4,5,7,9,12,14,15]
          |
          `- p:[2,14,5,12,7,4,9] c: [2,5,14]
             |
             `- p:[4,12,7,9] c: [9]
                |
                `- p:[4,12,7] c: [4,7,12])
    + Applied Processor:
        CloseWith True
    + Details:
        ()

YES