LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: resize_shareds_right
static void resize_shareds_right(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    for(int64_t i = layout->view.rect.top - 1; i >= rect.top; i--){
         CePoint_t point = {layout->view.rect.right, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.right == layout->view.rect.right){
              adjacent_layout->view.rect.right = result->new_value;
              i = adjacent_layout->view.rect.top;
         }else{
              break;
         }
    }

    for(int64_t i = layout->view.rect.bottom + 1; i <= rect.bottom; i++){
         CePoint_t point = {layout->view.rect.right, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.right == layout->view.rect.right){
              adjacent_layout->view.rect.right = result->new_value;
              i = adjacent_layout->view.rect.bottom;
         }else{
              break;
         }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jl 0x2976b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29d60
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x29759
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x29759
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2975b
jmp 0x2976b
jmp 0x2975d
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x296ec
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x18(%rcx), %rax
jg 0x297fa
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x29d60
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x297e8
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x297e8
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x297ea
jmp 0x297fa
jmp 0x297ec
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2977b
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: resize_shareds_up
static void resize_shareds_up(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    for(int64_t i = layout->view.rect.left - 1; i >= rect.left; i--){
         CePoint_t point = {i, layout->view.rect.top};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.top == layout->view.rect.top){
              adjacent_layout->view.rect.top = result->new_value;
              i = adjacent_layout->view.rect.left;
         }else{
              break;
         }
    }

    for(int64_t i = layout->view.rect.right + 1; i <= rect.right; i++){
         CePoint_t point = {i, layout->view.rect.top};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.top == layout->view.rect.top){
              adjacent_layout->view.rect.top = result->new_value;
              i = adjacent_layout->view.rect.right;
         }else{
              break;
         }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jl 0x29a1a
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29d60
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x29a08
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x29a08
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x29a0a
jmp 0x29a1a
jmp 0x29a0c
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2999c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x8(%rcx), %rax
jg 0x29aa9
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x29d60
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x29a97
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x29a97
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x29a99
jmp 0x29aa9
jmp 0x29a9b
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x29a2a
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: resize_shareds_down
static void resize_shareds_down(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    for(int64_t i = layout->view.rect.left - 1; i >= rect.left; i--){
         CePoint_t point = {i, layout->view.rect.bottom};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.bottom == layout->view.rect.bottom){
              adjacent_layout->view.rect.bottom = result->new_value;
              i = adjacent_layout->view.rect.left;
         }else{
              break;
         }
    }

    for(int64_t i = layout->view.rect.right + 1; i <= rect.right; i++){
         CePoint_t point = {i, layout->view.rect.bottom};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.bottom == layout->view.rect.bottom){
              adjacent_layout->view.rect.bottom = result->new_value;
              i = adjacent_layout->view.rect.right;
         }else{
              break;
         }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jl 0x29cca
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29d60
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x29cb8
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x29cb8
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x29cba
jmp 0x29cca
jmp 0x29cbc
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x29c4c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x8(%rcx), %rax
jg 0x29d59
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x29d60
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x29d47
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x29d47
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x29d49
jmp 0x29d59
jmp 0x29d4b
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x29cda
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: ce_layout_find_at
CeLayout_t* ce_layout_find_at(CeLayout_t* layout, CePoint_t point){
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          if(ce_point_in_rect(point, layout->view.rect)) return layout;
          break;
     case CE_LAYOUT_TYPE_LIST:
          for(int64_t i = 0; i < layout->list.layout_count; i++){
               CeLayout_t* found = ce_layout_find_at(layout->list.layouts[i], point);
               if(found) return found;
          }
          break;
     case CE_LAYOUT_TYPE_TAB:
          return ce_layout_find_at(layout->tab.root, point);
     case CE_LAYOUT_TYPE_TAB_LIST:
          return ce_layout_find_at(layout->tab_list.current, point);
     }

     return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x3, %rax
ja 0x29d98
movq -0x38(%rbp), %rax
leaq 0x1ade1(%rip), %rcx     # 0x44b70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x29e7c
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x11d80
testb $0x1, %al
jne 0x29dda
jmp 0x29de7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x29e84
jmp 0x29e7c
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x29e44
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x29d60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x29e34
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x29e84
jmp 0x29e36
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x29df4
jmp 0x29e7c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x29d60
movq %rax, -0x8(%rbp)
jmp 0x29e84
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x29d60
movq %rax, -0x8(%rbp)
jmp 0x29e84
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: ce_layout_find_popup
CeLayout_t* ce_layout_find_popup(CeLayout_t* layout){
     if(layout->popup){
         return layout;
     }
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          break;
     case CE_LAYOUT_TYPE_LIST:
          for(int64_t i = 0; i < layout->list.layout_count; i++){
               CeLayout_t* found = ce_layout_find_popup(layout->list.layouts[i]);
               if(found) return found;
          }
          break;
     case CE_LAYOUT_TYPE_TAB:
          return ce_layout_find_popup(layout->tab.root);
     case CE_LAYOUT_TYPE_TAB_LIST:
          return ce_layout_find_popup(layout->tab_list.current);
     }

     return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x58(%rax)
je 0x29eb3
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x29f5b
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0x29ed7
movq -0x28(%rbp), %rax
leaq 0x1acb2(%rip), %rcx     # 0x44b80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x29f53
jmp 0x29f53
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x29f2b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x29e90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29f1b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x29f5b
jmp 0x29f1d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x29ee3
jmp 0x29f53
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x29e90
movq %rax, -0x8(%rbp)
jmp 0x29f5b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x29e90
movq %rax, -0x8(%rbp)
jmp 0x29f5b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: ce_layout_buffer_in_view
CeLayout_t* ce_layout_buffer_in_view(CeLayout_t* layout, CeBuffer_t* buffer){
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          if(layout->view.buffer == buffer) return layout;
          break;
     case CE_LAYOUT_TYPE_LIST:
          for(int64_t i = 0; i < layout->list.layout_count; i++){
               CeLayout_t* found = ce_layout_buffer_in_view(layout->list.layouts[i], buffer);
               if(found) return found;
          }
          break;
     case CE_LAYOUT_TYPE_TAB:
          return ce_layout_buffer_in_view(layout->tab.root, buffer);
     case CE_LAYOUT_TYPE_TAB_LIST:
          return ce_layout_buffer_in_view(layout->tab_list.current, buffer);
     }

     return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x2a374
movq -0x30(%rbp), %rax
leaq 0x1a825(%rip), %rcx     # 0x44b90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2a41d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x2a394
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a425
jmp 0x2a41d
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x2a3ed
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a340
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2a3dd
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a425
jmp 0x2a3df
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a3a1
jmp 0x2a41d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a340
movq %rax, -0x8(%rbp)
jmp 0x2a425
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a340
movq %rax, -0x8(%rbp)
jmp 0x2a425
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: count_buffer_in_views
int64_t count_buffer_in_views(CeLayout_t* layout, CeBuffer_t* buffer, int64_t count){
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          if(layout->view.buffer == buffer) return 1;
          break;
     case CE_LAYOUT_TYPE_LIST:
          for(int64_t i = 0; i < layout->list.layout_count; i++){
               count = count_buffer_in_views(layout->list.layouts[i], buffer, count);
          }
          break;
     case CE_LAYOUT_TYPE_TAB:
          return count_buffer_in_views(layout->tab.root, buffer, count);
     case CE_LAYOUT_TYPE_TAB_LIST:
          return count_buffer_in_views(layout->tab_list.current, buffer, count);
     }

     return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x2a468
movq -0x30(%rbp), %rax
leaq 0x1a741(%rip), %rcx     # 0x44ba0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2a507
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x2a488
movq $0x1, -0x8(%rbp)
jmp 0x2a50f
jmp 0x2a507
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x2a4cf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a430
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2a492
jmp 0x2a507
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a430
movq %rax, -0x8(%rbp)
jmp 0x2a50f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a430
movq %rax, -0x8(%rbp)
jmp 0x2a50f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: build_buffer_in_views
void build_buffer_in_views(CeLayout_t* layout, CeBuffer_t* buffer, CeLayoutBufferInViewsResult_t* result){
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          if(layout->view.buffer == buffer){
               result->layouts[result->layout_count] = layout;
               result->layout_count++;
          }
          break;
     case CE_LAYOUT_TYPE_LIST:
          for(int64_t i = 0; i < layout->list.layout_count; i++){
               build_buffer_in_views(layout->list.layouts[i], buffer, result);
          }
          break;
     case CE_LAYOUT_TYPE_TAB:
          build_buffer_in_views(layout->tab.root, buffer, result);
          break;
     case CE_LAYOUT_TYPE_TAB_LIST:
          build_buffer_in_views(layout->tab_list.current, buffer, result);
          break;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0x2a558
movq -0x28(%rbp), %rax
leaq 0x1a661(%rip), %rcx     # 0x44bb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2a603
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x2a592
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x2a603
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x2a5d5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a520
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a59c
jmp 0x2a603
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a520
jmp 0x2a603
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a520
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: ce_layout_buffer_in_views
CeLayoutBufferInViewsResult_t ce_layout_buffer_in_views(CeLayout_t* layout, CeBuffer_t* buffer){
     CeLayoutBufferInViewsResult_t result = {};
     int64_t count = count_buffer_in_views(layout, buffer, 0);
     result.layouts = malloc(count * sizeof(*result.layouts));
     build_buffer_in_views(layout, buffer, &result);
     return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2a430
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
shlq $0x3, %rdi
callq 0xd4a0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x2a520
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: ce_layout_tab_get_layout_count
int64_t ce_layout_tab_get_layout_count(CeLayout_t* layout){
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_TAB:
          if(!layout->tab.root) return 0;
          return count_children(layout->tab.root);
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x2, %eax
je 0x2a68b
jmp 0x2a689
jmp 0x2a6b3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2a6a0
movq $0x0, -0x8(%rbp)
jmp 0x2a6bb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a6d0
movq %rax, -0x8(%rbp)
jmp 0x2a6bb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_layout.c
// Function: count_children
static int64_t count_children(CeLayout_t* layout){
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          return 1;
     case CE_LAYOUT_TYPE_LIST:
     {
          int sum = 0;
          for(int64_t i = 0; i < layout->list.layout_count; i++){
               sum += count_children(layout->list.layouts[i]);
          }
          return sum;
     }
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x2a6f7
jmp 0x2a6eb
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x2a701
jmp 0x2a6f5
jmp 0x2a758
movq $0x1, -0x8(%rbp)
jmp 0x2a760
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x2a74e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a6d0
movq %rax, %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a710
movslq -0x14(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a760
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_macros.c
// Function: ce_macros_begin_recording
bool ce_macros_begin_recording(CeMacros_t* macros, unsigned char reg){
     if(reg < 33 || reg >= 177) return false; // ascii printable character range
     macros->recording = reg;
     ce_rune_node_free(macros->rune_head + (reg - '!'));
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x21, %eax
jl 0x2a7e6
movzbl -0x11(%rbp), %eax
cmpl $0xb1, %eax
jl 0x2a7ec
movb $0x0, -0x1(%rbp)
jmp 0x2a816
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2f8(%rax)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
subl $0x21, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdi
callq 0x11f10
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_regex_linux.c
// Function: ce_regex_init
CeRegexResult_t ce_regex_init(const char* expression,
                              CeRegex_t* regex_handle) {
     CeRegexResult_t result = {};
     regex_t* regex = (regex_t*)(malloc(sizeof(regex_t)));
     if(regex == NULL){
          result.error_message = strdup("Failed to allocate regex_t");
          return result;
     }
     int rc = regcomp(regex, expression, REG_EXTENDED);
     if (rc != 0){
          result.error_message = malloc(CE_REGEX_MAX_ERROR_SIZE);
          regerror(rc, regex, result.error_message, CE_REGEX_MAX_ERROR_SIZE);
          free(regex);
          return result;
     }
     *regex_handle = regex;
     return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0xd290
movl $0x40, %edi
callq 0xd4a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2a9a4
leaq 0x1a3cb(%rip), %rdi     # 0x44d5e
callq 0xd620
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2a9fd
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0xd310
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a9f2
movl $0x100, %edi            # imm = 0x100
callq 0xd4a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movq (%rax), %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0xd410
movq -0x18(%rbp), %rdi
callq 0xd090
jmp 0x2a9fd
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_regex_linux.c
// Function: ce_regex_match
CeRegexResult_t ce_regex_match(CeRegex_t regex_handle,
                               const char* string) {
     regex_t* regex = (regex_t*)(regex_handle);
     // TODO: Check that handle is valid.
     CeRegexResult_t result = {};
     const size_t match_count = 1;
     regmatch_t matches[match_count];
     int rc = regexec(regex, string, match_count, matches, 0);
     if(rc == 0){
          result.match_start = matches[0].rm_so;
          result.match_length = matches[0].rm_eo - matches[0].rm_so;
     }else if(rc == REG_NOMATCH){
          result.match_start = CE_REGEX_NO_MATCH;
          result.match_length = CE_REGEX_NO_MATCH;
     }else{
          result.error_message = malloc(CE_REGEX_MAX_ERROR_SIZE);
          regerror(rc, regex, result.error_message, CE_REGEX_MAX_ERROR_SIZE);
     }
     return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0xd290
movq $0x1, -0x20(%rbp)
movq %rsp, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
leaq -0x40(%rbp), %rcx
xorl %r8d, %r8d
callq 0xd4e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x2aa8b
movq -0x50(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x3c(%rbp), %ecx
subl -0x40(%rbp), %ecx
movslq %ecx, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2aad1
cmpl $0x1, -0x2c(%rbp)
jne 0x2aaa7
movq -0x50(%rbp), %rax
movq $-0x1, 0x8(%rax)
movq $-0x1, 0x10(%rax)
jmp 0x2aacf
movl $0x100, %edi            # imm = 0x100
callq 0xd4a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
movq (%rax), %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0xd410
jmp 0x2aad1
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsp
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_subprocess.c
// Function: split_command_args
char** _split_command_args(const char* command){
    int64_t count = 0;
    char** result = NULL;

    char* token = strtok((char*)(command), " ");

    while(token){
        int64_t new_count = count + 1;
        result = realloc(result, new_count * sizeof(result[0]));
        result[count] = strdup(token);
        count = new_count;
        token = strtok(NULL, " ");
    }

    // End with a NULL per the execv() man page.
    int64_t new_count = count + 1;
    result = realloc(result, new_count * sizeof(result[0]));
    result[count] = NULL;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x19b92(%rip), %rsi     # 0x446d9
callq 0xd5a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2abae
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0xd500
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd620
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x19b36(%rip), %rsi     # 0x446d9
callq 0xd5a0
movq %rax, -0x20(%rbp)
jmp 0x2ab50
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
shlq $0x3, %rsi
callq 0xd500
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_subprocess.c
// Function: ce_subprocess_open
bool ce_subprocess_open(CeSubprocess_t* subprocess, const char* command, CeProcCommFlag_t comms,
                        bool use_shell){
     subprocess->pid = bidirectional_popen(command, comms, &subprocess->stdin_fd,
                                           &subprocess->stdout_fd, use_shell);
     if(subprocess->pid == 0) return false;
     if(subprocess->stdin_fd >= 0){
         subprocess->stdin_file = fdopen(subprocess->stdin_fd, "w");
     }
     if(subprocess->stdout_fd >= 0){
         subprocess->stdout_file = fdopen(subprocess->stdout_fd, "r");
     }
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x2acb0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2ac46
movb $0x0, -0x1(%rbp)
jmp 0x2ac9a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x2ac6e
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
leaq 0x18422(%rip), %rsi     # 0x43080
callq 0xd520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x2ac96
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
leaq 0x1a1f0(%rip), %rsi     # 0x44e76
callq 0xd520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_subprocess.c
// Function: ce_subprocess_close_stdin
void ce_subprocess_close_stdin(CeSubprocess_t* subprocess){
     if(subprocess->stdin_fd >= 0){
         _close_file(&subprocess->stdin_file);
         close(subprocess->stdin_fd);
         subprocess->stdin_fd = -1;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x2aeca
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x2aed0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0xd2d0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_subprocess.c
// Function: close_file
static void _close_file(FILE **file){
     FILE *to_close = *file;
     if(to_close == NULL) return;
     *file = NULL;
     // because fclose() is a cancellation point for pthread, I need to NULL
     // stdin prior to calling fclose() so we are guaranteed we don't do it
     // again in a cleanup handler
     fclose(to_close);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2aef0
jmp 0x2af04
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0xd1e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_subprocess.c
// Function: ce_subprocess_close
int ce_subprocess_close(CeSubprocess_t* subprocess){
     // wait for the subprocess to complete
     int status;
     do{
          if(waitpid(subprocess->pid, &status, 0) == -1){
               switch(errno){
               case EINTR:
                    continue;
               default:
                    // TODO: not sure what to do here
                    return 0;
               }
          }
     }while(!WIFEXITED(status) && !WIFSIGNALED(status));
     assert(!(WIFCONTINUED(status)));

     if(subprocess->stdout_fd >= 0){
         _close_file(&subprocess->stdout_file);
         close(subprocess->stdout_fd);
     }
     if(subprocess->stdin_fd >= 0){
         _close_file(&subprocess->stdin_file);
         close(subprocess->stdin_fd);
     }
     return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x14(%rbp), %rsi
xorl %edx, %edx
callq 0xd570
cmpl $-0x1, %eax
jne 0x2af4e
callq 0xd0a0
movl (%rax), %eax
subl $0x4, %eax
jne 0x2af42
jmp 0x2af40
jmp 0x2af50
movl $0x0, -0x4(%rbp)
jmp 0x2aff6
jmp 0x2af50
movl -0x14(%rbp), %ecx
andl $0x7f, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x2af79
movl -0x14(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
setg %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x2af1c
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
je 0x2af8b
jmp 0x2afaa
leaq 0x19de7(%rip), %rdi     # 0x44d79
leaq 0x19df8(%rip), %rsi     # 0x44d91
movl $0x108, %edx            # imm = 0x108
leaq 0x19dfc(%rip), %rcx     # 0x44da1
callq 0xd270
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x2afcd
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2aed0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xd2d0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x2aff0
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x2aed0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0xd2d0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_subprocess.c
// Function: ce_subprocess_read_stdout
int64_t ce_subprocess_read_stdout(CeSubprocess_t* subprocess, char* buffer, int64_t size){
#if defined(PLATFORM_WINDOWS)
     if(subprocess->stdout_read_pipe == INVALID_HANDLE_VALUE){
          ce_log("subprocess created without enabling reading stdout\n");
          return -1;
     }
     DWORD bytes_read = 0;
     ReadFile(subprocess->stdout_read_pipe, buffer, size, &bytes_read, NULL);
     if(bytes_read < 0){
          ce_log("read() from clangd stdout failed.\n");
          return -1;
     }
     return bytes_read;

#else
     if(subprocess->stdout_fd < 0){
          ce_log("subprocess created without enabling reading stdout\n");
          return -1;
     }
     int bytes_read = read(subprocess->stdout_fd, buffer, size);
     if(bytes_read < 0){
          if(errno != EINTR && errno != EAGAIN){
              ce_log("read() failed on subprocess pid %d stdin %s\n", strerror(errno));
          }
          return bytes_read;
     }
     return bytes_read;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x2b036
leaq 0x19da6(%rip), %rdi     # 0x44dcb
movb $0x0, %al
callq 0xd8f0
movq $-0x1, -0x8(%rbp)
jmp 0x2b096
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xd330
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x2b08e
callq 0xd0a0
cmpl $0x4, (%rax)
je 0x2b084
callq 0xd0a0
cmpl $0xb, (%rax)
je 0x2b084
callq 0xd0a0
movl (%rax), %edi
callq 0xd630
movq %rax, %rsi
leaq 0x19d82(%rip), %rdi     # 0x44dff
movb $0x0, %al
callq 0xd8f0
movslq -0x24(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b096
movslq -0x24(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_subprocess.c
// Function: ce_subprocess_write_stdin
int64_t ce_subprocess_write_stdin(CeSubprocess_t* subprocess, char* buffer, int64_t size){
     int64_t total_bytes_written = 0;
     while(total_bytes_written < size){
#if defined(PLATFORM_WINDOWS)
          if(subprocess->stdin_write_pipe == INVALID_HANDLE_VALUE){
               ce_log("subprocess created without enabling reading stdout\n");
               return -1;
          }
          DWORD bytes_written = 0;
          bool success = WriteFile(subprocess->stdin_write_pipe, buffer + total_bytes_written,
                                   size - total_bytes_written,
                                   &bytes_written, NULL);
          if(!success || bytes_written < 0){
               ce_log("write() failed on clangd stdin\n");
               return -1;
          }
#else
          if(subprocess->stdin_fd < 0){
               ce_log("subprocess created without enabling reading stdout\n");
               return -1;
          }
          int64_t bytes_written = write(subprocess->stdin_fd, buffer + total_bytes_written,
                                        size - total_bytes_written);
          if(bytes_written < 0){
               if(errno != EINTR && errno != EAGAIN){
                   ce_log("write() failed on clangd stdin %s\n", strerror(errno));
               }
               return bytes_written;
          }

#endif
          total_bytes_written += bytes_written;
     }
     return total_bytes_written;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x2b15f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jge 0x2b0ec
leaq 0x19cf0(%rip), %rdi     # 0x44dcb
movb $0x0, %al
callq 0xd8f0
movq $-0x1, -0x8(%rbp)
jmp 0x2b167
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x28(%rbp), %rdx
callq 0xd1c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x2b14e
callq 0xd0a0
cmpl $0x4, (%rax)
je 0x2b144
callq 0xd0a0
cmpl $0xb, (%rax)
je 0x2b144
callq 0xd0a0
movl (%rax), %edi
callq 0xd630
movq %rax, %rsi
leaq 0x19cef(%rip), %rdi     # 0x44e2c
movb $0x0, %al
callq 0xd8f0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b167
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2b0bc
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: ce_draw_color_list_insert
bool ce_draw_color_list_insert(CeDrawColorList_t* list, int fg, int bg, CePoint_t point){
     if(list->tail && list->tail->fg == fg && list->tail->bg == bg && list->tail->point.y == point.y) return true;
     CeDrawColorNode_t* node = malloc(sizeof(*node));
     if(!node) return false;
     node->fg = fg;
     node->bg = bg;
     node->point = point;
     node->next = NULL;
     if(list->tail) list->tail->next = node;
     list->tail = node;
     if(!list->head) list->head = node;
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b25f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x2b25f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x2b25f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x2b25f
movb $0x1, -0x1(%rbp)
jmp 0x2b2ed
movl $0x20, %edi
callq 0xd4a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2b27a
movb $0x0, -0x1(%rbp)
jmp 0x2b2ed
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b2c8
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2b2e9
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: ce_draw_color_list_free
void ce_draw_color_list_free(CeDrawColorList_t* list){
     CeDrawColorNode_t* itr = list->head;
     while(itr){
          CeDrawColorNode_t* tmp = itr;
          itr = itr->next;
          free(tmp);
     }

     list->head = NULL;
     list->tail = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2b33d
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd090
jmp 0x2b317
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: ce_range_list_insert
bool ce_range_list_insert(CeRangeList_t* list, CePoint_t start, CePoint_t end){
     CeRangeNode_t* node = malloc(sizeof(*node));
     if(!node) return false;
     node->range.start = start;
     node->range.end = end;
     node->next = NULL;
     if(list->tail) list->tail->next = node;
     list->tail = node;
     if(!list->head) list->head = node;
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movl $0x28, %edi
callq 0xd4a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2b397
movb $0x0, -0x1(%rbp)
jmp 0x2b40a
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b3e5
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2b406
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: ce_range_list_insert_sorted
bool ce_range_list_insert_sorted(CeRangeList_t* list, CePoint_t start, CePoint_t end){
     CeRangeNode_t* itr = list->head;
     CeRangeNode_t* prev = NULL;
     while(itr){
          if(prev){
               if(ce_point_after(itr->range.start, end) &&
                  ce_point_after(end, prev->range.end)){
                    break;
               }
          }else{
               if(ce_point_after(itr->range.start, end)){
                    break;
               }
          }

          prev = itr;
          itr = itr->next;
     }

     if(itr){
          if(!ce_point_after(end, itr->range.start)) return false;
     }

     CeRangeNode_t* node = malloc(sizeof(*node));
     if(!node) return false;
     node->range.start = start;
     node->range.end = end;

     if(!itr){
          node->next = NULL;
     }else{
          node->next = itr;
     }

     if(prev){
          prev->next = node;
     }else{
          list->head = node;
     }

     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2b4dd
cmpq $0x0, -0x40(%rbp)
je 0x2b4a2
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xf690
testb $0x1, %al
jne 0x2b47f
jmp 0x2b4a0
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0xf690
testb $0x1, %al
jne 0x2b49e
jmp 0x2b4a0
jmp 0x2b4dd
jmp 0x2b4c4
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xf690
testb $0x1, %al
jne 0x2b4c0
jmp 0x2b4c2
jmp 0x2b4dd
jmp 0x2b4c4
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2b44f
cmpq $0x0, -0x38(%rbp)
je 0x2b50b
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0xf690
testb $0x1, %al
jne 0x2b509
movb $0x0, -0x1(%rbp)
jmp 0x2b592
jmp 0x2b50b
movl $0x28, %edi
callq 0xd4a0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x2b526
movb $0x0, -0x1(%rbp)
jmp 0x2b592
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x38(%rbp)
jne 0x2b562
movq -0x48(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x2b56e
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x40(%rbp)
je 0x2b583
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2b58e
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: ce_range_list_free
void ce_range_list_free(CeRangeList_t* list){
     CeRangeNode_t* itr = list->head;
     while(itr){
          CeRangeNode_t* tmp = itr;
          itr = itr->next;
          free(tmp);
     }

     list->head = NULL;
     list->tail = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2b5dd
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd090
jmp 0x2b5b7
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: ce_draw_color_list_next_to_last_fg_color
int ce_draw_color_list_next_to_last_fg_color(CeDrawColorList_t* draw_color_list){
     int fg = CE_COLOR_DEFAULT;
     if(draw_color_list->tail && (draw_color_list->head != draw_color_list->tail)){
          CeDrawColorNode_t* itr = draw_color_list->head;
          while(itr->next != draw_color_list->tail) itr = itr->next;
          fg = itr->fg;
     }
     return fg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b6bf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x2b6bf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x2b6b6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2b696
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)