YES
* Step 1: UnsatPaths YES
    + Considered Problem:
        Rules:
          0.  evalrealheapsortstep1start(A,B,C)    -> evalrealheapsortstep1entryin(A,B,C)    True                                                                                                         (1,1)
          1.  evalrealheapsortstep1entryin(A,B,C)  -> evalrealheapsortstep1returnin(A,B,C)   [2 >= A]                                                                                                     (?,1)
          2.  evalrealheapsortstep1entryin(A,B,C)  -> evalrealheapsortstep1bb6in(A,1,C)      [A >= 3]                                                                                                     (?,1)
          3.  evalrealheapsortstep1returnin(A,B,C) -> evalrealheapsortstep1stop(A,B,C)       True                                                                                                         (?,1)
          4.  evalrealheapsortstep1bb6in(A,B,C)    -> evalrealheapsortstep1bb3in(A,B,B)      [-1 + B >= 0 && -4 + A + B >= 0 && -3 + A >= 0 && A >= 1 + B]                                                (?,1)
          5.  evalrealheapsortstep1bb3in(A,B,C)    -> evalrealheapsortstep1bb4in(A,B,C)      [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && C >= 1]                                                                                                       
          6.  evalrealheapsortstep1bb3in(A,B,C)    -> evalrealheapsortstep1bb5in(A,B,C)      [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && 0 >= C]                                                                                                       
          7.  evalrealheapsortstep1bb4in(A,B,C)    -> evalrealheapsortstep1bb5in(A,B,C)      [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + C >= 0                                                                                                   
                                                                                              && -2 + B + C >= 0                                                                                               
                                                                                              && -4 + A + C >= 0                                                                                               
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && C >= 0                                                                                                        
                                                                                              && D >= 0                                                                                                        
                                                                                              && 1 + C >= 2*D                                                                                                  
                                                                                              && 2*D >= C]                                                                                                     
          8.  evalrealheapsortstep1bb4in(A,B,C)    -> evalrealheapsortstep1bb2in(A,B,C)      [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + C >= 0                                                                                                   
                                                                                              && -2 + B + C >= 0                                                                                               
                                                                                              && -4 + A + C >= 0                                                                                               
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && C >= 0                                                                                                        
                                                                                              && D >= 0                                                                                                        
                                                                                              && 1 + C >= 2*D                                                                                                  
                                                                                              && 2*D >= C]                                                                                                     
          9.  evalrealheapsortstep1bb5in(A,B,C)    -> evalrealheapsortstep1bb6in(A,1 + B,C)  [B + -1*C >= 0 && -1 + A + -1*C >= 0 && -1 + A + -1*B >= 0 && -1 + B >= 0 && -4 + A + B >= 0 && -3 + A >= 0] (?,1)
          10. evalrealheapsortstep1bb6in(A,B,C)    -> evalrealheapsortstep1returnin(A,B,C)   [-1 + B >= 0 && -4 + A + B >= 0 && -3 + A >= 0 && B >= A]                                                    (?,1)
          11. evalrealheapsortstep1bb2in(A,B,C)    -> evalrealheapsortstep1bb3in(A,B,-1 + D) [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + C >= 0                                                                                                   
                                                                                              && -2 + B + C >= 0                                                                                               
                                                                                              && -4 + A + C >= 0                                                                                               
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && C >= 0                                                                                                        
                                                                                              && E >= 0                                                                                                        
                                                                                              && 1 + C >= 2*E                                                                                                  
                                                                                              && 2*E >= C                                                                                                      
                                                                                              && F >= 0                                                                                                        
                                                                                              && 1 + C >= 2*F                                                                                                  
                                                                                              && 2*F >= C                                                                                                      
                                                                                              && D >= 0                                                                                                        
                                                                                              && 1 + C >= 2*D                                                                                                  
                                                                                              && 2*D >= C]                                                                                                     
        Signature:
          {(evalrealheapsortstep1bb2in,3)
          ;(evalrealheapsortstep1bb3in,3)
          ;(evalrealheapsortstep1bb4in,3)
          ;(evalrealheapsortstep1bb5in,3)
          ;(evalrealheapsortstep1bb6in,3)
          ;(evalrealheapsortstep1entryin,3)
          ;(evalrealheapsortstep1returnin,3)
          ;(evalrealheapsortstep1start,3)
          ;(evalrealheapsortstep1stop,3)}
        Flow Graph:
          [0->{1,2},1->{3},2->{4,10},3->{},4->{5,6},5->{7,8},6->{9},7->{9},8->{11},9->{4,10},10->{3},11->{5,6}]
        
    + Applied Processor:
        UnsatPaths
    + Details:
        We remove following edges from the transition graph: [(2,10),(4,6)]
* Step 2: FromIts YES
    + Considered Problem:
        Rules:
          0.  evalrealheapsortstep1start(A,B,C)    -> evalrealheapsortstep1entryin(A,B,C)    True                                                                                                         (1,1)
          1.  evalrealheapsortstep1entryin(A,B,C)  -> evalrealheapsortstep1returnin(A,B,C)   [2 >= A]                                                                                                     (?,1)
          2.  evalrealheapsortstep1entryin(A,B,C)  -> evalrealheapsortstep1bb6in(A,1,C)      [A >= 3]                                                                                                     (?,1)
          3.  evalrealheapsortstep1returnin(A,B,C) -> evalrealheapsortstep1stop(A,B,C)       True                                                                                                         (?,1)
          4.  evalrealheapsortstep1bb6in(A,B,C)    -> evalrealheapsortstep1bb3in(A,B,B)      [-1 + B >= 0 && -4 + A + B >= 0 && -3 + A >= 0 && A >= 1 + B]                                                (?,1)
          5.  evalrealheapsortstep1bb3in(A,B,C)    -> evalrealheapsortstep1bb4in(A,B,C)      [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && C >= 1]                                                                                                       
          6.  evalrealheapsortstep1bb3in(A,B,C)    -> evalrealheapsortstep1bb5in(A,B,C)      [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && 0 >= C]                                                                                                       
          7.  evalrealheapsortstep1bb4in(A,B,C)    -> evalrealheapsortstep1bb5in(A,B,C)      [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + C >= 0                                                                                                   
                                                                                              && -2 + B + C >= 0                                                                                               
                                                                                              && -4 + A + C >= 0                                                                                               
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && C >= 0                                                                                                        
                                                                                              && D >= 0                                                                                                        
                                                                                              && 1 + C >= 2*D                                                                                                  
                                                                                              && 2*D >= C]                                                                                                     
          8.  evalrealheapsortstep1bb4in(A,B,C)    -> evalrealheapsortstep1bb2in(A,B,C)      [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + C >= 0                                                                                                   
                                                                                              && -2 + B + C >= 0                                                                                               
                                                                                              && -4 + A + C >= 0                                                                                               
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && C >= 0                                                                                                        
                                                                                              && D >= 0                                                                                                        
                                                                                              && 1 + C >= 2*D                                                                                                  
                                                                                              && 2*D >= C]                                                                                                     
          9.  evalrealheapsortstep1bb5in(A,B,C)    -> evalrealheapsortstep1bb6in(A,1 + B,C)  [B + -1*C >= 0 && -1 + A + -1*C >= 0 && -1 + A + -1*B >= 0 && -1 + B >= 0 && -4 + A + B >= 0 && -3 + A >= 0] (?,1)
          10. evalrealheapsortstep1bb6in(A,B,C)    -> evalrealheapsortstep1returnin(A,B,C)   [-1 + B >= 0 && -4 + A + B >= 0 && -3 + A >= 0 && B >= A]                                                    (?,1)
          11. evalrealheapsortstep1bb2in(A,B,C)    -> evalrealheapsortstep1bb3in(A,B,-1 + D) [B + -1*C >= 0                                                                                               (?,1)
                                                                                              && -1 + A + -1*C >= 0                                                                                            
                                                                                              && -1 + C >= 0                                                                                                   
                                                                                              && -2 + B + C >= 0                                                                                               
                                                                                              && -4 + A + C >= 0                                                                                               
                                                                                              && -1 + A + -1*B >= 0                                                                                            
                                                                                              && -1 + B >= 0                                                                                                   
                                                                                              && -4 + A + B >= 0                                                                                               
                                                                                              && -3 + A >= 0                                                                                                   
                                                                                              && C >= 0                                                                                                        
                                                                                              && E >= 0                                                                                                        
                                                                                              && 1 + C >= 2*E                                                                                                  
                                                                                              && 2*E >= C                                                                                                      
                                                                                              && F >= 0                                                                                                        
                                                                                              && 1 + C >= 2*F                                                                                                  
                                                                                              && 2*F >= C                                                                                                      
                                                                                              && D >= 0                                                                                                        
                                                                                              && 1 + C >= 2*D                                                                                                  
                                                                                              && 2*D >= C]                                                                                                     
        Signature:
          {(evalrealheapsortstep1bb2in,3)
          ;(evalrealheapsortstep1bb3in,3)
          ;(evalrealheapsortstep1bb4in,3)
          ;(evalrealheapsortstep1bb5in,3)
          ;(evalrealheapsortstep1bb6in,3)
          ;(evalrealheapsortstep1entryin,3)
          ;(evalrealheapsortstep1returnin,3)
          ;(evalrealheapsortstep1start,3)
          ;(evalrealheapsortstep1stop,3)}
        Flow Graph:
          [0->{1,2},1->{3},2->{4},3->{},4->{5},5->{7,8},6->{9},7->{9},8->{11},9->{4,10},10->{3},11->{5,6}]
        
    + Applied Processor:
        FromIts
    + Details:
        ()
* Step 3: Decompose YES
    + Considered Problem:
        Rules:
          evalrealheapsortstep1start(A,B,C)     -> evalrealheapsortstep1entryin(A,B,C)      True
          evalrealheapsortstep1entryin(A,B,C)   -> evalrealheapsortstep1returnin(A,B,C)     [2 >= A]
          evalrealheapsortstep1entryin(A,B,C)   -> evalrealheapsortstep1bb6in(A,1,C)        [A >= 3]
          evalrealheapsortstep1returnin(A,B,C)  -> evalrealheapsortstep1stop(A,B,C)         True
          evalrealheapsortstep1bb6in(A,B,C)     -> evalrealheapsortstep1bb3in(A,B,B)        [-1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && A >= 1 + B]
          evalrealheapsortstep1bb3in(A,B,C)     -> evalrealheapsortstep1bb4in(A,B,C)        [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && C >= 1]
          evalrealheapsortstep1bb3in(A,B,C)     -> evalrealheapsortstep1bb5in(A,B,C)        [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && 0 >= C]
          evalrealheapsortstep1bb4in(A,B,C)     -> evalrealheapsortstep1bb5in(A,B,C)        [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + C >= 0
                                                                                             && -2 + B + C >= 0
                                                                                             && -4 + A + C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && C >= 0
                                                                                             && D >= 0
                                                                                             && 1 + C >= 2*D
                                                                                             && 2*D >= C]
          evalrealheapsortstep1bb4in(A,B,C)     -> evalrealheapsortstep1bb2in(A,B,C)        [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + C >= 0
                                                                                             && -2 + B + C >= 0
                                                                                             && -4 + A + C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && C >= 0
                                                                                             && D >= 0
                                                                                             && 1 + C >= 2*D
                                                                                             && 2*D >= C]
          evalrealheapsortstep1bb5in(A,B,C)     -> evalrealheapsortstep1bb6in(A,1 + B,C)    [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0]
          evalrealheapsortstep1bb6in(A,B,C)     -> evalrealheapsortstep1returnin(A,B,C)     [-1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && B >= A]
          evalrealheapsortstep1bb2in(A,B,C)     -> evalrealheapsortstep1bb3in(A,B,-1 + D)   [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + C >= 0
                                                                                             && -2 + B + C >= 0
                                                                                             && -4 + A + C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && C >= 0
                                                                                             && E >= 0
                                                                                             && 1 + C >= 2*E
                                                                                             && 2*E >= C
                                                                                             && F >= 0
                                                                                             && 1 + C >= 2*F
                                                                                             && 2*F >= C
                                                                                             && D >= 0
                                                                                             && 1 + C >= 2*D
                                                                                             && 2*D >= C]
        Signature:
          {(evalrealheapsortstep1bb2in,3)
          ;(evalrealheapsortstep1bb3in,3)
          ;(evalrealheapsortstep1bb4in,3)
          ;(evalrealheapsortstep1bb5in,3)
          ;(evalrealheapsortstep1bb6in,3)
          ;(evalrealheapsortstep1entryin,3)
          ;(evalrealheapsortstep1returnin,3)
          ;(evalrealheapsortstep1start,3)
          ;(evalrealheapsortstep1stop,3)}
        Rule Graph:
          [0->{1,2},1->{3},2->{4},3->{},4->{5},5->{7,8},6->{9},7->{9},8->{11},9->{4,10},10->{3},11->{5,6}]
    + Applied Processor:
        Decompose NoGreedy
    + Details:
        We construct a looptree:
          P: [0,1,2,3,4,5,6,7,8,9,10,11]
          |
          `- p:[4,9,6,11,8,5,7] c: [4,6,7,9]
             |
             `- p:[5,11,8] c: [5,8,11]
* Step 4: CloseWith YES
    + Considered Problem:
        (Rules:
          evalrealheapsortstep1start(A,B,C)     -> evalrealheapsortstep1entryin(A,B,C)      True
          evalrealheapsortstep1entryin(A,B,C)   -> evalrealheapsortstep1returnin(A,B,C)     [2 >= A]
          evalrealheapsortstep1entryin(A,B,C)   -> evalrealheapsortstep1bb6in(A,1,C)        [A >= 3]
          evalrealheapsortstep1returnin(A,B,C)  -> evalrealheapsortstep1stop(A,B,C)         True
          evalrealheapsortstep1bb6in(A,B,C)     -> evalrealheapsortstep1bb3in(A,B,B)        [-1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && A >= 1 + B]
          evalrealheapsortstep1bb3in(A,B,C)     -> evalrealheapsortstep1bb4in(A,B,C)        [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && C >= 1]
          evalrealheapsortstep1bb3in(A,B,C)     -> evalrealheapsortstep1bb5in(A,B,C)        [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && 0 >= C]
          evalrealheapsortstep1bb4in(A,B,C)     -> evalrealheapsortstep1bb5in(A,B,C)        [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + C >= 0
                                                                                             && -2 + B + C >= 0
                                                                                             && -4 + A + C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && C >= 0
                                                                                             && D >= 0
                                                                                             && 1 + C >= 2*D
                                                                                             && 2*D >= C]
          evalrealheapsortstep1bb4in(A,B,C)     -> evalrealheapsortstep1bb2in(A,B,C)        [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + C >= 0
                                                                                             && -2 + B + C >= 0
                                                                                             && -4 + A + C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && C >= 0
                                                                                             && D >= 0
                                                                                             && 1 + C >= 2*D
                                                                                             && 2*D >= C]
          evalrealheapsortstep1bb5in(A,B,C)     -> evalrealheapsortstep1bb6in(A,1 + B,C)    [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0]
          evalrealheapsortstep1bb6in(A,B,C)     -> evalrealheapsortstep1returnin(A,B,C)     [-1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && B >= A]
          evalrealheapsortstep1bb2in(A,B,C)     -> evalrealheapsortstep1bb3in(A,B,-1 + D)   [B + -1*C >= 0
                                                                                             && -1 + A + -1*C >= 0
                                                                                             && -1 + C >= 0
                                                                                             && -2 + B + C >= 0
                                                                                             && -4 + A + C >= 0
                                                                                             && -1 + A + -1*B >= 0
                                                                                             && -1 + B >= 0
                                                                                             && -4 + A + B >= 0
                                                                                             && -3 + A >= 0
                                                                                             && C >= 0
                                                                                             && E >= 0
                                                                                             && 1 + C >= 2*E
                                                                                             && 2*E >= C
                                                                                             && F >= 0
                                                                                             && 1 + C >= 2*F
                                                                                             && 2*F >= C
                                                                                             && D >= 0
                                                                                             && 1 + C >= 2*D
                                                                                             && 2*D >= C]
        Signature:
          {(evalrealheapsortstep1bb2in,3)
          ;(evalrealheapsortstep1bb3in,3)
          ;(evalrealheapsortstep1bb4in,3)
          ;(evalrealheapsortstep1bb5in,3)
          ;(evalrealheapsortstep1bb6in,3)
          ;(evalrealheapsortstep1entryin,3)
          ;(evalrealheapsortstep1returnin,3)
          ;(evalrealheapsortstep1start,3)
          ;(evalrealheapsortstep1stop,3)}
        Rule Graph:
          [0->{1,2},1->{3},2->{4},3->{},4->{5},5->{7,8},6->{9},7->{9},8->{11},9->{4,10},10->{3},11->{5,6}]
        ,We construct a looptree:
          P: [0,1,2,3,4,5,6,7,8,9,10,11]
          |
          `- p:[4,9,6,11,8,5,7] c: [4,6,7,9]
             |
             `- p:[5,11,8] c: [5,8,11])
    + Applied Processor:
        CloseWith True
    + Details:
        ()

YES