LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_jump_list_insert
void ce_jump_list_insert(CeJumpList_t* jump_list, CeDestination_t destination){
     if(jump_list->count < JUMP_LIST_DESTINATION_COUNT){
          if(jump_list->count > 0){
               jump_list->itr++;
               jump_list->current = jump_list->itr;
          }
          jump_list->destinations[jump_list->itr] = destination;
          jump_list->count++;
          return;
     }

     // shift all destinations down
     for(int i = 1; i <= jump_list->itr; i++){
          jump_list->destinations[i - 1] = jump_list->destinations[i];
     }

     jump_list->destinations[jump_list->itr] = destination;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x10, 0x4100(%rax)
jge 0x13a58
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4100(%rax)
jle 0x13a1c
movq -0x8(%rbp), %rax
movq 0x4108(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x4108(%rax)
movq -0x8(%rbp), %rax
movq 0x4108(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4110(%rax)
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
imulq $0x410, 0x4108(%rax), %rax # imm = 0x410
addq %rax, %rdi
movl $0x410, %edx            # imm = 0x410
callq 0xd400
movq -0x8(%rbp), %rax
movq 0x4100(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x4100(%rax)
jmp 0x13ad1
movl $0x1, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x4108(%rcx), %rax
jg 0x13aad
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x410, %rax, %rax      # imm = 0x410
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
imulq $0x410, %rax, %rax      # imm = 0x410
addq %rax, %rsi
movl $0x410, %edx            # imm = 0x410
callq 0xd400
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13a5f
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
imulq $0x410, 0x4108(%rax), %rax # imm = 0x410
addq %rax, %rdi
movl $0x410, %edx            # imm = 0x410
callq 0xd400
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_jump_list_previous
CeDestination_t* ce_jump_list_previous(CeJumpList_t* jump_list){
     if(jump_list->count == 0) return NULL;
     if(jump_list->itr >= (jump_list->count - 1)) return 0;
     jump_list->itr++;
     jump_list->current = jump_list->itr;
     return jump_list->destinations + jump_list->itr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4100(%rax)
jne 0x13b00
movq $0x0, -0x8(%rbp)
jmp 0x13b6f
movq -0x10(%rbp), %rax
movq 0x4108(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x4100(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jl 0x13b29
movq $0x0, -0x8(%rbp)
jmp 0x13b6f
movq -0x10(%rbp), %rax
movq 0x4108(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x4108(%rax)
movq -0x10(%rbp), %rax
movq 0x4108(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x4110(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq $0x410, 0x4108(%rcx), %rcx # imm = 0x410
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_jump_list_next
CeDestination_t* ce_jump_list_next(CeJumpList_t* jump_list){
     if(jump_list->count == 0) return NULL;
     if(jump_list->itr < 0) return NULL;
     jump_list->current = jump_list->itr;
     jump_list->itr--;
     return jump_list->destinations + jump_list->current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4100(%rax)
jne 0x13ba0
movq $0x0, -0x8(%rbp)
jmp 0x13bfe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4108(%rax)
jge 0x13bb8
movq $0x0, -0x8(%rbp)
jmp 0x13bfe
movq -0x10(%rbp), %rax
movq 0x4108(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x4110(%rax)
movq -0x10(%rbp), %rax
movq 0x4108(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x4108(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq $0x410, 0x4110(%rcx), %rcx # imm = 0x410
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_destination_in_view
bool ce_destination_in_view(CeDestination_t* destination, CeView_t* view){
     if(!view) return false;

     int64_t view_width = ce_view_width(view);
     int64_t view_height = ce_view_height(view);
     CeRect_t view_rect = {view->scroll.x, view->scroll.x + view_width, view->scroll.y, view->scroll.y + view_height};

     return strcmp(destination->filepath, view->buffer->name) == 0 &&
            ce_point_in_rect(destination->point, view_rect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13eb0
movb $0x0, -0x1(%rbp)
jmp 0x13f68
movq -0x18(%rbp), %rdi
callq 0x119e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11a00
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
callq 0xd370
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
jne 0x13f60
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x11d80
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_app_update_terminal_view
void ce_app_update_terminal_view(CeApp_t* app, int width, int height) {
     app->terminal_width = width;
     app->terminal_height = height;
     app->terminal_rect = (CeRect_t){0, app->terminal_width - 1, 0, app->terminal_height - 1};
     ce_layout_distribute_rect(app->tab_list_layout, app->terminal_rect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2700(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2704(%rax)
movq -0x8(%rbp), %rax
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movl 0x2700(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rcx, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movl 0x2704(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rcx, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x2818(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x285c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_app_switch_to_prev_buffer_in_view
bool ce_app_switch_to_prev_buffer_in_view(CeApp_t* app, CeView_t* view, bool switch_if_deleted){
     CeAppViewData_t* view_data = view->user_data;
     if(!view_data->prev_buffer) return false;

     bool deleted = true;
     CeBufferNode_t* itr = app->buffer_node_head;
     while(itr){
          if(itr->buffer == view_data->prev_buffer){
               deleted = false;
               break;
          }
          itr = itr->next;
     }

     if(deleted){
          if(switch_if_deleted){
               view_data->prev_buffer = app->buffer_node_head->buffer;
          }else{
               view_data->prev_buffer = NULL;
               return false;
          }
     }

     ce_view_switch_buffer(view, view_data->prev_buffer, &app->vim, &app->config_options, true);
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x4118(%rax)
jne 0x140fa
movb $0x0, -0x1(%rbp)
jmp 0x141ab
movb $0x1, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq 0x2828(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1413c
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x4118(%rcx), %rax
jne 0x1412e
movb $0x0, -0x29(%rbp)
jmp 0x1413c
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1410d
testb $0x1, -0x29(%rbp)
je 0x1417a
testb $0x1, -0x19(%rbp)
je 0x14163
movq -0x10(%rbp), %rax
movq 0x2828(%rax), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x4118(%rax)
jmp 0x14178
movq -0x28(%rbp), %rax
movq $0x0, 0x4118(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x141ab
jmp 0x1417a
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x4118(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
movq -0x10(%rbp), %rcx
addq $0x1a50, %rcx           # imm = 0x1A50
movl $0x1, %r8d
callq 0x13c50
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: input_view_overlay
void input_view_overlay(CeView_t* input_view, CeView_t* view){
     input_view->rect.left = view->rect.left;
     input_view->rect.right = view->rect.right;
     input_view->rect.bottom = view->rect.bottom;
     int64_t max_height = (view->rect.bottom - view->rect.top) - 1;
     int64_t height = input_view->buffer->line_count;
     if(height <= 0) height = 1;
     if(height > max_height) height = max_height;
     input_view->rect.top = view->rect.bottom - height;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x10(%rcx), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jg 0x14231
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x14243
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
subq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: view_cursor_on_screen
CePoint_t view_cursor_on_screen(CeView_t* view, int64_t tab_width, CeLineNumber_t line_number){
     // move the visual cursor to the right location
     int64_t visible_cursor_x = 0;
     if(ce_buffer_point_is_valid(view->buffer, view->cursor)){
          visible_cursor_x = ce_util_string_index_to_visible_index(view->buffer->lines[view->cursor.y],
                                                                   view->cursor.x, tab_width);
     }

     int64_t line_number_width = 0;
     if(!view->buffer->no_line_numbers){
          line_number_width = ce_line_number_column_width(line_number, view->buffer->line_count, view->rect.top, view->rect.bottom);
     }

     return (CePoint_t){visible_cursor_x - view->scroll.x + view->rect.left + line_number_width,
                        view->cursor.y - view->scroll.y + view->rect.top};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0xeba0
cmpq $0x0, %rax
je 0x142c6
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xf970
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
testb $0x1, 0x50(%rax)
jne 0x14304
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0x12940
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rdx), %rcx
movq 0x20(%rdx), %rdx
subq %rdx, %rax
addq %rcx, %rax
movq -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdx
movq 0x38(%rdx), %rax
movq 0x10(%rdx), %rcx
movq 0x28(%rdx), %rdx
subq %rdx, %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: find_already_loaded_file
CeBuffer_t* find_already_loaded_file(CeBufferNode_t* buffer_node_head, const char* filename){
     CeBufferNode_t* itr = buffer_node_head;
     while(itr){
          if(strcmp(itr->buffer->name, filename) == 0){
               return itr->buffer;
          }
          if(strstr(filename, itr->buffer->name) != NULL){
#if defined(PLATFORM_WINDOWS)
               char* buffer_full_path = _fullpath(NULL, itr->buffer->name, MAX_PATH_LEN);
#else
               char* buffer_full_path = realpath(itr->buffer->name, NULL);
#endif
               if(strcmp(buffer_full_path, filename) == 0){
                    free(buffer_full_path);
                    return itr->buffer;
               }
               free(buffer_full_path);
          }
          itr = itr->next;
     }
     return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1440d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xd370
cmpl $0x0, %eax
jne 0x14399
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x14415
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
callq 0xd6d0
cmpq $0x0, %rax
je 0x143fc
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd3f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd370
cmpl $0x0, %eax
jne 0x143f3
movq -0x28(%rbp), %rdi
callq 0xd090
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x14415
movq -0x28(%rbp), %rdi
callq 0xd090
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x14368
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: new_buffer
CeBuffer_t* new_buffer(){
     CeBuffer_t* buffer = calloc(1, sizeof(*buffer));
     if(!buffer) return buffer;
     buffer->app_data = calloc(1, sizeof(CeAppBufferData_t));
     return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x70, %esi
callq 0xd360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x148fc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1491e
movl $0x1, %edi
movl $0x628, %esi            # imm = 0x628
callq 0xd360
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: string_ends_with
static bool string_ends_with(const char* str, const char* pattern){
     int64_t str_len = strlen(str);
     int64_t pattern_len = strlen(pattern);
     if(str_len < pattern_len) return false;

     return strncmp(str + (str_len - pattern_len), pattern, pattern_len) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd200
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd200
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x1496a
movb $0x0, -0x1(%rbp)
jmp 0x14991
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xd0d0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: directory_from_filename
char* directory_from_filename(const char* filename){
     const char* last_slash = strrchr(filename, CE_PATH_SEPARATOR);
     char* directory = NULL;
     if(last_slash) directory = ce_strndup((char*)(filename), last_slash - filename);
     return directory;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0xd260
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x149e5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
subq %rax, %rsi
callq 0x10cc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: buffer_append_on_new_line
bool buffer_append_on_new_line(CeBuffer_t* buffer, const char* string){
     int64_t old_line_count = buffer->line_count;
     if(old_line_count == 1 && strlen(buffer->lines[0]) == 0){
          return ce_buffer_insert_string(buffer, string, (CePoint_t){0, 0});
     }
     int64_t new_line_count = buffer->line_count + 1;
     buffer->lines = realloc(buffer->lines, new_line_count * sizeof(buffer->lines[0]));
     if(buffer->lines == NULL) return false;
     buffer->line_count = new_line_count;
     buffer->lines[old_line_count] = calloc(1, sizeof(buffer->lines[old_line_count]));
     return ce_buffer_insert_string(buffer, string, (CePoint_t){0, old_line_count});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jne 0x15037
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xd200
cmpq $0x0, %rax
jne 0x15037
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xda70
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x150cc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
shlq $0x3, %rsi
callq 0xd500
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15075
movb $0x0, -0x1(%rbp)
jmp 0x150cc
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, %edi
movl $0x8, %esi
callq 0xd360
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0xda70
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: user_config_free
void user_config_free(CeUserConfig_t* user_config){
     free(user_config->filepath);
#if defined(PLATFORM_WINDOWS)

#else
     // NOTE: comment out dlclose() so valgrind can get a helpful stack frame
     dlclose(user_config->handle);
#endif
     memset(user_config, 0, sizeof(*user_config));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd670
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0xd290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: istrtol
int64_t istrtol(const CeRune_t* istr, const CeRune_t** end_of_numbers){
     int64_t value = 0;
     const CeRune_t* itr = istr;

     while(*itr){
          if(isdigit(*itr)){
               value *= 10;
               value += *itr - '0';
          }else{
               if(itr != istr) *end_of_numbers = itr;
               break;
          }

          itr++;
     }

     if(!(*itr) && itr != istr) *end_of_numbers = itr;

     return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x15759
callq 0xd700
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x15734
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
subl $0x30, %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1574b
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x15749
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x15759
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x156f0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x15777
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x15777
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_app_init_command_completion
void ce_app_init_command_completion(CeApp_t* app, CeComplete_t* complete){
     const char** commands = malloc(app->command_entry_count * sizeof(*commands));
     const char** descriptions = malloc(app->command_entry_count * sizeof(*descriptions));
     for(int64_t i = 0; i < app->command_entry_count; i++){
          commands[i] = strdup(app->command_entries[i].name);
          descriptions[i] = strdup(app->command_entries[i].description);
     }
     ce_complete_init(complete, commands, descriptions, app->command_entry_count);
     for(int64_t i = 0; i < app->command_entry_count; i++){
          free((char*)(commands[i]));
          free((char*)(descriptions[i]));
     }
     free(commands);
     free(descriptions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x2838(%rax), %rdi
shlq $0x3, %rdi
callq 0xd4a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x2838(%rax), %rdi
shlq $0x3, %rdi
callq 0xd4a0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2838(%rcx), %rax
jge 0x1596d
movq -0x8(%rbp), %rax
movq 0x2830(%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0xd620
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x2830(%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0xd620
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x158f8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x2838(%rax), %rcx
callq 0x220d0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2838(%rcx), %rax
jge 0x159d2
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xd090
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xd090
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15991
movq -0x18(%rbp), %rdi
callq 0xd090
movq -0x20(%rbp), %rdi
callq 0xd090
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x2708, %rax           # imm = 0x2708
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x2818(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
je 0x15ca7
jmp 0x15de6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x141c0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x58(%rax), %rdi
callq 0xd090
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0xe050
movl $0x1, %edi
movl $0x628, %esi            # imm = 0x628
callq 0xd360
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movb $0x1, 0x50(%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movb $0x1, 0x51(%rax)
movq -0x20(%rbp), %rax
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1a08(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1a20(%rcx), %rdx
movq %rdx, 0x1a10(%rax)
movq 0x1a28(%rcx), %rcx
movq %rcx, 0x1a18(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq 0x1dbd0(%rip), %rcx     # 0x33960
movq %rcx, 0x19c8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x19b0(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x19f9(%rax)
jne 0x15dc7
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
addq $0x19c8, %rdi           # imm = 0x19C8
callq 0x11f10
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x27f8(%rax)
movq -0x8(%rbp), %rdi
addq $0x28a0, %rdi           # imm = 0x28A0
callq 0x221f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd200
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd200
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x15e2a
movb $0x0, -0x1(%rbp)
jmp 0x15e4d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xd370
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2cffd(%rip), %rax     # 0x43e60
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x7, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x16eba
movq -0x8(%rbp), %rdi
addq $0x7, %rdi
callq 0xd200
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x7, %rsi
movq -0x18(%rbp), %rdx
callq 0xd560
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x16ec7
movq -0x8(%rbp), %rdi
callq 0xd200
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x16f49
movq -0x8(%rbp), %rdi
addq -0x28(%rbp), %rdi
leaq 0x2cf78(%rip), %rsi     # 0x43e68
movl $0x3, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x16f19
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x16f2f
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x16ed7
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0xe920
movq $0x0, -0x2028(%rbp)
movq -0x2028(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x618(%rcx), %rax
jge 0x18058
movq -0x18(%rbp), %rax
movq 0x610(%rax), %rax
imulq $0x28, -0x2028(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x2030(%rbp)
leaq -0x2020(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x2030(%rbp), %rax
movq 0x8(%rax), %r8
addq $0x1, %r8
movq -0x2030(%rbp), %rax
movq (%rax), %r9
addq $0x1, %r9
movq -0x2030(%rbp), %rax
movq 0x20(%rax), %rax
movl $0x2000, %esi           # imm = 0x2000
leaq 0x2bc72(%rip), %rdx     # 0x43c98
movq %rax, (%rsp)
movb $0x0, %al
callq 0xd250
movq -0x8(%rbp), %rdi
leaq -0x2020(%rbp), %rsi
callq 0x14fd0
movq -0x2028(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2028(%rbp)
jmp 0x17fae
movq -0x8(%rbp), %rax
movl $0x2, 0x18(%rax)
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x2a34f(%rip), %rsi     # 0x423e7
callq 0xd370
cmpl $0x0, %eax
je 0x180c4
movq -0x8(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x2bbec(%rip), %rsi     # 0x43ca6
callq 0xd370
cmpl $0x0, %eax
jne 0x180cf
movq -0x8(%rbp), %rax
movb $0x1, 0x2c78(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x2a2df(%rip), %rsi     # 0x423e7
callq 0xd370
cmpl $0x0, %eax
je 0x18134
movq -0x10(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x2bb7c(%rip), %rsi     # 0x43ca6
callq 0xd370
cmpl $0x0, %eax
jne 0x18181
movq -0x10(%rbp), %rax
movq 0x2818(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
jne 0x1816e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x18174
movb $0x0, -0x1(%rbp)
jmp 0x18185
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xe7d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2818(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
je 0x18689
movb $0x0, -0x1(%rbp)
jmp 0x18787
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x18783
movq -0x10(%rbp), %rdi
addq $0x2828, %rdi           # imm = 0x2828
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x1a50, %rdx           # imm = 0x1A50
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %r8
movq (%rax,%r8,8), %r9
movl $0x1, %r8d
callq 0x14420
cmpq $0x0, %rax
jne 0x18746
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
callq 0xd0a0
movl (%rax), %edi
callq 0xd630
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x2b5b6(%rip), %rsi     # 0x43ce4
movb $0x0, %al
callq 0x159f0
callq 0xd0a0
movl $0x0, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x18787
movq -0x10(%rbp), %rdi
addq $0x2cd0, %rdi           # imm = 0x2CD0
movq -0x10(%rbp), %rax
movq 0x2828(%rax), %rax
movq (%rax), %rsi
callq 0x1a760
testb $0x1, %al
jne 0x1876e
movb $0x0, -0x1(%rbp)
jmp 0x18787
jmp 0x18770
jmp 0x18772
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x186a1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_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
movq %rsp, %rbp
subq $0x870, %rsp            # imm = 0x870
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2818(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
je 0x187dc
movb $0x0, -0x1(%rbp)
jmp 0x1891c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28d0, %rdi           # imm = 0x28D0
movq -0x10(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x12f80
movq -0x10(%rbp), %rax
addq $0x20, %rax
addq $0x1050, %rax           # imm = 0x1050
movq %rax, -0x460(%rbp)
movl $0x2f, %edi
callq 0x33a80
movq %rax, %rcx
movq -0x460(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd090
movq -0x10(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x450(%rbp), %rdi
xorl %esi, %esi
movl $0x410, %edx            # imm = 0x410
callq 0xd290
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, -0x450(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x448(%rbp)
leaq -0x450(%rbp), %rdi
addq $0x10, %rdi
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0xd0b0
movq -0x40(%rbp), %rax
movq %rax, -0x458(%rbp)
movq %rsp, %rdi
movl $0x82, %ecx
leaq -0x450(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x458(%rbp), %rdi
callq 0x139c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x870, %rsp            # imm = 0x870
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2818(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
je 0x18969
movb $0x0, -0x1(%rbp)
jmp 0x18a10
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x2828(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x18a0c
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0xd370
cmpl $0x0, %eax
jne 0x189fe
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
movq -0x10(%rbp), %rcx
addq $0x1a50, %rcx           # imm = 0x1A50
cmpq $0x0, -0x38(%rbp)
setne %al
movzbl %al, %r8d
andl $0x1, %r8d
callq 0x13c50
jmp 0x18a0c
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x1899c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2818(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
je 0x18a56
movb $0x0, -0x1(%rbp)
jmp 0x18aca
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movl $0x2f, %edi
callq 0x33a80
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rax
addq $0x1050, %rax           # imm = 0x1050
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x18ac6
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1a08, %rsi           # imm = 0x1A08
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rcx
callq 0x1fbf0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x12550
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x18b87
movq -0x8(%rbp), %rdi
addq $0x2940, %rdi           # imm = 0x2940
movq -0x8(%rbp), %rax
movsbl 0x2938(%rax), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdi
callq 0x11f10
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x18b7e
movq -0x8(%rbp), %rdi
addq $0x2940, %rdi           # imm = 0x2940
movq -0x8(%rbp), %rax
movsbl 0x2938(%rax), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x11df0
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x18b3d
movq -0x18(%rbp), %rdi
callq 0xd090
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
addq $0x1050, %rax           # imm = 0x1050
movq -0x8(%rbp), %rcx
movsbl 0x2938(%rcx), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x321a0
cmpl $0x3, -0x1c(%rbp)
jne 0x18cc6
movq -0x8(%rbp), %rax
movq 0x2748(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0xd4a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x2748(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jge 0x18cbb
movq -0x8(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xd200
cmpq $0x0, %rax
je 0x18c94
movq -0x8(%rbp), %rax
movq 0x2748(%rax), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xd620
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x18ca8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x18caa
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x18c2e
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x18cea
movq -0x8(%rbp), %rax
movq 0x2748(%rax), %rdi
callq 0x10cf0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)