LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: ce_app_input
void ce_app_input(CeApp_t* app, const char* dialogue, CeInputCompleteFunc* input_complete_func){
     CeView_t* input_view = &app->input_view;

     CeLayout_t* tab_layout = app->tab_list_layout->tab_list.current;
     if(tab_layout->tab.current->type != CE_LAYOUT_TYPE_VIEW) return;
     CeView_t* view = &tab_layout->tab.current->view;

     input_view_overlay(input_view, view);

     free(input_view->buffer->app_data);

     ce_buffer_alloc(input_view->buffer, 1, dialogue);
     input_view->buffer->app_data = calloc(1, sizeof(CeAppBufferData_t));
     input_view->buffer->no_line_numbers = true;
     input_view->buffer->no_highlight_current_line = true;
     input_view->cursor = (CePoint_t){0, 0};

     app->vim_visual_save.mode = app->vim.mode;
     app->vim_visual_save.visual_point = app->visual.point;

     app->vim.mode = CE_VIM_MODE_INSERT;
     app->vim.current_action.verb.function = ce_vim_verb_insert_mode;
     app->vim.current_action.motion.function = NULL;
     if(!app->vim.verb_last_action){
          ce_rune_node_free(&app->vim.insert_rune_head);
     }

     app->input_complete_func = input_complete_func;
     ce_complete_free(&app->input_complete);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq 0x2818(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
cmpl $0x0, (%rsi)
je 0x11d6a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rdi, %rbx
addq $0x2708, %rdi           # imm = 0x2708
addq $0x8, %rsi
callq 0x10e88
movq 0x2748(%rbx), %rax
movq 0x58(%rax), %rdi
callq 0xd090
movq 0x2748(%rbx), %rdi
pushq $0x1
popq %r12
movq %r12, %rsi
movq %r15, %rdx
callq 0xdd58
movl $0x628, %esi            # imm = 0x628
movq %r12, %rdi
callq 0xd380
movq 0x2748(%rbx), %rcx
movq %rax, 0x58(%rcx)
movw $0x101, 0x50(%rcx)      # imm = 0x101
xorps %xmm0, %xmm0
movups %xmm0, 0x2738(%rbx)
movl 0x20(%rbx), %eax
movl %eax, 0x1a08(%rbx)
movups 0x1a20(%rbx), %xmm0
movups %xmm0, 0x1a10(%rbx)
movl $0x1, 0x20(%rbx)
leaq 0x10710(%rip), %rax     # 0x22503
movq %rax, 0x19c8(%rbx)
andq $0x0, 0x19b0(%rbx)
cmpb $0x0, 0x19f9(%rbx)
jne 0x11e17
leaq 0x19e8(%rbx), %rdi
callq 0xfe39
movq %r14, 0x27f8(%rbx)
addq $0x28a0, %rbx           # imm = 0x28A0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18e0f
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: str_endswith
bool _str_endswith(const char* string,
                   const char* extension){
     int64_t string_len = strlen(string);
     int64_t extension_len = strlen(extension);

     if(extension_len > string_len){
          return false;
     }

     return strcmp(string + (string_len - extension_len),
                   extension) == 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd210
movq %rax, %r15
movq %rbx, %rdi
callq 0xd210
subq %rax, %r15
jge 0x11e5c
xorl %eax, %eax
jmp 0x11e6f
addq %r15, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd390
testl %eax, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: convert_uri_to_linux_path
static void _convert_uri_to_linux_path(char* uri){
     const char prefix[] = "file://";
     int64_t uri_len = 0;
     if(strncmp(uri, prefix, 7) == 0){
          uri_len = strlen(uri + 7);
          memmove(uri, uri + 7, uri_len);
          uri[uri_len] = 0;
     }else{
          uri_len = strlen(uri);
     }
     int64_t u = 0;
     for(int64_t i = 0; i < uri_len; i++){
          if(strncmp(uri + i, "%20", 3) == 0){
               uri[u] = ' ';
               i += 2;
          }else{
               uri[u] = uri[i];
          }
          u++;
     }
     uri[u] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x195c9(%rip), %rsi     # 0x2bead
pushq $0x7
popq %rdx
callq 0xd0d0
testl %eax, %eax
je 0x128fd
movq %rbx, %rdi
callq 0xd210
movq %rax, %r14
jmp 0x1291f
leaq 0x7(%rbx), %r15
movq %r15, %rdi
callq 0xd210
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd580
movb $0x0, (%rbx,%r14)
xorl %eax, %eax
movq %rbx, %rcx
cmpq %r14, %rax
jge 0x1295e
movb (%rbx,%rax), %dl
cmpb $0x25, %dl
jne 0x12954
movb $0x25, %dl
cmpb $0x32, 0x1(%rbx,%rax)
jne 0x12954
xorl %edx, %edx
cmpb $0x30, 0x2(%rbx,%rax)
setne %sil
jne 0x1294b
addq $0x2, %rax
movb %sil, %dl
leal (%rdx,%rdx,4), %edx
orl $0x20, %edx
movb %dl, (%rcx)
incq %rax
incq %rcx
jmp 0x12924
movb $0x0, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: load_destination_into_view
CeBuffer_t* load_destination_into_view(CeBufferNode_t** buffer_node_head, CeView_t* view, CeConfigOptions_t* config_options,
                                       CeVim_t* vim, bool insert_into_jump_list,
                                       const char* base_directory, CeDestination_t* destination){
     char full_path[MAX_PATH_LEN];
     if(!base_directory){
#if defined(PLATFORM_WINDOWS)
          bool is_absolute_path = (destination->filepath[0] != 0 && destination->filepath[1] == ':');
#else
          bool is_absolute_path = (destination->filepath[0] == CE_PATH_SEPARATOR);
#endif
          if(!is_absolute_path){
               base_directory = ".";
          }
     }
     if(base_directory){
          const char* full_path_format = "%s/%s";
          snprintf(full_path, MAX_PATH_LEN - strlen(full_path_format), full_path_format, base_directory, destination->filepath);
     }else{
          strncpy(full_path, destination->filepath, MAX_PATH_LEN);
     }
     CeBuffer_t* load_buffer = load_file_into_view(buffer_node_head, view, config_options, vim,
                                                   insert_into_jump_list, full_path);
     if(!load_buffer) return load_buffer;

     if(destination->point.y < load_buffer->line_count){
          view->cursor.y = destination->point.y;
          int64_t line_len = ce_utf8_strlen(load_buffer->lines[view->cursor.y]);
          if(destination->point.x < line_len) view->cursor.x = destination->point.x;
     }

     return load_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x440(%rsp), %r13
testq %r9, %r9
jne 0x131bd
cmpb $0x2f, 0x10(%r13)
jne 0x131b6
leaq 0x10(%r13), %rsi
movq %rsp, %rdi
movl $0x400, %edx            # imm = 0x400
callq 0xd0b0
jmp 0x131da
leaq 0x170ad(%rip), %r9      # 0x2a26a
leaq 0x10(%r13), %r8
leaq 0x18cdf(%rip), %rdx     # 0x2bea7
movq %rsp, %rdi
movl $0x3fb, %esi            # imm = 0x3FB
movq %r9, %rcx
xorl %eax, %eax
callq 0xd260
movzbl %bpl, %r8d
movq %rsp, %r9
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x10fbd
movq %rax, %r14
testq %rax, %rax
je 0x13221
movq 0x8(%r13), %rax
cmpq 0x8(%r14), %rax
jge 0x13221
movq %rax, 0x38(%rbx)
movq (%r14), %rcx
movq (%rcx,%rax,8), %rdi
callq 0xe38c
movq (%r13), %rcx
cmpq %rax, %rcx
jge 0x13221
movq %rcx, 0x30(%rbx)
movq %r14, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: build_clangd_diagnostics_buffer
void build_clangd_diagnostics_buffer(CeBuffer_t* buffer, CeBuffer_t* source){
     CeAppBufferData_t* app_data = (CeAppBufferData_t*)(source->app_data);
     char line[BUFSIZ];
     buffer->status = CE_BUFFER_STATUS_NONE;
     ce_buffer_empty(buffer);
     for(int64_t i = 0; i < app_data->clangd_diagnostics.count; i++){
         CeClangDDiagnostic_t* diag = app_data->clangd_diagnostics.elements + i;
         snprintf(line, BUFSIZ, "%s:%" PRId64 ":%" PRId64 " %s",
                  source->name, diag->start.y + 1, diag->start.x + 1, diag->message);
         buffer_append_on_new_line(buffer, line);
     }
     buffer->status = CE_BUFFER_STATUS_READONLY;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rsi), %r13
andl $0x0, 0x18(%rdi)
callq 0xe2e2
leaq 0x10(%rsp), %r12
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq 0x618(%r13), %r15
jge 0x13421
movq 0x610(%r13), %rax
movq 0x10(%r14), %rcx
movq (%rax,%rbp), %r9
movq 0x8(%rax,%rbp), %r8
incq %r8
incq %r9
movq 0x20(%rax,%rbp), %rax
movq %rax, (%rsp)
movl $0x2000, %esi           # imm = 0x2000
movq %r12, %rdi
leaq 0x188e1(%rip), %rdx     # 0x2bce7
xorl %eax, %eax
callq 0xd260
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1163b
incq %r15
addq $0x28, %rbp
jmp 0x133cb
movl $0x2, 0x18(%rbx)
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: unsaved_buffers_input_complete_func
bool unsaved_buffers_input_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     if(strcmp(app->input_view.buffer->lines[0], "y") == 0 ||
        strcmp(app->input_view.buffer->lines[0], "Y") == 0){
          app->quit = true;
     }

     return true;
}

// Assembly:
movq 0x2748(%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
movzbl (%rax), %ecx
cmpl $0x59, %ecx
je 0x13454
cmpl $0x79, %ecx
jne 0x13461
cmpb $0x0, 0x1(%rax)
jne 0x13461
movb $0x1, 0x2c78(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: buffer_modified_outside_editor_complete_func
bool buffer_modified_outside_editor_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     if(strcmp(app->input_view.buffer->lines[0], "y") == 0 ||
        strcmp(app->input_view.buffer->lines[0], "Y") == 0){
          CeLayout_t* tab_layout = app->tab_list_layout->tab_list.current;
          CeView_t* view = NULL;

          if(tab_layout->tab.current->type == CE_LAYOUT_TYPE_VIEW){
               view = &tab_layout->tab.current->view;
          }else{
               return false;
          }

          ce_buffer_save(view->buffer);
     }

     return true;
}

// Assembly:
pushq %rbx
movq 0x2748(%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %bl
cmpl $0x59, %ecx
je 0x13481
cmpl $0x79, %ecx
jne 0x134a8
cmpb $0x0, 0x1(%rax)
jne 0x134a8
movq 0x2818(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
je 0x1349f
xorl %ebx, %ebx
jmp 0x134a8
movq 0x48(%rax), %rdi
callq 0xe1fb
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: load_file_input_complete_func
bool load_file_input_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     // TODO: compress with code above
     CeLayout_t* tab_layout = app->tab_list_layout->tab_list.current;
     if(tab_layout->tab.current->type != CE_LAYOUT_TYPE_VIEW) return false;
     CeView_t* view = &tab_layout->tab.current->view;

     char* base_directory = buffer_base_directory(view->buffer);
     char filepath[MAX_PATH_LEN];
     for(int64_t i = 0; i < app->input_view.buffer->line_count; i++){
          if(base_directory && app->input_view.buffer->lines[i][0] != CE_PATH_SEPARATOR){
               snprintf(filepath, MAX_PATH_LEN, "%s%c%s", base_directory, CE_PATH_SEPARATOR, app->input_view.buffer->lines[i]);
          }else{
               strncpy(filepath, app->input_view.buffer->lines[i], MAX_PATH_LEN);
          }
          if(!load_file_into_view(&app->buffer_node_head, view, &app->config_options, &app->vim,
                                  true, filepath)){
               ce_app_message(app, "failed to load file '%s': '%s'", filepath, strerror(errno));
               errno = 0;
               return false;
          }
          if(!ce_clangd_file_open(&app->clangd, app->buffer_node_head->buffer)){
               return false;
          }
     }

     free(base_directory);
     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq 0x2818(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
je 0x136a5
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq 0x48(%rax), %rdi
addq $0x8, %rax
movq %rax, 0x18(%rsp)
callq 0x1132c
movq %rax, 0x8(%rsp)
leaq 0x2828(%r14), %r12
leaq 0x1a50(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
leaq 0x2cd0(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rbx
xorl %r13d, %r13d
movq 0x2748(%r14), %rax
cmpq 0x8(%rax), %r13
setge %bpl
jge 0x13794
movq (%rax), %rax
movq (%rax,%r13,8), %r9
cmpq $0x0, 0x8(%rsp)
je 0x13719
cmpb $0x2f, (%r9)
jne 0x1372b
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %r9, %rsi
callq 0xd0b0
jmp 0x1374a
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
leaq 0x17175(%rip), %rdx     # 0x2a8af
movq 0x8(%rsp), %rcx
pushq $0x2f
popq %r8
xorl %eax, %eax
callq 0xd260
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
pushq $0x1
popq %r8
movq %rbx, %r15
movq %rbx, %r9
callq 0x10fbd
testq %rax, %rax
je 0x137a3
movq (%r12), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdi
callq 0x14cd5
incq %r13
testb %al, %al
movq %r15, %rbx
jne 0x136ef
jmp 0x13691
movq 0x8(%rsp), %rdi
callq 0xd090
jmp 0x13691
callq 0xd0a0
movq %rax, %rbx
movl (%rax), %edi
callq 0xd650
leaq 0x18578(%rip), %rsi     # 0x2bd31
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x11b97
andl $0x0, (%rbx)
jmp 0x13691
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: load_project_file_input_complete_func
bool load_project_file_input_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     // TODO: compress with code above
     CeLayout_t* tab_layout = app->tab_list_layout->tab_list.current;
     if(tab_layout->tab.current->type != CE_LAYOUT_TYPE_VIEW) return false;
     CeView_t* view = &tab_layout->tab.current->view;

     for(int64_t i = 0; i < input_buffer->line_count; i++){
          if(!load_file_into_view(&app->buffer_node_head, view, &app->config_options, &app->vim,
                                  true, input_buffer->lines[i])){
               ce_app_message(app, "failed to load file '%s': '%s'", input_buffer->lines[i], strerror(errno));
               errno = 0;
               return false;
          }else{
               if(!ce_clangd_file_open(&app->clangd, app->buffer_node_head->buffer)){
                    return false;
               }
          }
     }

     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x2818(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r15
cmpl $0x0, (%r15)
je 0x13809
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
addq $0x8, %r15
leaq 0x2828(%rdi), %r12
leaq 0x1a50(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rdi), %rbx
movq %rdi, (%rsp)
leaq 0x2cd0(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
cmpq 0x8(%r14), %r13
setge %bpl
jge 0x137f8
movq (%r14), %rax
movq (%rax,%r13,8), %r9
movq %r12, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
pushq $0x1
popq %r8
callq 0x10fbd
testq %rax, %rax
je 0x13885
movq (%r12), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdi
callq 0x14cd5
testb %al, %al
je 0x137f8
incq %r13
jmp 0x1383a
movq (%r14), %rax
movq (%rax,%r13,8), %rbx
callq 0xd0a0
movq %rax, %r14
movl (%rax), %edi
callq 0xd650
leaq 0x1848f(%rip), %rsi     # 0x2bd31
xorl %ebp, %ebp
movq (%rsp), %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x11b97
andl $0x0, (%r14)
jmp 0x137f8
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: search_input_complete_func
bool search_input_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     // TODO: compress with code above
     CeLayout_t* tab_layout = app->tab_list_layout->tab_list.current;
     if(tab_layout->tab.current->type != CE_LAYOUT_TYPE_VIEW) return false;
     CeView_t* view = &tab_layout->tab.current->view;

     ce_history_insert(&app->search_history, app->input_view.buffer->lines[0]);

     // update yanks
     CeVimYank_t* yank = app->vim.yanks + ce_vim_register_index('/');
     free(yank->text);
     yank->text = strdup(app->input_view.buffer->lines[0]);
     yank->type = CE_VIM_YANK_TYPE_STRING;

     // clear input buffer
     app->input_view.buffer->lines[0][0] = 0;

     // insert jump
     CeAppViewData_t* view_data = view->user_data;
     CeJumpList_t* jump_list = &view_data->jump_list;
     CeDestination_t destination = {};
     destination.point = view->cursor;
     strncpy(destination.filepath, view->buffer->name, MAX_PATH_LEN);
     ce_jump_list_insert(jump_list, destination);
     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x820, %rsp            # imm = 0x820
movq 0x2818(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r14
movl (%r14), %ebp
testl %ebp, %ebp
jne 0x1398f
movq %rdi, %rbx
addq $0x28d0, %rdi           # imm = 0x28D0
movq 0x2748(%rbx), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x1057e
pushq $0x2f
popq %rdi
callq 0x22581
imulq $0x18, %rax, %r15
movq 0x1078(%rbx,%r15), %rdi
callq 0xd090
movq 0x2748(%rbx), %r12
movq (%r12), %rax
movq (%rax), %rdi
callq 0xd640
movq %rax, 0x1078(%rbx,%r15)
movl $0x1, 0x1070(%rbx,%r15)
movq (%r12), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq 0x50(%r14), %rbx
movups 0x38(%r14), %xmm0
leaq 0x420(%rsp), %rdi
movaps %xmm0, -0x10(%rdi)
movq 0x48(%r14), %rax
movq 0x10(%rax), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0xd0b0
leaq 0x410(%rsp), %rsi
movl $0x82, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x10a8e
testl %ebp, %ebp
sete %al
addq $0x820, %rsp            # imm = 0x820
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: switch_buffer_input_complete_func
bool switch_buffer_input_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     // TODO: compress with code above
     CeLayout_t* tab_layout = app->tab_list_layout->tab_list.current;
     if(tab_layout->tab.current->type != CE_LAYOUT_TYPE_VIEW) return false;
     CeView_t* view = &tab_layout->tab.current->view;

     CeAppViewData_t* view_data = view->user_data;
     CeJumpList_t* jump_list = &view_data->jump_list;
     CeBufferNode_t* itr = app->buffer_node_head;
     while(itr){
          if(strcmp(itr->buffer->name, app->input_view.buffer->lines[0]) == 0){
               ce_view_switch_buffer(view, itr->buffer, &app->vim, &app->config_options,
                                     jump_list);
               break;
          }
          itr = itr->next;
     }

     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2818(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r14
movl (%r14), %ebp
testl %ebp, %ebp
jne 0x13a25
movq %rdi, %rbx
movq 0x50(%r14), %r12
addq $0x8, %r14
leaq 0x2828(%rdi), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x13a25
movq (%r13), %r15
movq 0x10(%r15), %rdi
movq 0x2748(%rbx), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0xd390
addq $0x8, %r13
testl %eax, %eax
jne 0x139d7
leaq 0x20(%rbx), %rdx
addq $0x1a50, %rbx           # imm = 0x1A50
xorl %r8d, %r8d
testq %r12, %r12
setne %r8b
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x10bc9
testl %ebp, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: replace_all_input_complete_func
bool replace_all_input_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     // TODO: compress with code above
     CeLayout_t* tab_layout = app->tab_list_layout->tab_list.current;
     if(tab_layout->tab.current->type != CE_LAYOUT_TYPE_VIEW) return false;
     CeView_t* view = &tab_layout->tab.current->view;

     int64_t index = ce_vim_register_index('/');
     CeVimYank_t* yank = app->vim.yanks + index;
     if(yank->text){
          replace_all(view, &app->vim_visual_save, yank->text, app->input_view.buffer->lines[0]);
     }
     return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x2818(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r14
movl (%r14), %ebp
testl %ebp, %ebp
jne 0x13a92
movq %rdi, %rbx
pushq $0x2f
popq %rdi
callq 0x22581
imulq $0x18, %rax, %rax
movq 0x1078(%rbx,%rax), %rdx
testq %rdx, %rdx
je 0x13a92
addq $0x8, %r14
movq 0x2748(%rbx), %rax
addq $0x1a08, %rbx           # imm = 0x1A08
movq (%rax), %rax
movq (%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17827
testl %ebp, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: edit_macro_input_complete_func
bool edit_macro_input_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     CeRune_t* rune_string = ce_char_string_to_rune_string(app->input_view.buffer->lines[0]);
     if(rune_string){
          ce_rune_node_free(app->macros.rune_head + app->edit_register);
          CeRune_t* itr = rune_string;
          while(*itr){
               ce_rune_node_insert(app->macros.rune_head + app->edit_register, *itr);
               itr++;
          }

          free(rune_string);
     }
     return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2748(%rdi), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x10081
testq %rax, %rax
je 0x13b0a
movq %rax, %r14
leaq 0x2940(%rbx), %r15
movsbq 0x2938(%rbx), %rax
leaq (%rbx,%rax,8), %rdi
addq $0x2940, %rdi           # imm = 0x2940
callq 0xfe39
movq %r14, %r12
movl (%r12), %esi
testl %esi, %esi
je 0x13b02
movsbq 0x2938(%rbx), %rax
leaq (%r15,%rax,8), %rdi
callq 0xfdbe
addq $0x4, %r12
jmp 0x13ae3
movq %r14, %rdi
callq 0xd090
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: edit_yank_input_complete_func
bool edit_yank_input_complete_func(CeApp_t* app, CeBuffer_t* input_buffer){
     CeVimYank_t* yank = app->vim.yanks + app->edit_register;
     CeVimYankType_t yank_type = yank->type;
     ce_vim_yank_free(yank);
     if(yank_type == CE_VIM_YANK_TYPE_BLOCK){
          yank->block_line_count = app->input_view.buffer->line_count;
          yank->block = malloc(yank->block_line_count * sizeof(*yank->block));
          for(int64_t i = 0; i < app->input_view.buffer->line_count; i++){
               if(strlen(app->input_view.buffer->lines[i])){
                    yank->block[i] = strdup(app->input_view.buffer->lines[i]);
               }else{
                    yank->block[i] = NULL;
               }
          }
          yank->type = yank_type;
     }else{
          yank->text = ce_buffer_dupe(app->input_view.buffer);
          yank->type = yank_type;
     }
     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movsbq 0x2938(%rdi), %rax
imulq $0x18, %rax, %rax
leaq (%rdi,%rax), %rbx
addq $0x1070, %rbx           # imm = 0x1070
movl (%rbx), %ebp
movq %rbx, %rdi
callq 0x2196f
movq 0x2748(%r14), %r15
cmpl $0x3, %ebp
jne 0x13b9a
movq 0x8(%r15), %rdi
movq %rdi, 0x10(%rbx)
shlq $0x3, %rdi
callq 0xd4c0
movq %rax, 0x8(%rbx)
xorl %r12d, %r12d
pushq $0x3
popq %rbp
cmpq 0x8(%r15), %r12
jge 0x13ba6
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
cmpb $0x0, (%rdi)
je 0x13b84
callq 0xd640
jmp 0x13b86
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x2748(%r14), %r15
jmp 0x13b6b
movq %r15, %rdi
callq 0xf570
movq %rax, 0x8(%rbx)
movl %ebp, (%rbx)
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: run_shell_command_cleanup
void run_shell_command_cleanup(void* data){
     RunShellCommandCleanup_t* cleanup = (RunShellCommandCleanup_t*)(data);

     *cleanup->shell_command_data->should_scroll = false;

     if(cleanup->shell_command_data){
          free(cleanup->shell_command_data->command);
          free(cleanup->shell_command_data);
     }

     if(cleanup->subprocess){
          // kill the subprocess and wait for it to be cleaned up
#if !defined(PLATFORM_WINDOWS)
          ce_subprocess_kill(cleanup->subprocess, SIGKILL);
          ce_subprocess_close(cleanup->subprocess);
#endif
     }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rcx
movb $0x0, (%rcx)
movq 0x8(%rax), %rdi
callq 0xd090
movq (%rbx), %rdi
callq 0xd090
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x13bed
pushq $0x9
popq %rsi
callq 0x1d8f3
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x1d934
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: ce_clang_format_buffer
bool ce_clang_format_buffer(char* clang_format_exe, CeBuffer_t* buffer, CePoint_t cursor){
    char* buffer_str = ce_buffer_dupe(buffer);
    int64_t buffer_str_len = ce_utf8_strlen(buffer_str);
    ClangFormatResult_t result = _clang_format_string(clang_format_exe, buffer_str, buffer_str_len);
    free(buffer_str);
    if(!result.success){
        return false;
    }

    bool removed = ce_buffer_remove_string_change(buffer, (CePoint_t){0, 0}, buffer_str_len,
                                                  &cursor, cursor, false);
    if(!removed){
        ce_log("Failed to clear buffer %s to insert clang format results\n", buffer->name);
        free(result.bytes);
        return false;
    }
    bool inserted = ce_buffer_insert_string_change(buffer, result.bytes, (CePoint_t){0, 0}, &cursor,
                                                   cursor, true);
    if(!inserted){
        ce_log("Failed to insert clang format results into %s\n", buffer->name);
        free(result.bytes);
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rsi, %rdi
callq 0xf570
movq %rax, %r12
movq %rax, %rdi
callq 0xe38c
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x14020
movl %eax, %ebp
movq %rdx, %r14
movq %r12, %rdi
callq 0xd090
testb $0x1, %bpl
je 0x141f5
leaq 0x10(%rsp), %r8
movups (%r8), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
xorl %r9d, %r9d
callq 0xf77c
testb %al, %al
je 0x141f9
leaq 0x10(%rsp), %r8
movups (%r8), %xmm0
movups %xmm0, (%rsp)
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf5c8
movb $0x1, %bpl
testb %al, %al
jne 0x14215
leaq 0x17c3e(%rip), %rdi     # 0x2be31
jmp 0x14200
xorl %ebp, %ebp
jmp 0x14215
leaq 0x17bf7(%rip), %rdi     # 0x2bdf7
movq 0x10(%rbx), %rsi
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xd8e5
movq %r14, %rdi
callq 0xd090
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_app.c
// Function: ce_app_close_popup_view
bool ce_app_close_popup_view(CeApp_t* app){
     CeLayout_t* tab_layout = app->tab_list_layout->tab_list.current;
     CeLayout_t* current_layout = tab_layout->tab.current;
     CeLayout_t* popup_layout = ce_layout_find_popup(app->tab_list_layout);
     if(popup_layout == NULL){
         return false;
     }
     // Save a point in the popup layout.
     CePoint_t popup_point = {};
     if(popup_layout->type == CE_LAYOUT_TYPE_VIEW){
         popup_point.x = popup_layout->view.rect.left;
         popup_point.y = popup_layout->view.rect.top;
     }
     bool result = ce_layout_delete(app->tab_list_layout, popup_layout);
     // Find the layout that is where the popup layout used to be, and make it the current one if
     // the delete was successful.
     if(result && current_layout == popup_layout){
          CeLayout_t* select_layout = ce_layout_find_at(tab_layout, popup_point);
          if(select_layout){
              tab_layout->tab.current = select_layout;
          }
     }
     return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq 0x2818(%rdi), %rdi
movq 0x10(%rdi), %rbx
movq 0x10(%rbx), %rbp
callq 0x1d0e4
testq %rax, %rax
je 0x14398
movq %rax, %r14
cmpl $0x0, (%rax)
je 0x1439c
xorl %r15d, %r15d
xorl %r13d, %r13d
jmp 0x143a4
xorl %eax, %eax
jmp 0x143d9
movq 0x8(%r14), %r15
movq 0x18(%r14), %r13
movq 0x2818(%r12), %rdi
movq %r14, %rsi
callq 0x1d151
testb %al, %al
je 0x143d9
cmpq %r14, %rbp
jne 0x143d9
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1d04c
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
je 0x143d9
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: send_json_obj
static bool _send_json_obj(CeJsonObj_t* obj, CeSubprocess_t* subprocess){
     // Build the message boyd
     char* message_body = malloc(DEFAULT_MESSAGE_SIZE);
     ce_json_obj_to_string(obj, message_body, DEFAULT_MESSAGE_SIZE - 1, 1);
     uint64_t message_len = strlen(message_body);

     // Prepend the header.
     char* header = malloc(DEFAULT_HEADER_SIZE);
     int64_t header_len = snprintf(header, DEFAULT_HEADER_SIZE, "Content-Length: %" PRId64 "\r\n\r\n",
                                             message_len);

     int64_t bytes_written = ce_subprocess_write_stdin(subprocess, header, header_len);
     free(header);
     if(bytes_written < 0){
          free(message_body);
          return false;
     }
     bytes_written = ce_subprocess_write_stdin(subprocess, message_body, message_len);
     free(message_body);
     if(bytes_written < 0){
          return false;
     }
     return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1000000, %edi        # imm = 0x1000000
callq 0xd4c0
movq %rax, %rbx
pushq $0x1
popq %rcx
movl $0xffffff, %edx         # imm = 0xFFFFFF
movq %r15, %rdi
movq %rax, %rsi
callq 0x1ad46
movq %rbx, %rdi
callq 0xd210
movq %rax, %r15
movl $0x400, %edi            # imm = 0x400
callq 0xd4c0
movq %rax, %r12
leaq 0x17528(%rip), %rdx     # 0x2c198
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0xd260
movslq %eax, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1da39
movq %rax, %r13
movq %r12, %rdi
callq 0xd090
testq %r13, %r13
js 0x14cc1
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1da39
movq %rax, %r14
movq %rbx, %rdi
callq 0xd090
testq %r14, %r14
setns %al
jmp 0x14ccb
movq %rbx, %rdi
callq 0xd090
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: calculate_filename_uri
static bool _calculate_filename_uri(const char* name, char* uri, size_t size){
#if defined(PLATFORM_WINDOWS)
     char* full_file_path = _fullpath(NULL, name, size);
     strncpy(uri, full_file_path, size);
     free(full_file_path);
     if(!_convert_windows_path_to_uri(uri, size)){
          return false;
     }
#else
     char* full_file_path = realpath(name, NULL);
     snprintf(uri, size, "file://%s", full_file_path);
     free(full_file_path);
#endif
     return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %esi, %esi
callq 0xd410
movq %rax, %r14
leaq 0x171f5(%rip), %rdx     # 0x2c06a
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xd260
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd090
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_file_close
bool ce_clangd_file_close(CeClangD_t* clangd, CeBuffer_t* buffer){
     if(clangd->buffer == NULL){
          return true;
     }
     CeAppBufferData_t* buffer_data = buffer->app_data;
     if(buffer_data->syntax_function != ce_syntax_highlight_c &&
        buffer_data->syntax_function != ce_syntax_highlight_cpp){
          return true;
     }
     char file_uri[MAX_PATH_LEN + 1];
     if(!_calculate_filename_uri(buffer->name, file_uri, MAX_PATH_LEN)){
          return false;
     }

     CeJsonObj_t obj = {};
     ce_json_obj_set_string(&obj, "jsonrpc", "2.0");
     ce_json_obj_set_string(&obj, "method", "textDocument/didClose");

     CeJsonObj_t text_document_obj = {};
     ce_json_obj_set_string(&text_document_obj, "uri", file_uri);
     CeJsonObj_t param_obj = {};
     ce_json_obj_set_obj(&param_obj, "textDocument", &text_document_obj);
     ce_json_obj_set_obj(&obj, "params", &param_obj);

     bool result = _send_json_obj(&obj, &clangd->proc);
     ce_json_obj_free(&param_obj);
     ce_json_obj_free(&text_document_obj);
     ce_json_obj_free(&obj);
     return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x440, %rsp            # imm = 0x440
movb $0x1, %bpl
cmpq $0x0, 0x28(%rdi)
je 0x14f9c
movq 0x58(%rsi), %rax
movq 0x600(%rax), %rax
cmpq 0x2409b(%rip), %rax     # 0x38f60
setne %cl
cmpq 0x24089(%rip), %rax     # 0x38f58
setne %al
testb %al, %cl
jne 0x14f9c
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
leaq 0x30(%rsp), %r12
movq %r12, %rsi
callq 0x14e5d
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
leaq 0x17148(%rip), %rsi     # 0x2c049
leaq 0x17149(%rip), %rdx     # 0x2c051
movq %r14, %rdi
callq 0x1ab25
leaq 0x16da9(%rip), %rsi     # 0x2bcc0
leaq 0x171ca(%rip), %rdx     # 0x2c0e8
movq %r14, %rdi
callq 0x1ab25
leaq 0x10(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
leaq 0x16cca(%rip), %rsi     # 0x2bc03
movq %r15, %rdi
movq %r12, %rdx
callq 0x1ab25
movq %rsp, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
leaq 0x17185(%rip), %rsi     # 0x2c0db
movq %r12, %rdi
movq %r15, %rdx
callq 0x1a949
leaq 0x16c94(%rip), %rsi     # 0x2bbfc
movq %r14, %rdi
movq %r12, %rdx
callq 0x1a949
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14c22
movl %eax, %ebp
movq %r12, %rdi
callq 0x1ad0b
movq %r15, %rdi
callq 0x1ad0b
movq %r14, %rdi
callq 0x1ad0b
movl %ebp, %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_request_goto_type_def
bool ce_clangd_request_goto_type_def(CeClangD_t* clangd, CeBuffer_t* buffer, CePoint_t point){
     if(clangd->buffer == NULL){
          return true;
     }
     const char* method = "textDocument/typeDefinition";
     clangd->current_request_id++;
     _clangd_track_request(clangd, method);
     return _clangd_request_goto(clangd, buffer, point, method);
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x1517f
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
incq 0x30(%rdi)
leaq 0x16aca(%rip), %r13     # 0x2bc27
movq %r13, %rsi
callq 0x15182
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x151da
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: clangd_request_goto
static bool _clangd_request_goto(CeClangD_t* clangd, CeBuffer_t* buffer, CePoint_t point,
                                 const char* method){
     char file_uri[MAX_PATH_LEN + 1];
     if(!_calculate_filename_uri(buffer->name, file_uri, MAX_PATH_LEN)){
          return false;
     }

     CeJsonObj_t obj = {};
     ce_json_obj_set_string(&obj, "jsonrpc", "2.0");
     ce_json_obj_set_number(&obj, "id", clangd->current_request_id);
     ce_json_obj_set_string(&obj, "method", method);

     CeJsonObj_t param_obj = {};

     CeJsonObj_t pos_obj = {};
     ce_json_obj_set_number(&pos_obj, "line", point.y);
     ce_json_obj_set_number(&pos_obj, "character", point.x);
     ce_json_obj_set_obj(&param_obj, "position", &pos_obj);

     CeJsonObj_t text_document_obj = {};
     ce_json_obj_set_string(&text_document_obj, "uri", file_uri);
     ce_json_obj_set_obj(&param_obj, "textDocument", &text_document_obj);

     ce_json_obj_set_obj(&obj, "params", &param_obj);

     bool result = _send_json_obj(&obj, &clangd->proc);
     ce_json_obj_free(&text_document_obj);
     ce_json_obj_free(&pos_obj);
     ce_json_obj_free(&param_obj);
     ce_json_obj_free(&obj);
     return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp            # imm = 0x448
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbp
movq %rdi, %r14
movq 0x10(%rsi), %rdi
leaq 0x40(%rsp), %rsi
callq 0x14e5d
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rbx
movaps %xmm0, (%rbx)
leaq 0x16e32(%rip), %rsi     # 0x2c049
leaq 0x16e33(%rip), %rdx     # 0x2c051
movq %rbx, %rdi
callq 0x1ab25
cvtsi2sdq 0x30(%r14), %xmm0
leaq 0x17e35(%rip), %rsi     # 0x2d068
movq %rbx, %rdi
callq 0x1aba5
leaq 0x16a7e(%rip), %rsi     # 0x2bcc0
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1ab25
leaq 0x20(%rsp), %r15
xorpd %xmm0, %xmm0
movapd %xmm0, (%r15)
leaq 0x10(%rsp), %r13
movapd %xmm0, (%r13)
cvtsi2sd %r12, %xmm0
leaq 0x15a4b(%rip), %rsi     # 0x2acbd
movq %r13, %rdi
callq 0x1aba5
cvtsi2sd %rbp, %xmm0
leaq 0x1696c(%rip), %rsi     # 0x2bbf2
movq %r13, %rdi
callq 0x1aba5
leaq 0x16f1b(%rip), %rsi     # 0x2c1b0
movq %r15, %rdi
movq %r13, %rdx
callq 0x1a949
movq %rsp, %r12
xorpd %xmm0, %xmm0
movapd %xmm0, (%r12)
leaq 0x1694f(%rip), %rsi     # 0x2bc03
movq %r12, %rdi
leaq 0x40(%rsp), %rdx
callq 0x1ab25
leaq 0x16e13(%rip), %rsi     # 0x2c0db
movq %r15, %rdi
movq %r12, %rdx
callq 0x1a949
leaq 0x16922(%rip), %rsi     # 0x2bbfc
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1a949
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14c22
movl %eax, %ebp
movq %r12, %rdi
callq 0x1ad0b
movq %r13, %rdi
callq 0x1ad0b
movq %r15, %rdi
callq 0x1ad0b
movq %rbx, %rdi
callq 0x1ad0b
movl %ebp, %eax
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_request_goto_def
bool ce_clangd_request_goto_def(CeClangD_t* clangd, CeBuffer_t* buffer, CePoint_t point){
     if(clangd->buffer == NULL){
          return true;
     }
     const char* method = "textDocument/definition";
     clangd->current_request_id++;
     _clangd_track_request(clangd, method);
     return _clangd_request_goto(clangd, buffer, point, method);
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x15376
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
incq 0x30(%rdi)
leaq 0x168f2(%rip), %r13     # 0x2bc43
movq %r13, %rsi
callq 0x15182
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x151da
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_request_goto_decl
bool ce_clangd_request_goto_decl(CeClangD_t* clangd, CeBuffer_t* buffer, CePoint_t point){
     if(clangd->buffer == NULL){
          return true;
     }
     const char* method = "textDocument/declaration";
     clangd->current_request_id++;
     _clangd_track_request(clangd, method);
     return _clangd_request_goto(clangd, buffer, point, method);
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x153c5
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
incq 0x30(%rdi)
leaq 0x168bb(%rip), %r13     # 0x2bc5b
movq %r13, %rsi
callq 0x15182
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x151da
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_request_auto_complete
bool ce_clangd_request_auto_complete(CeClangD_t* clangd, CeBuffer_t* buffer, CePoint_t point){
     if(clangd->buffer == NULL){
          return true;
     }
     const char* method = "textDocument/completion";
     clangd->current_request_id++;
     _clangd_track_request(clangd, method);
     return _clangd_request_goto(clangd, buffer, point, method);
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x15414
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
incq 0x30(%rdi)
leaq 0x168a1(%rip), %r13     # 0x2bc90
movq %r13, %rsi
callq 0x15182
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x151da
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_request_find_references
bool ce_clangd_request_find_references(CeClangD_t* clangd, CeBuffer_t* buffer, CePoint_t point){
     if(clangd->buffer == NULL){
          return true;
     }
     const char* method = "textDocument/references";
     clangd->current_request_id++;
     _clangd_track_request(clangd, method);
     return _clangd_request_goto(clangd, buffer, point, method);
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x15463
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
incq 0x30(%rdi)
leaq 0x1686a(%rip), %r13     # 0x2bca8
movq %r13, %rsi
callq 0x15182
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x151da
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_pop_response
CeClangDResponse_t ce_clangd_pop_response(CeClangD_t* clangd){
     if(clangd->buffer == NULL){
          return (CeClangDResponse_t){};
     }
     CeClangDResponse_t response = _pop_response(&clangd->response_queue);
     for(int64_t i = 0; i < clangd->request_lookup.size; i++){
          if(clangd->request_lookup.requests[i].id == response.request_id){
               response.method = clangd->request_lookup.requests[i].method;
               _remove_clangd_request(&clangd->request_lookup, i);
               return response;
          }
     }
     return response;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rsi)
je 0x154f6
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x48(%rsi), %r15
movq %r15, %rdi
callq 0xd700
testl %eax, %eax
je 0x15553
leaq 0x16c8a(%rip), %r15     # 0x2c135
movl %eax, %edi
callq 0xd650
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xd8e5
movq 0x70(%r14), %r15
xorl %edx, %edx
testq %r15, %r15
cmovgq %r15, %rdx
movq (%rbx), %rsi
negq %rdx
pushq $0x10
popq %rax
pushq $0x1
popq %rcx
leaq (%rdx,%rcx), %rdi
cmpq $0x1, %rdi
je 0x15546
movq 0x78(%r14), %rdi
cmpq %rsi, -0x8(%rdi,%rax)
je 0x15503
addq $0x10, %rax
incq %rcx
jmp 0x154d8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
jmp 0x15546
movq -0x10(%rdi,%rax), %rdx
movq %rdx, 0x10(%rbx)
cmpq %r15, %rcx
jge 0x1552b
movq 0x78(%r14), %rdx
movups (%rdx,%rax), %xmm0
movups %xmm0, -0x10(%rdx,%rax)
movq 0x70(%r14), %r15
addq $0x10, %rax
incq %rcx
jmp 0x1550c
decq %r15
movq 0x78(%r14), %rdi
movq %r15, %rsi
shlq $0x4, %rsi
callq 0xd520
movq %rax, 0x78(%r14)
movq %r15, 0x70(%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x38(%r14), %r13
testq %r13, %r13
je 0x154bf
movq 0x40(%r14), %rdi
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
decq %r13
leaq 0x18(%rdi), %rsi
imulq $0x18, %r13, %r12
movq %r12, %rdx
callq 0xd580
movq 0x40(%r14), %rdi
movq %r12, %rsi
callq 0xd520
movq %rax, 0x40(%r14)
movq %r13, 0x38(%r14)
movq %r15, %rdi
callq 0xd490
testl %eax, %eax
je 0x154bf
leaq 0x16bb6(%rip), %r15     # 0x2c166
jmp 0x154ab
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_free
void ce_clangd_free(CeClangD_t* clangd){
     if(clangd->buffer == NULL){
          return;
     }
#if defined(PLATFORM_WINDOWS)
     ce_subprocess_kill(&clangd->proc, 0);
     CloseHandle(clangd->thread_handle);
#else
     ce_subprocess_kill(&clangd->proc, SIGINT);
#endif

#if defined(PLATFORM_WINDOWS)
     CloseHandle(clangd->thread_handle);
     CloseHandle(clangd->response_queue.mutex);
#else
     pthread_join(clangd->thread, NULL);
     pthread_mutex_destroy(&clangd->response_queue.mutex);
#endif

     memset(clangd, 0, sizeof(*clangd));
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x15602
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
pushq $0x2
popq %rsi
callq 0x1d8f3
movq (%rbx), %rdi
xorl %esi, %esi
callq 0xd630
leaq 0x48(%rbx), %rdi
callq 0xd250
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_response_free
void ce_clangd_response_free(CeClangDResponse_t* response){
     if(response->obj == NULL){
          return;
     }
     ce_json_obj_free(response->obj);
     free(response->obj);
     free(response->method);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x15628
callq 0x1ad0b
movq 0x8(%rbx), %rdi
callq 0xd090
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0xd090
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_diag_add
void ce_clangd_diag_add(CeClangDDiagnostics_t* diags, CeClangDDiagnostic_t* elem){
    int64_t new_count = diags->count + 1;
    diags->elements = realloc(diags->elements, new_count * sizeof(diags->elements[0]));
    memcpy(diags->elements + diags->count, elem, sizeof(diags->elements[0]));
    diags->elements[diags->count].message = strdup(elem->message);
    diags->count = new_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %r12
incq %r12
imulq $0x28, %r12, %rsi
callq 0xd520
movq %rax, %r15
movq %rax, (%r14)
imulq $0x28, 0x8(%r14), %r13
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%rax,%r13)
movups %xmm1, 0x10(%rax,%r13)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r15,%r13)
movq 0x20(%rbx), %rdi
callq 0xd640
movq %rax, 0x20(%r15,%r13)
movq %r12, 0x8(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_clangd.c
// Function: ce_clangd_diag_free
void ce_clangd_diag_free(CeClangDDiagnostics_t* diags){
    for(int64_t i = 0; i < diags->count; i++){
        free(diags->elements[i].message);
    }
    free(diags->elements);
    free(diags->filepath);
    memset(diags, 0, sizeof(*diags));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %r14
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r15
jge 0x156b8
movq (%rdi,%r14), %rdi
callq 0xd090
incq %r15
addq $0x28, %r14
jmp 0x1569d
callq 0xd090
movq 0x10(%rbx), %rdi
callq 0xd090
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_command.c
// Function: eat_blanks
static const char* eat_blanks(const char* string){
     while(*string){
          if(!isblank((int)(*string))) break;
          string++;
     }

     return string;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbq (%rbx), %r14
testq %r14, %r14
je 0x1590f
callq 0xd720
movq (%rax), %rax
testb $0x1, (%rax,%r14,2)
je 0x1590f
incq %rbx
jmp 0x158f2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_command.c
// Function: find_end_of_arg
static const char* find_end_of_arg(const char* string){
     bool quote = (*string == '"');

     if(quote){
          // find the next quote, ignoring backslashed quotes
          char prev = 0;
          while(*string){
               prev = *string;
               string++;
               if(*string == '"' && prev != '\\'){
                    const char* end = string + 1;
                    if(*end) return end;
                    return NULL;
               }
          }
          return NULL;
     }else{
          return strchr(string, ' ');
     }
}

// Assembly:
cmpb $0x22, (%rdi)
jne 0x1594d
incq %rdi
movb $0x22, %cl
xorl %eax, %eax
testb %cl, %cl
je 0x1594c
movb (%rdi), %dl
cmpb $0x22, %dl
setne %sil
cmpb $0x5c, %cl
sete %cl
incq %rdi
orb %sil, %cl
movl %edx, %ecx
jne 0x15926
xorl %eax, %eax
cmpb $0x0, (%rdi)
cmovneq %rdi, %rax
retq
pushq $0x20
popq %rsi
jmp 0xd230