LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: resize_opposites_up
static void resize_opposites_up(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    int64_t right_start = layout->view.rect.left;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpq %rdx, %rsi
jle 0x1ebea
movq %rdx, %r13
movq %r12, %rsi
decq %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1ebea
movq 0x20(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1ebea
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r12, %rax
cmovgeq %rcx, %r12
cmpq %r13, %rsi
jg 0x1ebac
cmpq %r14, %r12
jg 0x1ec22
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ede6
testq %rax, %rax
je 0x1ec22
movq 0x20(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1ec22
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rax), %rax
leaq 0x1(%rax), %r12
cmpq %r14, %rax
jl 0x1ebef
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rsi), %rsi
cmpq %rdx, %rsi
jle 0x1ec7b
movq %rdx, %r13
decq %rsi
movq 0x18(%r15), %rdx
movq %r12, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1ec7b
movq 0x18(%rax), %rcx
cmpq 0x18(%r15), %rcx
jne 0x1ec7b
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rax), %rsi
cmpq %r13, %rsi
jg 0x1ec4d
movq 0x10(%r15), %rsi
cmpq %r14, %rsi
jge 0x1ecaf
incq %rsi
movq 0x18(%r15), %rdx
movq %r12, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1ecaf
movq 0x18(%rax), %rcx
cmpq 0x18(%r15), %rcx
jne 0x1ecaf
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rsi
jmp 0x1ec7f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: resize_opposites_down
static void resize_opposites_down(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    int64_t right_start = layout->view.rect.left;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpq %rdx, %rsi
jle 0x1ed17
movq %rdx, %r13
movq %r12, %rsi
decq %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1ed17
movq 0x18(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1ed17
movq 0x10(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r12, %rax
cmovgeq %rcx, %r12
cmpq %r13, %rsi
jg 0x1ecd9
cmpq %r14, %r12
jg 0x1ed4f
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ede6
testq %rax, %rax
je 0x1ed4f
movq 0x18(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1ed4f
movq 0x10(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rax
leaq 0x1(%rax), %r12
cmpq %r14, %rax
jl 0x1ed1c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rsi), %rsi
cmpq %rdx, %rsi
jle 0x1eda8
movq %rdx, %r13
decq %rsi
movq 0x20(%r15), %rdx
movq %r12, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1eda8
movq 0x20(%rax), %rcx
cmpq 0x20(%r15), %rcx
jne 0x1eda8
movq (%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rax), %rsi
cmpq %r13, %rsi
jg 0x1ed7a
movq 0x10(%r15), %rsi
cmpq %r14, %rsi
jge 0x1eddc
incq %rsi
movq 0x20(%r15), %rdx
movq %r12, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1eddc
movq 0x20(%rax), %rcx
cmpq 0x20(%r15), %rcx
jne 0x1eddc
movq (%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rax), %rsi
jmp 0x1edac
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10e3f(%rip), %rax     # 0x2fc40
movl (%rbx), %edx
cmpq $0x3, %rdx
ja 0x1ee6f
movl $0x10, %ecx
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movl $0x8, %ecx
movq (%rbx,%rcx), %rbx
jmp 0x1ee01
movups 0x8(%rbx), %xmm0
movups 0x18(%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x10121
testb %al, %al
je 0x1ee6f
jmp 0x1ee71
cmpq $0x0, 0x10(%rbx)
jle 0x1ee6f
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ede6
testq %rax, %rax
jne 0x1ee80
incq %r12
cmpq 0x10(%rbx), %r12
jl 0x1ee4e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x1ee71
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x58(%rdi)
jne 0x1eeeb
movl (%rbx), %eax
cmpl $0x2, %eax
je 0x1eea9
movl $0x10, %ecx
cmpl $0x3, %eax
je 0x1eeae
jmp 0x1eeba
movl $0x8, %ecx
movq (%rbx,%rcx), %rbx
cmpb $0x1, 0x58(%rbx)
jne 0x1ee96
jmp 0x1eeeb
cmpl $0x1, %eax
jne 0x1eee9
movq 0x10(%rbx), %r14
testq %r14, %r14
jle 0x1eee9
movq 0x8(%rbx), %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x1ee85
testq %rax, %rax
jne 0x1eefa
incq %r12
cmpq %r12, %r14
jne 0x1eed1
jmp 0x1eeeb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x1eeeb
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
leaq 0x10b62(%rip), %rcx     # 0x2fc50
movl (%rax), %esi
cmpq $0x3, %rsi
ja 0x1f140
movl $0x10, %edx
movslq (%rcx,%rsi,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
movl $0x8, %edx
movq (%rax,%rdx), %rax
jmp 0x1f0ee
cmpq %rbx, 0x48(%rax)
jne 0x1f140
jmp 0x1f142
movq 0x10(%rax), %r14
testq %r14, %r14
jle 0x1f140
movq 0x8(%rax), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1f0d9
testq %rax, %rax
jne 0x1f142
incq %r12
cmpq %r12, %r14
jne 0x1f127
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
leaq 0x10afd(%rip), %rcx     # 0x2fc60
movl (%rdi), %esi
cmpq $0x3, %rsi
ja 0x1f1ba
movl $0x10, %edx
movslq (%rcx,%rsi,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
movl $0x8, %edx
movq (%rdi,%rdx), %rdi
jmp 0x1f163
cmpq %rbx, 0x48(%rdi)
movl $0x1, %ecx
cmoveq %rcx, %rax
jmp 0x1f1ba
movq 0x10(%rdi), %r14
testq %r14, %r14
jle 0x1f1ba
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1f14e
incq %r12
cmpq %r12, %r14
jne 0x1f1a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10a92(%rip), %rax     # 0x2fc70
movl (%r14), %edx
cmpq $0x3, %rdx
ja 0x1f240
movl $0x10, %ecx
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movl $0x8, %ecx
movq (%r14,%rcx), %r14
jmp 0x1f1de
cmpq %r15, 0x48(%r14)
jne 0x1f240
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x8(%rbx)
jmp 0x1f240
cmpq $0x0, 0x10(%r14)
jle 0x1f240
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f1c6
incq %r12
cmpq 0x10(%r14), %r12
jl 0x1f224
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq $0x0, 0x8(%r15)
xorl %edx, %edx
callq 0x1f14e
leaq (,%rax,8), %rdi
callq 0xd4c0
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1f1c6
movq (%r15), %rax
movq 0x8(%r15), %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
testl %eax, %eax
je 0x1f2ea
cmpl $0x1, %eax
jne 0x1f2f1
movq 0x10(%rdi), %r14
xorl %ebx, %ebx
testq %r14, %r14
jle 0x1f2f3
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x1f2ad
addl %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x1f2d2
movslq %ebx, %rbx
jmp 0x1f2f3
movl $0x1, %ebx
jmp 0x1f2f3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leal -0x21(%rsi), %ebx
cmpb $-0x71, %bl
ja 0x1f34c
movb %sil, 0x2f8(%rdi)
movzbl %sil, %eax
addl $-0x21, %eax
leaq (%rdi,%rax,8), %rdi
callq 0x101e1
cmpb $-0x70, %bl
setb %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x40, %edi
callq 0xd4c0
testq %rax, %rax
je 0x1f410
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd320
testl %eax, %eax
je 0x1f421
movl %eax, %ebp
movl $0x100, %edi            # imm = 0x100
callq 0xd4c0
movq %rax, (%rbx)
movl $0x100, %ecx            # imm = 0x100
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd430
movq %r14, %rdi
callq 0xd090
jmp 0x1f424
leaq 0x10a07(%rip), %rdi     # 0x2fe1e
callq 0xd640
movq %rax, (%rbx)
jmp 0x1f424
movq %r14, (%r15)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsp, %rcx
movl $0x1, %edx
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xd500
cmpl $0x1, %eax
je 0x1f488
movl %eax, %ebp
testl %eax, %eax
jne 0x1f493
movslq (%rsp), %rax
movq %rax, 0x8(%rbx)
movslq 0x4(%rsp), %rcx
subq %rax, %rcx
movq %rcx, 0x10(%rbx)
jmp 0x1f4b2
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rbx)
jmp 0x1f4b2
movl $0x100, %edi            # imm = 0x100
callq 0xd4c0
movq %rax, (%rbx)
movl $0x100, %ecx            # imm = 0x100
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd430
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x1033d(%rip), %rsi     # 0x2f815
callq 0xd5c0
testq %rax, %rax
je 0x1f52b
movq %rax, %r15
xorl %r13d, %r13d
leaq 0x10326(%rip), %r14     # 0x2f815
xorl %ebx, %ebx
leaq 0x1(%r13), %r12
leaq 0x8(,%r13,8), %rsi
movq %rbx, %rdi
callq 0xd520
movq %rax, %rbx
movq %r15, %rdi
callq 0xd640
movq %rax, (%rbx,%r13,8)
xorl %edi, %edi
movq %r14, %rsi
callq 0xd5c0
movq %rax, %r15
movq %r12, %r13
testq %rax, %rax
jne 0x1f4f1
jmp 0x1f530
xorl %ebx, %ebx
xorl %r12d, %r12d
leaq 0x8(,%r12,8), %rsi
movq %rbx, %rdi
callq 0xd520
movq $0x0, (%rax,%r12,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd2f0
testl %eax, %eax
jne 0x1f583
movq %rsp, %rdi
callq 0xd2f0
testl %eax, %eax
je 0x1f59a
movl $0x0, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xd6e0
testl %eax, %eax
js 0x1f583
je 0x1f62c
movl %eax, %r12d
movl 0x8(%rsp), %edi
callq 0xd2e0
movl 0x4(%rsp), %edi
callq 0xd2e0
movl 0xc(%rsp), %edi
testb $0x1, %bpl
jne 0x1f5d2
callq 0xd2e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %edi, 0x10(%rbx)
movl (%rsp), %eax
testb $0x2, %bpl
jne 0x1f5ed
movl %eax, %edi
callq 0xd2e0
movl 0x10(%rbx), %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rbx)
movl %r12d, (%rbx)
testl %edi, %edi
js 0x1f60a
leaq 0xead1(%rip), %rsi      # 0x2e0cf
callq 0xd540
movq %rax, 0x18(%rbx)
movl 0x4(%rbx), %eax
movb $0x1, %bpl
testl %eax, %eax
js 0x1f58b
leaq 0x10914(%rip), %rsi     # 0x2ff30
movl %eax, %edi
callq 0xd540
movq %rax, 0x8(%rbx)
jmp 0x1f58b
movl 0xc(%rsp), %edi
callq 0xd2e0
movl (%rsp), %edi
callq 0xd2e0
movl 0x8(%rsp), %edi
xorl %esi, %esi
callq 0xd220
movl 0x4(%rsp), %edi
movl $0x1, %esi
callq 0xd220
movl 0x4(%rsp), %edi
movl $0x2, %esi
callq 0xd220
testb %r15b, %r15b
je 0x1f68c
leaq 0x1089f(%rip), %rdi     # 0x2ff0f
leaq 0x108a0(%rip), %rdx     # 0x2ff17
movq %rdi, %rsi
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xd660
jmp 0x1f583
movq %r14, %rdi
callq 0x1f4c8
movq %rax, %r14
movq (%rax), %rdi
movq %rax, %rsi
callq 0xd6d0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f6c2
movq %r14, %r15
addq $0x8, %r15
callq 0xd090
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x1f6b1
movq %r14, %rdi
callq 0xd090
jmp 0x1f583
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %edi
testl %edi, %edi
js 0x1f70d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f701
movq $0x0, 0x18(%rbx)
movq %rax, %rdi
callq 0xd1f0
movl 0x10(%rbx), %edi
callq 0xd2e0
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl (%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd590
cmpl $-0x1, %eax
jne 0x1f736
callq 0xd0a0
cmpl $0x4, (%rax)
jne 0x1f7b5
movl 0x4(%rsp), %eax
movl %eax, %ecx
andl $0x7f, %ecx
je 0x1f752
shll $0x18, %ecx
addl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x2000000, %ecx        # imm = 0x2000000
jl 0x1f71b
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x1f7b9
movl 0x4(%rbx), %edi
testl %edi, %edi
js 0x1f781
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1f77c
movq $0x0, 0x8(%rbx)
movq %rax, %rdi
callq 0xd1f0
movl 0x4(%rbx), %edi
callq 0xd2e0
movl 0x10(%rbx), %edi
testl %edi, %edi
js 0x1f7a9
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f7a4
movq $0x0, 0x18(%rbx)
movq %rax, %rdi
callq 0xd1f0
movl 0x10(%rbx), %edi
callq 0xd2e0
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x1f7ad
leaq 0x10679(%rip), %rdi     # 0x2fe39
leaq 0x1068a(%rip), %rsi     # 0x2fe51
leaq 0x10693(%rip), %rcx     # 0x2fe61
movl $0x108, %edx            # imm = 0x108
callq 0xd280
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl 0x4(%rdi), %edi
testl %edi, %edi
js 0x1f7f4
callq 0xd350
movq %rax, %rbx
testl %ebx, %ebx
js 0x1f80b
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
jmp 0x1f835
leaq 0x10690(%rip), %rdi     # 0x2fe8b
xorl %eax, %eax
callq 0xd954
movq $-0x1, %rbx
jmp 0x1f835
callq 0xd0a0
movl (%rax), %edi
cmpl $0x4, %edi
je 0x1f832
cmpl $0xb, %edi
je 0x1f832
callq 0xd650
leaq 0x10697(%rip), %rdi     # 0x2febf
movq %rax, %rsi
xorl %eax, %eax
callq 0xd954
movslq %ebx, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
jle 0x1f87c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
xorl %ebx, %ebx
movl 0x10(%r13), %edi
testl %edi, %edi
js 0x1f880
leaq (%r15,%rbx), %rsi
movq %r14, %rdx
subq %rbx, %rdx
callq 0xd1d0
movq %rax, %r12
testq %rax, %rax
js 0x1f897
addq %r12, %rbx
cmpq %r14, %rbx
jl 0x1f853
jmp 0x1f8c1
xorl %ebx, %ebx
jmp 0x1f8c1
leaq 0x10604(%rip), %rdi     # 0x2fe8b
xorl %eax, %eax
callq 0xd954
movq $-0x1, %rbx
jmp 0x1f8c1
callq 0xd0a0
movl (%rax), %edi
cmpl $0x4, %edi
je 0x1f8be
cmpl $0xb, %edi
je 0x1f8be
callq 0xd650
leaq 0x10638(%rip), %rdi     # 0x2feec
movq %rax, %rsi
xorl %eax, %eax
callq 0xd954
movq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
movq 0x8(%rdi), %r13
testq %r13, %r13
je 0x1f91f
cmpl %r12d, (%r13)
jne 0x1f91f
cmpl %ebp, 0x4(%r13)
jne 0x1f91f
movb $0x1, %cl
cmpq %r14, 0x10(%r13)
je 0x1f960
movl $0x20, %edi
callq 0xd4c0
testq %rax, %rax
je 0x1f95e
movl %r12d, (%rax)
movl %ebp, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq $0x0, 0x18(%rax)
testq %r13, %r13
je 0x1f94d
movq %rax, 0x18(%r13)
movq %rax, 0x8(%rbx)
movb $0x1, %cl
cmpq $0x0, (%rbx)
jne 0x1f960
movq %rax, (%rbx)
jmp 0x1f960
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1f991
movq 0x18(%rdi), %r14
callq 0xd090
movq %r14, %rdi
testq %r14, %r14
jne 0x1f980
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, (%rsp)
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1fa74
xorl %ebp, %ebp
movq %rbp, %r12
movq %rax, %rbp
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xec71
testq %r12, %r12
je 0x1fa62
testb %al, %al
je 0x1fa66
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0xec71
testb %al, %al
jne 0x1fab2
movq 0x20(%rbp), %rax
testq %rax, %rax
jne 0x1fa2c
movq %rbp, %r12
jmp 0x1fa77
xorl %r12d, %r12d
xorl %ebp, %ebp
movl $0x28, %edi
callq 0xd4c0
testq %rax, %rax
je 0x1fac9
movq %r13, (%rax)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbp, 0x20(%rax)
leaq 0x20(%r12), %rcx
testq %r12, %r12
cmoveq %rbx, %rcx
movq %rax, (%rcx)
movb $0x1, %al
jmp 0x1facb
movq (%rbp), %rdx
movq 0x8(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0xec71
testb %al, %al
jne 0x1fa79
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1fafa
movq 0x20(%rdi), %r14
callq 0xd090
movq %r14, %rdi
testq %r14, %r14
jne 0x1fae9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x8(%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x1fb51
movq (%rdi), %rdx
cmpq %rcx, %rdx
je 0x1fb51
movq %rdx, %rax
movq 0x18(%rdx), %rdx
cmpq %rcx, %rdx
jne 0x1fb43
movl (%rax), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_syntax.c
// Function: ce_color_def_get
int ce_color_def_get(CeColorDefs_t* color_defs, int fg, int bg){
     // search for the already defined color
     for(int32_t i = 0; i < color_defs->count; ++i){
          if(color_defs->pairs[i].fg == fg && color_defs->pairs[i].bg == bg){
               return i;
          }
     }

     // increment the color pair we are going to define, but make sure it wraps around to 0 at the max
     color_defs->current++;
     color_defs->current %= 256;
     if(color_defs->current <= 0) color_defs->current = 1; // when we wrap around, start at 1, because curses doesn't like 0 index color pairs

#if defined(DISPLAY_TERMINAL)
     // create the pair definition
     init_pair(color_defs->current, fg, bg);
#endif

     // set our internal definition
     color_defs->pairs[color_defs->current].fg = fg;
     color_defs->pairs[color_defs->current].bg = bg;

     if(color_defs->current >= color_defs->count){
          color_defs->count = color_defs->current + 1;
     }

     return color_defs->current;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0x1fb7d
xorl %eax, %eax
cmpl %r14d, 0x8(%rbx,%rax,8)
jne 0x1fb75
cmpl %ebp, 0xc(%rbx,%rax,8)
je 0x1fbcd
incq %rax
cmpq %rax, %rcx
jne 0x1fb68
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
leal 0x100(%rax), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
andl $0xffffff00, %edx       # imm = 0xFFFFFF00
negl %edx
addl %edx, %eax
incl %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl %ecx, 0x4(%rbx)
movswl %cx, %edi
movswl %r14w, %esi
movswl %bp, %edx
callq 0xd4f0
movslq 0x4(%rbx), %rax
movl %r14d, 0x8(%rbx,%rax,8)
movl %ebp, 0xc(%rbx,%rax,8)
cmpl (%rbx), %eax
jl 0x1fbcd
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_syntax.c
// Function: check_visual_start
void check_visual_start(CeRangeNode_t* range_node, int64_t line, CeDrawColorList_t* draw_color_list,
                        CeSyntaxDef_t* syntax_defs, bool* in_visual){
     if(range_node){
          CePoint_t start = {0, line};
          if(ce_point_after(start, range_node->range.start) && !ce_point_after(start, range_node->range.end)){
               int bg = ce_syntax_def_get_bg(syntax_defs, CE_SYNTAX_COLOR_VISUAL, ce_draw_color_list_last_bg_color(draw_color_list));
               int fg = ce_syntax_def_get_fg(syntax_defs, CE_SYNTAX_COLOR_VISUAL, ce_draw_color_list_last_fg_color(draw_color_list));
               ce_draw_color_list_insert(draw_color_list, fg, bg, start);
               *in_visual = true;
          }
     }
}

// Assembly:
testq %rdi, %rdi
je 0x1fc69
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
xorl %edi, %edi
callq 0xec71
testb %al, %al
je 0x1fc60
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
xorl %edi, %edi
movq %r14, %rsi
callq 0xec71
testb %al, %al
jne 0x1fc60
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x1fc35
movl 0x64(%r12), %edx
cmpl $-0x2, %edx
jne 0x1fc31
movl 0x4(%rax), %edx
movl (%rax), %esi
jmp 0x1fc45
movl 0x64(%r12), %edx
cmpl $-0x2, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmovel %esi, %edx
movl 0x60(%r12), %eax
cmpl $-0x2, %eax
cmovnel %eax, %esi
movq %r15, %rdi
xorl %ecx, %ecx
movq %r14, %r8
callq 0x1f8e9
movb $0x1, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_syntax.c
// Function: check_visual_mode_end
void check_visual_mode_end(CeRangeNode_t* range_node, bool* in_visual, int64_t line, int64_t line_len,
                           CeDrawColorList_t* draw_color_list){
     if(!range_node) return;

     CePoint_t point = {line_len, line};
     if(in_visual){
          if(ce_point_after(point, range_node->range.end)){
               ce_draw_color_list_insert(draw_color_list, ce_draw_color_list_last_fg_color(draw_color_list),
                                         CE_COLOR_DEFAULT, point);
               range_node = range_node->next;
               *in_visual = false;
          }
     }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1fe11
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0xec71
testb %al, %al
je 0x1fe11
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x1fdf6
movl (%rax), %esi
jmp 0x1fdfb
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r12, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
movq %r14, %r8
callq 0x1f8e9
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_syntax.c
// Function: match_c_multiline_comment
static int64_t match_c_multiline_comment(const char* str){
     if(strncmp("/*", str, 2) == 0){
          char* matching_comment = strstr(str, "*/");
          if(matching_comment) return (matching_comment - str);
          return utf8_strlen_until_trailing_whitespace(str);
     }

     return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
subl $0x2f, %eax
jne 0x203c8
movzbl 0x1(%rbx), %ecx
movl $0x2a, %eax
subl %ecx, %eax
jmp 0x203ca
negl %eax
testl %eax, %eax
je 0x203d2
xorl %eax, %eax
jmp 0x203e9
leaq 0xfb4c(%rip), %rsi      # 0x2ff25
movq %rbx, %rdi
callq 0xd6f0
testq %rax, %rax
je 0x203eb
subq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x22496
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_syntax.c
// Function: match_trailing_whitespace
static int64_t match_trailing_whitespace(const char* str){
     const char* itr = str;
     while(*itr){
          if(!isspace((int)(*itr))) return 0;
          itr++;
     }

     return (itr - str);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
movq %rdi, %rax
testb %bpl, %bpl
je 0x20466
callq 0xd720
movq (%rax), %rcx
movq %rbx, %rax
movsbq %bpl, %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x2046b
movb 0x1(%rax), %bpl
incq %rax
testb %bpl, %bpl
jne 0x2044f
subq %rbx, %rax
jmp 0x2046d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_syntax.c
// Function: match_c_type
static int64_t match_c_type(const char* str, const char* beginning_of_line, bool cpp){
     if(!isalpha((int)(*str))) return false;

     const char* itr = str;
     while(*itr){
          if(!is_c_type_char(*itr)) break;
          itr++;
     }

     int64_t len = itr - str;
     if(len > 1){
          if(strncmp((itr - 2), "_t", 2) == 0) return len;
          if(strncmp((itr - 2), "_h", 2) == 0) return len;
          if(cpp && isupper((int)(*str))) return len;
     }

     static const char* keywords[] = {
          "bool",
          "char",
          "double",
          "float",
          "int",
          "long",
          "short",
          "signed",
          "unsigned",
          "void",
          "S8",
          "S16",
          "S32",
          "S64",
          "U8",
          "U16",
          "U32",
          "U64",
          "F32",
          "F64",
     };

     static const int64_t keyword_count = sizeof(keywords) / sizeof(keywords[0]);

     return match_words(str, beginning_of_line, keywords, keyword_count);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd720
movq (%rax), %rax
movsbq (%r14), %rsi
movzwl (%rax,%rsi,2), %ecx
btl $0xa, %ecx
jb 0x2049d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdx
testb %sil, %sil
je 0x204c7
movq %r14, %rdx
cmpb $0x5f, %sil
je 0x204bb
movsbq %sil, %rsi
movzwl (%rax,%rsi,2), %esi
andl $0x8, %esi
je 0x204c7
movb 0x1(%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0x204a8
movq %rdx, %rax
subq %r14, %rax
cmpq $0x2, %rax
jl 0x204ed
cmpb $0x5f, -0x2(%rdx)
jne 0x204e5
cmpb $0x74, -0x1(%rdx)
je 0x20498
cmpb $0x68, -0x1(%rdx)
je 0x20498
shrl $0x8, %ecx
testb %bpl, %cl
jne 0x20498
leaq 0x19ecc(%rip), %rdx     # 0x3a3c0
movl $0x14, %ecx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x224e2
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_syntax.c
// Function: match_caps_var
static int64_t match_caps_var(const char* str, const char* beginning_of_line){
     const char* itr = str;
     if(!is_starting_caps_var_char(*itr)) return 0; // make sure the first char is not a number
     itr++;
     while(*itr){
          if(!is_caps_var_char(*itr)) break;
          itr++;
     }

     // check before and after the match for non c type chars
     if(str > beginning_of_line){
          if(is_c_type_char(*(str - 1))) return 0;
     }
     if(is_c_type_char(*itr)) return 0;

     int64_t len = itr - str;
     if(len > 1) return len;
     return 0;
}

// Assembly:
movsbl (%rdi), %eax
cmpl $0x5f, %eax
setne %cl
addl $-0x41, %eax
cmpl $0x1a, %eax
setae %al
testb %al, %cl
jne 0x2058b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %eax
movq %rax, %rbx
movsbl (%rdi,%rax), %r15d
movslq %r15d, %r14
testl %r15d, %r15d
je 0x20562
leal -0x41(%r15), %eax
cmpl $0x1a, %eax
setb %al
cmpb $0x5f, %r14b
sete %cl
leal -0x30(%r15), %edx
cmpl $0xa, %edx
setb %dl
orb %al, %dl
orb %cl, %dl
leaq 0x1(%rbx), %rax
testb %dl, %dl
jne 0x2052b
cmpq %rsi, %rdi
jbe 0x2058e
movsbq -0x1(%rdi), %r12
callq 0xd720
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x5f, %r12
je 0x205b5
movq (%rcx), %rdx
movzwl (%rdx,%r12,2), %edx
andl $0x8, %edx
je 0x20596
jmp 0x205b5
xorl %eax, %eax
retq
callq 0xd720
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x5f, %r15b
je 0x205b5
movq (%rcx), %rcx
movzwl (%rcx,%r14,2), %ecx
andl $0x8, %ecx
jne 0x205b5
xorl %eax, %eax
cmpq $0x2, %rbx
cmovgeq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_syntax.c
// Function: match_c_string
static int64_t match_c_string(const char* str){
     if(*str == '"'){
          const char* match = str;
          while(match){
               match = strchr(match + 1, '"');
               if(match && *(match - 1) != '\\'){
                    return (match - str) + 1;
               }
          }
     }

     return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x22, (%rdi)
jne 0x205f8
movq %rdi, %r14
xorl %ebx, %ebx
movq %rdi, %rax
incq %rax
movq %rax, %rdi
movl $0x22, %esi
callq 0xd230
testq %rax, %rax
je 0x205fa
cmpb $0x5c, -0x1(%rax)
je 0x205d2
subq %r14, %rax
incq %rax
movq %rax, %rbx
jmp 0x205fa
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq