LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_insert_rune
bool ce_buffer_insert_rune(CeBuffer_t* buffer, CeRune_t rune, CePoint_t point){
     char str[5];
     int64_t written = 0;
     ce_utf8_encode(rune, str, 5, &written);
     str[written] = 0;
     return ce_buffer_insert_string(buffer, str, point);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x1c(%rbp), %edi
leaq -0x21(%rbp), %rsi
movl $0x5, %edx
leaq -0x30(%rbp), %rcx
callq 0x10000
movq -0x30(%rbp), %rax
movb $0x0, -0x21(%rbp,%rax)
movq -0x18(%rbp), %rdi
leaq -0x21(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
callq 0xda70
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_dupe
char* ce_buffer_dupe(CeBuffer_t* buffer){
     CePoint_t start = {0, 0};
     CePoint_t end = {0, buffer->line_count};
     if(end.y) end.y--;
     end.x = ce_utf8_last_index(buffer->lines[end.y]);
     int64_t len = ce_buffer_range_len(buffer, start, end);
     if(len > 0) return ce_buffer_dupe_string(buffer, start, len);
     return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xd290
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x10d33
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xf1f0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xf510
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jle 0x10d8a
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10900
movq %rax, -0x8(%rbp)
jmp 0x10d92
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_insert_string_change
bool ce_buffer_insert_string_change(CeBuffer_t* buffer, char* alloced_string, CePoint_t point, CePoint_t* cursor_before,
                                    CePoint_t cursor_after, bool chain_undo){
     if(!ce_buffer_insert_string(buffer, alloced_string, point)) return false;

     CeBufferChange_t change = {};
     change.chain = chain_undo;
     change.insertion = true;
     change.string = alloced_string;
     change.location = point;
     change.cursor_before = *cursor_before;
     change.cursor_after = cursor_after;
     ce_buffer_change(buffer, &change);

     *cursor_before = cursor_after;
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r9b, %al
leaq 0x10(%rbp), %r9
movq %r9, -0x80(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xda70
testb $0x1, %al
jne 0x10df1
movb $0x0, -0x1(%rbp)
jmp 0x10e73
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0xd290
movq -0x80(%rbp), %rax
movb -0x31(%rbp), %cl
andb $0x1, %cl
movb %cl, -0x78(%rbp)
movb $0x1, -0x77(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq -0x30(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
movq 0x8(%rcx), %rcx
movq %rcx, -0x50(%rbp)
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x10e90
movq -0x80(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_change
bool ce_buffer_change(CeBuffer_t* buffer, CeBufferChange_t* change){
     CeBufferChangeNode_t* node = calloc(1, sizeof(*node));
     node->change = *change;
     node->next = NULL;

     if(buffer->change_node){
          if(buffer->change_node->next){
               ce_buffer_change_node_free(&buffer->change_node->next);
          }

          node->prev = buffer->change_node;
          node->index = buffer->change_node->index + 1;
          buffer->change_node->next = node;
     }else{
          CeBufferChangeNode_t* first_empty_node = calloc(1, sizeof(*node));
          first_empty_node->next = node;
          node->prev = first_empty_node;
          if(buffer->save_at_change_node == NULL) buffer->save_at_change_node = first_empty_node;
     }

     buffer->change_node = node;
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0xd360
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0xd400
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x10f36
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x40(%rax)
je 0x10efc
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x40, %rdi
callq 0xe210
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x40(%rax)
jmp 0x10f7a
movl $0x1, %edi
movl $0x58, %esi
callq 0xd360
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x10f78
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0x10f7a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_insert_string_change_at_cursor
bool ce_buffer_insert_string_change_at_cursor(CeBuffer_t* buffer, char* alloced_string, CePoint_t* cursor, bool chain_undo){
     if(!ce_buffer_insert_string(buffer, alloced_string, *cursor)) return false;
     CePoint_t cursor_after = ce_buffer_advance_point(buffer, *cursor, strlen(alloced_string));

     CeBufferChange_t change = {};
     change.chain = chain_undo;
     change.insertion = true;
     change.string = alloced_string;
     change.location = *cursor;
     change.cursor_before = *cursor;
     change.cursor_after = cursor_after;
     ce_buffer_change(buffer, &change);

     *cursor = cursor_after;
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0xda70
testb $0x1, %al
jne 0x10fd3
movb $0x0, -0x1(%rbp)
jmp 0x1108f
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd200
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xfaf0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0xd290
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x78(%rbp)
movb $0x1, -0x77(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x10e90
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_remove_string_change
bool ce_buffer_remove_string_change(CeBuffer_t* buffer, CePoint_t point, int64_t remove_len, CePoint_t* cursor_before,
                                    CePoint_t cursor_after, bool chain_undo){
     char* remove_string = ce_buffer_dupe_string(buffer, point, remove_len);
     if(!ce_buffer_remove_string(buffer, point, remove_len)){
          free(remove_string);
          return false;
     }

     CeBufferChange_t change = {};
     change.chain = chain_undo;
     change.insertion = false;
     change.string = remove_string;
     change.location = point;
     change.cursor_before = *cursor_before;
     change.cursor_after = cursor_after;
     ce_buffer_change(buffer, &change);

     *cursor_before = cursor_after;
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %r9b, %al
leaq 0x10(%rbp), %r9
movq %r9, -0x88(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x10900
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x10190
testb $0x1, %al
jne 0x11116
movq -0x40(%rbp), %rdi
callq 0xd090
movb $0x0, -0x1(%rbp)
jmp 0x1119e
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0xd290
movq -0x88(%rbp), %rax
movb -0x31(%rbp), %cl
andb $0x1, %cl
movb %cl, -0x80(%rbp)
movb $0x0, -0x7f(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq -0x30(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
movq 0x8(%rcx), %rcx
movq %rcx, -0x58(%rbp)
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x10e90
movq -0x88(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_undo
bool ce_buffer_undo(CeBuffer_t* buffer, CePoint_t* cursor){
     // nothing to undo
     if(!buffer->change_node) return true;
     if(!buffer->change_node->prev) return true;

     CeBufferChange_t* change = &buffer->change_node->change;
     if(change->insertion){
          ce_buffer_remove_string(buffer, change->location, ce_utf8_strlen(change->string));
     }else{
          ce_buffer_insert_string(buffer, change->string, change->location);
     }

     *cursor = change->cursor_before;
     buffer->change_node = buffer->change_node->prev;

     bool success = true;
     if(change->chain) success = ce_buffer_undo(buffer, cursor);

     if(buffer->status == CE_BUFFER_STATUS_MODIFIED && buffer->change_node == buffer->save_at_change_node){
          buffer->status = CE_BUFFER_STATUS_NONE;
     }

     return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x111d4
movb $0x1, -0x1(%rbp)
jmp 0x112cf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x48(%rax)
jne 0x111ec
movb $0x1, -0x1(%rbp)
jmp 0x112cf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x11239
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xea70
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x10190
jmp 0x11256
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0xda70
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, (%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movb $0x1, -0x21(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0x112a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x111b0
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x112c7
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x112c7
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_redo
bool ce_buffer_redo(CeBuffer_t* buffer, CePoint_t* cursor){
     // nothing to redo
     if(!buffer->change_node) return false;
     if(!buffer->change_node->next) return false;

     buffer->change_node = buffer->change_node->next;

     CeBufferChange_t* change = &buffer->change_node->change;
     if(change->insertion){
          ce_buffer_insert_string(buffer, change->string, change->location);
     }else{
          ce_buffer_remove_string(buffer, change->location, ce_utf8_strlen(change->string));
     }

     *cursor = change->cursor_after;

     if(buffer->change_node->next && buffer->change_node->next->change.chain) return ce_buffer_redo(buffer, cursor);

     if(buffer->status == CE_BUFFER_STATUS_MODIFIED && buffer->change_node == buffer->save_at_change_node){
          buffer->status = CE_BUFFER_STATUS_NONE;
     }

     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x11304
movb $0x0, -0x1(%rbp)
jmp 0x11410
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x40(%rax)
jne 0x1131c
movb $0x0, -0x1(%rbp)
jmp 0x11410
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x11365
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0xda70
jmp 0x1139a
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xea70
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x10190
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, (%rax)
movq 0x38(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x40(%rax)
je 0x113e5
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
testb $0x1, (%rax)
je 0x113e5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x112e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11410
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x1140c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x1140c
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_move_point_based_on_buffer_changes
CePoint_t ce_move_point_based_on_buffer_changes(CeBuffer_t* buffer, CeBufferChangeNode_t* before, CePoint_t point){
     CeBufferChangeNode_t* itr = buffer->change_node;
     while(itr && itr != before){
          point = move_point_based_on_buffer_change(buffer, itr, point);
          itr = itr->prev;
     }
     return point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x49(%rbp)
je 0x1145e
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x11467
jmp 0x114a2
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x114c0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x11444
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_buffer_status_get_str
const char* ce_buffer_status_get_str(CeBufferStatus_t status){
     if(status == CE_BUFFER_STATUS_READONLY){
          return "[RO]";
     }

     if(status == CE_BUFFER_STATUS_MODIFIED ||
        status == CE_BUFFER_STATUS_NEW_FILE){
          return "*";
     }

     return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x1166a
leaq 0x31058(%rip), %rax     # 0x426bc
movq %rax, -0x8(%rbp)
jmp 0x1168e
cmpl $0x1, -0xc(%rbp)
je 0x11676
cmpl $0x3, -0xc(%rbp)
jne 0x11683
leaq 0x337ec(%rip), %rax     # 0x44e69
movq %rax, -0x8(%rbp)
jmp 0x1168e
leaq 0x3281f(%rip), %rax     # 0x43ea9
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.c
// Function: ce_utf8_strlen_between
int64_t ce_utf8_strlen_between(const char* start, const char* end){
     int64_t len = 0;
     int64_t byte_count = 0;

     while(start <= end){
          if((*start & 0x80) == 0){
               byte_count = 1;
          }else if((*start & 0xE0) == 0xC0){
               byte_count = 2;
          }else if((*start & 0xF0) == 0xE0){
               byte_count = 3;
          }else if((*start & 0xF8) == 0xF0){
               byte_count = 4;
          }else{
               assert(!"unicode character claiming it has more than 4 bytes?!");
               return -1;
          }

          // validate string doesn't early terminate
          for(int64_t i = 0; i < byte_count; i++){
               if(*start == 0) return -1;
               start++;
          }

          len++;
     }

     return len;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x11b38
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x11a69
movq $0x1, -0x28(%rbp)
jmp 0x11ae5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x11a86
movq $0x2, -0x28(%rbp)
jmp 0x11ae3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x11aa3
movq $0x3, -0x28(%rbp)
jmp 0x11ae1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x11ac0
movq $0x4, -0x28(%rbp)
jmp 0x11adf
leaq 0x30bfa(%rip), %rdi     # 0x426c1
leaq 0x30b46(%rip), %rsi     # 0x42614
movl $0x54f, %edx            # imm = 0x54F
leaq 0x30c45(%rip), %rcx     # 0x4271f
callq 0xd270
jmp 0x11ae1
jmp 0x11ae3
jmp 0x11ae5
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x11b27
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x11b0d
movq $-0x1, -0x8(%rbp)
jmp 0x11b40
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11aed
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11a40
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_utf8_decode_reverse
CeRune_t ce_utf8_decode_reverse(const char* string, const char* string_start, int64_t* bytes_consumed){
     if((*string & 0x80) == 0){
          *bytes_consumed = 1;
          return string[0];
     }

     while(string >= string_start){
          if((*string & 0x80) == 0x80){
               string--;
          }else{
               return ce_utf8_decode(string, bytes_consumed);
          }
     }

     return CE_UTF8_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x11cbc
movq -0x20(%rbp), %rax
movq $0x1, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x11d04
jmp 0x11cbe
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x11cfd
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x80, %eax
jne 0x11ce9
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11cfb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xedc0
movl %eax, -0x4(%rbp)
jmp 0x11d04
jmp 0x11cbe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_utf8_rune_len
int64_t ce_utf8_rune_len(CeRune_t u){
     // TODO: optimize based on st's bitmasking
     if(u < 0x80){
          return 1;
     }else if(u < 0x0800){
          return 2;
     }else if(u < 0x10000){
          return 3;
     }else if(u < 0x110000){
          return 4;
     }

     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x11d2a
movq $0x1, -0x8(%rbp)
jmp 0x11d71
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jge 0x11d3d
movq $0x2, -0x8(%rbp)
jmp 0x11d71
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0x11d50
movq $0x3, -0x8(%rbp)
jmp 0x11d71
cmpl $0x110000, -0xc(%rbp)   # imm = 0x110000
jge 0x11d63
movq $0x4, -0x8(%rbp)
jmp 0x11d71
jmp 0x11d65
jmp 0x11d67
jmp 0x11d69
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_rune_node_insert
bool ce_rune_node_insert(CeRuneNode_t** head, CeRune_t rune){
     CeRuneNode_t* node = malloc(sizeof(*node));
     if(!node) return false;

     // always insert at head
     node->rune = rune;
     node->next = *head;
     *head = node;

     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x10, %edi
callq 0xd4a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11e1a
movb $0x0, -0x1(%rbp)
jmp 0x11e41
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_rune_node_string
CeRune_t* ce_rune_node_string(CeRuneNode_t* head){
     // count nodes
     CeRuneNode_t* itr = head;
     int64_t len = 0;
     while(itr){
          itr = itr->next;
          len++;
     }

     CeRune_t* runes = malloc((len + 1) * sizeof(*runes));

     // copy into string
     int64_t save_len = len;
     itr = head;
     while(itr){
          runes[len - 1] = itr->rune;
          itr = itr->next;
          len--;
     }

     // null terminate
     runes[save_len] = 0;
     return runes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11e8d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11e6c
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x2, %rdi
callq 0xd4a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11ee8
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11eb2
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_rune_node_free
void ce_rune_node_free(CeRuneNode_t** head){
     CeRuneNode_t* itr = *head;
     while(itr){
          CeRuneNode_t* tmp = itr;
          itr = itr->next;
          free(tmp);
     }

     *head = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11f4d
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd090
jmp 0x11f27
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_range_sort
bool ce_range_sort(CeRange_t* range){
     if(ce_point_after(range->start, range->end)){
          CePoint_t tmp = range->start;
          range->start = range->end;
          range->end = tmp;
          return true;
     }

     return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rcx), %rdi
movq 0x8(%rcx), %rsi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0xf690
testb $0x1, %al
jne 0x1286e
jmp 0x128b2
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x128b6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_count_digits
int64_t ce_count_digits(int64_t n){
     if(n < 0) n = -n;
     if(n == 0) return 1;

     int count = 0;
     while(n > 0){
          n /= 10;
          count++;
     }

     return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x128e9
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x128fa
movq $0x1, -0x8(%rbp)
jmp 0x1292d
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jle 0x12925
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12901
movslq -0x14(%rbp), %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.c
// Function: ce_line_number_column_width
int64_t ce_line_number_column_width(CeLineNumber_t line_number, int64_t buffer_line_count, int64_t view_top, int64_t view_bottom){
     if(buffer_line_count == 0) return 0;

     int64_t column_width = 0;

     if(line_number == CE_LINE_NUMBER_ABSOLUTE || line_number == CE_LINE_NUMBER_ABSOLUTE_AND_RELATIVE){
          column_width += ce_count_digits(buffer_line_count) + 1;
     }else if(line_number == CE_LINE_NUMBER_RELATIVE){
          int64_t view_height = (view_bottom - view_top) + 1;
          if(view_height > buffer_line_count){
               column_width += ce_count_digits(buffer_line_count - 1) + 1;
          }else{
               column_width += ce_count_digits(view_height - 1) + 1;
          }
     }

     return column_width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1296b
movq $0x0, -0x8(%rbp)
jmp 0x129f6
movq $0x0, -0x30(%rbp)
cmpl $0x1, -0xc(%rbp)
je 0x1297f
cmpl $0x3, -0xc(%rbp)
jne 0x12996
movq -0x18(%rbp), %rdi
callq 0x128d0
addq $0x1, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x129ee
cmpl $0x2, -0xc(%rbp)
jne 0x129ec
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x129d1
movq -0x18(%rbp), %rdi
subq $0x1, %rdi
callq 0x128d0
addq $0x1, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x129ea
movq -0x38(%rbp), %rdi
subq $0x1, %rdi
callq 0x128d0
addq $0x1, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x129ec
jmp 0x129ee
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_list_dir
CeListDirResult_t ce_list_dir(const char* directory) {
     CeListDirResult_t result;
     memset(&result, 0, sizeof(result));

#if defined(PLATFORM_WINDOWS)
     WIN32_FIND_DATA find_files_result;
     memset(&find_files_result, 0, sizeof(find_files_result));

     HANDLE find_files_handle = FindFirstFileA(directory,
                                               &find_files_result);
     if (find_files_handle == INVALID_HANDLE_VALUE) {
          return result;
     }

     do{
         insert_list_dir_result_filename(&result,
                                         find_files_result.cFileName,
                                         find_files_result.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
     }while(FindNextFileA(find_files_handle, &find_files_result));

     FindClose(find_files_handle);
#else
     DIR* os_dir = opendir(directory);
     if(!os_dir){
          return result;
     }

     struct dirent* node = NULL;
     while((node = readdir(os_dir)) != NULL){
          insert_list_dir_result_filename(&result,
                                          node->d_name,
                                          node->d_type == DT_DIR);
     }

     closedir(os_dir);
#endif

     return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0xd290
movq -0x8(%rbp), %rdi
callq 0xd1f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12a89
jmp 0x12ad4
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd450
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x12acb
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x13, %rsi
movq -0x18(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x12ae0
jmp 0x12a91
movq -0x10(%rbp), %rdi
callq 0xd2f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: insert_list_dir_result_filename
static void insert_list_dir_result_filename(CeListDirResult_t* list_dir_result,
                                            const char* filename,
                                            bool is_directory) {
      int64_t new_count = list_dir_result->count + 1;

      list_dir_result->filenames = realloc(list_dir_result->filenames,
                                           new_count * sizeof(*list_dir_result->filenames));
      list_dir_result->filenames[list_dir_result->count] = strdup(filename);

      list_dir_result->is_directories = realloc(list_dir_result->is_directories,
                                                new_count * sizeof(*list_dir_result->is_directories));
      list_dir_result->is_directories[list_dir_result->count] = is_directory;

      list_dir_result->count = new_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0xd500
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0xd620
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x0, %rsi
callq 0xd500
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce.c
// Function: ce_free_list_dir_result
void ce_free_list_dir_result(CeListDirResult_t* list_dir_result) {
     for(int64_t i = 0; i < list_dir_result->count; i++){
          free(list_dir_result->filenames[i]);
     }
     free(list_dir_result->filenames);
     free(list_dir_result->is_directories);
     memset(list_dir_result, 0, sizeof(*list_dir_result));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x12bd4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xd090
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x12ba4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0xd290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_buffer_node_insert
bool ce_buffer_node_insert(CeBufferNode_t** head, CeBuffer_t* buffer){
     CeBufferNode_t* node = malloc(sizeof(*node));
     if(!node) return false;
     node->buffer = buffer;
     node->next = *head;
     *head = node;
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x10, %edi
callq 0xd4a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12c3b
movb $0x0, -0x1(%rbp)
jmp 0x12c64
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_buffer_node_unlink
CeBufferNode_t* ce_buffer_node_unlink(CeBufferNode_t** head, CeBuffer_t* buffer){
     CeBufferNode_t* prev = NULL;
     CeBufferNode_t* itr = *head;
     while(itr){
          if(itr->buffer == buffer) break;
          prev = itr;
          itr = itr->next;
     }

     if(!itr) return NULL;

     if(prev){
          prev->next = itr->next;
     }else{
          *head = (*head)->next;
     }

     return itr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12cbb
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x12ca5
jmp 0x12cbb
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12c8f
cmpq $0x0, -0x28(%rbp)
jne 0x12ccc
movq $0x0, -0x8(%rbp)
jmp 0x12cff
cmpq $0x0, -0x20(%rbp)
je 0x12ce5
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x12cf7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %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: free_buffer_node
static void free_buffer_node(CeBufferNode_t* node){
     CeAppBufferData_t* buffer_data = node->buffer->app_data;
     if(buffer_data) free(buffer_data->base_directory);
     free(node->buffer->app_data);
     ce_buffer_free(node->buffer);
     free(node->buffer);
     free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12d82
movq -0x10(%rbp), %rax
movq 0x608(%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xe160
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rdi
callq 0xd090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_buffer_node_free
void ce_buffer_node_free(CeBufferNode_t** head){
     CeBufferNode_t* itr = *head;
     while(itr){
          CeBufferNode_t* tmp = itr;
          itr = itr->next;
          free_buffer_node(tmp);
     }
     *head = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12dfd
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12d50
jmp 0x12dd7
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_string_node_insert
CeStringNode_t* ce_string_node_insert(CeStringNode_t** head, const char* string){
     CeStringNode_t* tail = *head;
     CeStringNode_t* node;
     if(tail){
          while(tail->next) tail = tail->next;

          // NOTE: we probably don't want this if we want the linked list to be general
          // skip the insertion if the string matches the previous string
          if(strcmp(string, tail->string) == 0) return NULL;

          node = calloc(1, sizeof(*node));
          if(!node) return node;
          node->string = strdup(string);

          tail->next = node;
          node->prev = tail;
     }else{
          node = calloc(1, sizeof(*node));
          if(!node) return node;
          node->string = strdup(string);

          *head = node;
     }

     return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12ec4
jmp 0x12e38
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x12e51
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12e38
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0xd370
cmpl $0x0, %eax
jne 0x12e73
movq $0x0, -0x8(%rbp)
jmp 0x12f0e
movl $0x1, %edi
movl $0x18, %esi
callq 0xd360
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12e97
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12f0e
movq -0x18(%rbp), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x12f06
movl $0x1, %edi
movl $0x18, %esi
callq 0xd360
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12ee8
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12f0e
movq -0x18(%rbp), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_string_node_free
void ce_string_node_free(CeStringNode_t** head){
     CeStringNode_t* itr = *head;
     while(itr){
          CeStringNode_t* tmp = itr;
          itr = itr->next;
          free(tmp->string);
          free(tmp);
     }

     *head = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12f69
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xd090
movq -0x18(%rbp), %rdi
callq 0xd090
jmp 0x12f37
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_history_insert
bool ce_history_insert(CeHistory_t* history, const char* string){
     CeStringNode_t* new_node = ce_string_node_insert(&history->head, string);
     if(!new_node) return false;
     ce_history_reset_current(history);
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12e10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12fae
movb $0x0, -0x1(%rbp)
jmp 0x12fbb
movq -0x10(%rbp), %rdi
callq 0x12fd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_history_previous
char* ce_history_previous(CeHistory_t* history){
     if(history->current){
          if(history->current->prev){
               history->current = history->current->prev;
          }

          return history->current->string;
     }else{
          history->current = history->head;
          if(history->current){
               while(history->current->next) history->current = history->current->next;
               return history->current->string;
          }
     }

     return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13037
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x13026
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13093
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13089
jmp 0x13053
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x13078
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x13053
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13093
jmp 0x1308b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_history_next
char* ce_history_next(CeHistory_t* history){
     if(history->current){
          history->current = history->current->next;
          if(history->current) return history->current->string;
     }

     return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x130e5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x130e3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x130ed
jmp 0x130e5
movq $0x0, -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_set_vim_key_bind
void ce_set_vim_key_bind(CeVimKeyBind_t* key_binds, int64_t* key_bind_count, CeRune_t key, CeVimParseFunc_t* parse_func){
     for(int64_t i = 0; i < *key_bind_count; ++i){
          CeVimKeyBind_t* key_bind = key_binds + i;
          if(key_bind->key == key){
               key_bind->function = parse_func;
               return;
          }
     }

     // we didn't find the key to override it, so we add the binding
     ce_vim_add_key_bind(key_binds, key_bind_count, key, parse_func);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x133e8
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x133d8
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x133fc
jmp 0x133da
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1339f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x2fd40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_app.c
// Function: ce_extend_commands
void ce_extend_commands(CeCommandEntry_t** command_entries, int64_t* command_entry_count, CeCommandEntry_t* new_command_entries,
                        int64_t new_command_entry_count){
     int64_t final_command_entry_count = *command_entry_count + new_command_entry_count;
     *command_entries = realloc(*command_entries, final_command_entry_count * sizeof(**command_entries));
     for(int64_t i = 0; i < new_command_entry_count; i++){
          (*command_entries)[i + *command_entry_count] = new_command_entries[i];
     }
     *command_entry_count = final_command_entry_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0x18, -0x28(%rbp), %rsi
callq 0xd500
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x134ad
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
addq (%rdx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
imulq $0x18, -0x30(%rbp), %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1345a
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop