LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: replace_all
void replace_all(CeView_t* view, CeVimVisualSave_t* vim_visual_save, const char* match, const char* replace){
     CePoint_t start;
     CePoint_t end;
     if(vim_visual_save->mode == CE_VIM_MODE_VISUAL){
          if(ce_point_after(view->cursor, vim_visual_save->visual_point)){
               start = vim_visual_save->visual_point;
               end = view->cursor;
          }else{
               start = view->cursor;
               end = vim_visual_save->visual_point;
          }
     }else if(vim_visual_save->mode == CE_VIM_MODE_VISUAL_LINE){
          if(ce_point_after(view->cursor, vim_visual_save->visual_point)){
               start = (CePoint_t){0, vim_visual_save->visual_point.y};
               end = (CePoint_t){ce_utf8_last_index(view->buffer->lines[view->cursor.y]), view->cursor.y};
          }else{
               start = (CePoint_t){0, view->cursor.y};
               end = (CePoint_t){ce_utf8_last_index(view->buffer->lines[vim_visual_save->visual_point.y]), vim_visual_save->visual_point.y};
          }
     }else{
          start = view->cursor;
          end = ce_buffer_end_point(view->buffer);
     }

     if(ce_point_after(end, start)){
          buffer_replace_all(view->buffer, view->cursor, match, replace, start, end, false);
     }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl (%rsi), %eax
cmpl $0x3, %eax
je 0x17881
leaq 0x30(%r15), %r13
cmpl $0x2, %eax
jne 0x178c6
leaq 0x8(%r12), %rbp
movq 0x30(%r15), %rdi
movq 0x38(%r15), %rsi
movq 0x8(%r12), %rdx
movq 0x10(%r12), %rcx
callq 0xea69
testb %al, %al
je 0x178e5
movups (%rbp), %xmm0
movaps %xmm0, 0x30(%rsp)
movups (%r13), %xmm0
jmp 0x178f3
movq 0x30(%r15), %rdi
movq 0x38(%r15), %rsi
movq 0x8(%r12), %rdx
movq 0x10(%r12), %rcx
callq 0xea69
testb %al, %al
je 0x178fa
movq 0x10(%r12), %rax
andq $0x0, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rdi
callq 0xe784
movq 0x38(%r15), %rcx
jmp 0x17923
movups (%r13), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x40(%r15), %rdi
callq 0xd9cc
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
jmp 0x1792d
movups (%r13), %xmm0
movaps %xmm0, 0x30(%rsp)
movups (%rbp), %xmm0
movaps %xmm0, 0x20(%rsp)
jmp 0x1792d
movq 0x38(%r15), %rax
andq $0x0, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq 0x40(%r15), %rax
movq (%rax), %rax
movq 0x10(%r12), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe784
movq 0x10(%r12), %rcx
movq %rax, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0xea69
testb %al, %al
je 0x17977
movq 0x40(%r15), %rdi
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rcx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x1852c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_reload_file
CeCommandStatus_t command_reload_file(CeCommand_t* command, void* user_data){
     if(command->arg_count != 0) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = user_data;
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     bool file_backed = false;

#if defined(PLATFORM_WINDOWS)
     file_backed = (_access(command_context.view->buffer->name, 0) == 0);
#else
     file_backed = (access(command_context.view->buffer->name, F_OK) == 0);
#endif

     if(!file_backed){
          ce_app_message(app, "buffer '%s' is not file backed, unable to reload\n", command_context.view->buffer->name);
          return CE_COMMAND_NO_ACTION;
     }

     char* filename = strdup(command_context.view->buffer->name);
     CeAppBufferData_t* buffer_data = command_context.view->buffer->app_data;
     ce_buffer_free(command_context.view->buffer);
     command_context.view->buffer->app_data = buffer_data; // NOTE: not great that I need to save user data and reset it
     ce_buffer_load_file(command_context.view->buffer, filename);
     free(filename);

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x208(%rdi)
je 0x179a3
pushq $0x2
popq %rbx
jmp 0x17a25
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r14, %rdi
callq 0x15be9
pushq $0x3
popq %rbx
testb %al, %al
je 0x17a25
movq 0x8(%rsp), %r12
movq 0x40(%r12), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0xd5a0
movq 0x40(%r12), %r15
movq 0x10(%r15), %rdx
testl %eax, %eax
je 0x179f3
leaq 0x14a86(%rip), %rsi     # 0x2c46d
movq %r14, %rdi
xorl %eax, %eax
callq 0x11b97
jmp 0x17a25
movq %rdx, %rdi
callq 0xd640
movq %rax, %rbx
movq 0x58(%r15), %r14
movq %r15, %rdi
callq 0xde1c
movq 0x40(%r12), %rdi
movq %r14, 0x58(%rdi)
movq %rbx, %rsi
callq 0xdec5
movq %rbx, %rdi
callq 0xd090
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_reload_config
CeCommandStatus_t command_reload_config(CeCommand_t* command, void* user_data){
     if(command->arg_count != 0) return CE_COMMAND_PRINT_HELP;
     CeApp_t* app = user_data;
#if defined(PLATFORM_WINDOWS)
     if(app->user_config.library_instance == NULL) return CE_COMMAND_NO_ACTION;
#else
     if(!app->user_config.handle) return CE_COMMAND_NO_ACTION;
#endif

     if(app->command_entries) free(app->command_entries);
     ce_app_init_default_commands(app);
     char* config_path = strdup(app->user_config.filepath);
     user_config_free(&app->user_config);
     if(user_config_init(&app->user_config, config_path)){
          app->user_config.init_func(app);
     }else{
          ce_app_message(app, "failed to reload config: '%s', see log for details", config_path);
          return CE_COMMAND_FAILURE;
     }
     free(config_path);
     return CE_COMMAND_SUCCESS;
}

// Assembly:
cmpq $0x0, 0x208(%rdi)
je 0x17a41
pushq $0x2
popq %rax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0x2c80(%rsi)
je 0x17aa9
leaq 0x2c80(%rbx), %r15
movq 0x2830(%rbx), %rdi
callq 0xd090
movq %rbx, %rdi
callq 0x11a67
movq 0x2c88(%rbx), %rdi
callq 0xd640
movq %rax, %r14
movq %r15, %rdi
callq 0x119d6
movq %r15, %rdi
movq %r14, %rsi
callq 0x1191b
testb %al, %al
je 0x17aad
movq %rbx, %rdi
callq *0x2c90(%rbx)
movq %r14, %rdi
callq 0xd090
xorl %eax, %eax
jmp 0x17ac4
pushq $0x3
jmp 0x17ac3
leaq 0x149eb(%rip), %rsi     # 0x2c49f
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11b97
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_new_buffer
CeCommandStatus_t command_new_buffer(CeCommand_t* command, void* user_data){
     if(command->arg_count > 1) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = user_data;
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     const char* buffer_name = "unnamed";
     if(command->arg_count == 1 && command->args[0].type == CE_COMMAND_ARG_STRING) buffer_name = command->args[0].string;

     CeBuffer_t* buffer = new_buffer();
     ce_buffer_alloc(buffer, 1, buffer_name);
     command_context.view->buffer = buffer;
     command_context.view->cursor = (CePoint_t){0, 0};
     ce_buffer_node_insert(&app->buffer_node_head, buffer);

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x208(%rdi), %r12
cmpq $0x1, %r12
jle 0x17c4d
pushq $0x2
jmp 0x17cc5
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x17cc3
leaq 0x14879(%rip), %r14     # 0x2c4e8
cmpq $0x1, %r12
jne 0x17c85
movq 0x200(%r15), %rax
cmpl $0x2, (%rax)
jne 0x17c85
movq 0x8(%rax), %r14
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1129e
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0xdd58
movq 0x8(%rsp), %rax
movq %r15, 0x40(%rax)
addq $0x2828, %rbx           # imm = 0x2828
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x103e0
jmp 0x17cc6
pushq $0x3
popq %rbp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_rename_buffer
CeCommandStatus_t command_rename_buffer(CeCommand_t* command, void* user_data){
     if(command->arg_count != 1) return CE_COMMAND_PRINT_HELP;
     if(command->args[0].type != CE_COMMAND_ARG_STRING) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = user_data;
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     free(command_context.view->buffer->name);
     command_context.view->buffer->name = strdup(command->args[0].string);
     if(command_context.view->buffer->status == CE_BUFFER_STATUS_NONE) command_context.view->buffer->status = CE_BUFFER_STATUS_MODIFIED;

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq $0x2
popq %rax
cmpq $0x1, 0x208(%rdi)
jne 0x17d55
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x200(%rdi), %rcx
cmpl $0x2, (%rcx)
jne 0x17d4e
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x15be9
testb %al, %al
je 0x17d4b
movq 0x8(%rsp), %r14
movq 0x40(%r14), %rax
movq 0x10(%rax), %rdi
callq 0xd090
movq 0x200(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xd640
movq 0x40(%r14), %rcx
movq %rax, 0x10(%rcx)
xorl %eax, %eax
cmpl $0x0, 0x18(%rcx)
jne 0x17d4e
movl $0x1, 0x18(%rcx)
jmp 0x17d4e
pushq $0x3
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_line_number
CeCommandStatus_t command_line_number(CeCommand_t* command, void* user_data){
     if(command->arg_count != 1) return CE_COMMAND_PRINT_HELP;
     if(command->args[0].type != CE_COMMAND_ARG_STRING) return CE_COMMAND_PRINT_HELP;
     CeApp_t* app = user_data;
     if(strcmp(command->args[0].string, "none") == 0){
          app->config_options.line_number = CE_LINE_NUMBER_NONE;
     }else if(strcmp(command->args[0].string, "absolute") == 0){
          app->config_options.line_number = CE_LINE_NUMBER_ABSOLUTE;
     }else if(strcmp(command->args[0].string, "relative") == 0){
          app->config_options.line_number = CE_LINE_NUMBER_RELATIVE;
     }else if(strcmp(command->args[0].string, "both") == 0){
          app->config_options.line_number = CE_LINE_NUMBER_ABSOLUTE_AND_RELATIVE;
     }else{
          return CE_COMMAND_PRINT_HELP;
     }

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
pushq $0x2
popq %rbp
cmpq $0x1, 0x208(%rdi)
jne 0x18007
movq 0x200(%rdi), %rax
cmpl $0x2, (%rax)
jne 0x18007
movq %rsi, %rbx
movq 0x8(%rax), %r14
leaq 0x1454b(%rip), %rsi     # 0x2c4f0
movq %r14, %rdi
callq 0xd390
xorl %ebp, %ebp
movl $0x0, %ecx
testl %eax, %eax
je 0x18001
leaq 0x14536(%rip), %rsi     # 0x2c4f5
movq %r14, %rdi
callq 0xd390
testl %eax, %eax
je 0x17ff6
leaq 0x13789(%rip), %rsi     # 0x2b75b
movq %r14, %rdi
callq 0xd390
testl %eax, %eax
je 0x17ffa
leaq 0x14519(%rip), %rsi     # 0x2c4fe
movq %r14, %rdi
callq 0xd390
testl %eax, %eax
je 0x17ffe
pushq $0x2
popq %rbp
jmp 0x18007
pushq $0x1
jmp 0x18000
pushq $0x2
jmp 0x18000
pushq $0x3
popq %rcx
movl %ecx, 0x1a50(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_man_page_on_word_under_cursor
CeCommandStatus_t command_man_page_on_word_under_cursor(CeCommand_t* command, void* user_data){
     if(command->arg_count != 0) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     CeRange_t range = ce_vim_find_little_word_boundaries(command_context.view->buffer, command_context.view->cursor); // returns -1
     char* word = ce_buffer_dupe_string(command_context.view->buffer, range.start, (range.end.x - range.start.x) + 1);
     if(!word) return CE_COMMAND_NO_ACTION;
     char cmd[128];
     snprintf(cmd, 128, "man %s", word);
     free(word);
     ce_app_run_shell_command(app, cmd, command_context.tab_layout, command_context.view, false);

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
cmpq $0x0, 0x208(%rdi)
je 0x1802e
pushq $0x2
jmp 0x180c7
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x180c5
movq 0x8(%rsp), %r14
movq 0x40(%r14), %rsi
movq 0x30(%r14), %rdx
movq 0x38(%r14), %rcx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x23f4a
movq 0x40(%r14), %rdi
movq 0x10(%r15), %rcx
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rcx
incq %rcx
callq 0xf361
testq %rax, %rax
je 0x180c5
movq %rax, %r15
leaq 0x14476(%rip), %rdx     # 0x2c503
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
movl $0x80, %esi
movq %r12, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xd260
movq %r15, %rdi
callq 0xd090
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x13bef
jmp 0x180c8
pushq $0x3
popq %rbp
movl %ebp, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_shell_command
CeCommandStatus_t command_shell_command(CeCommand_t* command, void* user_data){
     if(command->arg_count < 1) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     char* command_args = build_string_from_command_args(command);

     if(!ce_app_run_shell_command(app, command_args, command_context.tab_layout, command_context.view, false)){
          free(command_args);
          return CE_COMMAND_FAILURE;
     }

     free(command_args);
     return CE_COMMAND_SUCCESS;
}

// Assembly:
cmpq $0x0, 0x208(%rdi)
jle 0x1813a
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x1813e
movq %r14, %rdi
callq 0x18149
movq %rax, %r14
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x13bef
movl %eax, %ebx
movq %r14, %rdi
callq 0xd090
xorb $0x1, %bl
movzbl %bl, %eax
jmp 0x18141
pushq $0x2
popq %rax
retq
pushq $0x3
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: build_string_from_command_args
static char* build_string_from_command_args(CeCommand_t* command){
     char buffer[256];
     int64_t buffer_consumed = 0;

     char* result = NULL;
     for(int64_t i = 0; i < command->arg_count; i++){
          int rc = 0;

          switch(command->args[i].type){
          default:
              return result;
          case CE_COMMAND_ARG_INTEGER:
               rc = snprintf(buffer + buffer_consumed, 256 - buffer_consumed, "%" PRId64 " ", command->args[i].integer);
               break;
          case CE_COMMAND_ARG_DECIMAL:
               rc = snprintf(buffer + buffer_consumed, 256 - buffer_consumed, "%f ", command->args[i].decimal);
               break;
          case CE_COMMAND_ARG_STRING:
               rc = snprintf(buffer + buffer_consumed, 256 - buffer_consumed, "%s ", command->args[i].string);
               break;
          }

          if(rc < 0){
               ce_log("snprintf() failed: %s\n", strerror(errno));
               return result;
          }

          buffer_consumed += rc;
     }

     result = strdup(buffer);

     // strip off extra space at the end
     size_t len = strlen(result);
     if(len >= 1) result[len - 1] = 0;

     return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
pushq $0x8
popq %r13
leaq 0x14458(%rip), %r15     # 0x2c5c0
leaq 0x13ab3(%rip), %r12     # 0x2bc22
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpq 0x208(%rbx), %r14
jge 0x181f9
movq 0x200(%rbx), %rax
movl -0x8(%rax,%r13), %ecx
leaq (%rsp,%rbp), %rdi
cmpl $0x2, %ecx
je 0x181ca
cmpl $0x1, %ecx
je 0x181b0
testl %ecx, %ecx
jne 0x18239
movl $0x100, %esi            # imm = 0x100
subq %rbp, %rsi
movq (%rax,%r13), %rcx
movq %r12, %rdx
jmp 0x181dd
movl $0x100, %esi            # imm = 0x100
subq %rbp, %rsi
movsd (%rax,%r13), %xmm0
movq %r15, %rdx
movb $0x1, %al
callq 0xd260
jmp 0x181e4
movl $0x100, %esi            # imm = 0x100
subq %rbp, %rsi
movq (%rax,%r13), %rcx
leaq 0x1445f(%rip), %rdx     # 0x2c63c
xorl %eax, %eax
callq 0xd260
testl %eax, %eax
js 0x18218
movl %eax, %eax
addq %rax, %rbp
incq %r14
addq $0x10, %r13
jmp 0x18174
movq %rsp, %rdi
callq 0xd640
movq %rax, %rbx
movq %rax, %rdi
callq 0xd210
testq %rax, %rax
je 0x1823b
movb $0x0, -0x1(%rbx,%rax)
jmp 0x1823b
callq 0xd0a0
movl (%rax), %edi
callq 0xd650
leaq 0x14399(%rip), %rdi     # 0x2c5c4
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0xd8e5
jmp 0x1823b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_shell_command_relative
CeCommandStatus_t command_shell_command_relative(CeCommand_t* command, void* user_data){
     if(command->arg_count < 1) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;
#if defined(PLATFORM_WINDOWS)
     ce_app_message(app, "shell_command_relative not yet supported on windows. Please use shell_command.");
     return CE_COMMAND_FAILURE;
#else
     char* command_args = build_string_from_command_args(command);

     if(!ce_app_run_shell_command(app, command_args, command_context.tab_layout, command_context.view, true)){
          free(command_args);
          return CE_COMMAND_FAILURE;
     }

     free(command_args);
     return CE_COMMAND_SUCCESS;
#endif
}

// Assembly:
cmpq $0x0, 0x208(%rdi)
jle 0x182b1
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x182b5
movq %r14, %rdi
callq 0x18149
movq %rax, %r14
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13bef
movl %eax, %ebx
movq %r14, %rdi
callq 0xd090
xorb $0x1, %bl
movzbl %bl, %eax
jmp 0x182b8
pushq $0x2
popq %rax
retq
pushq $0x3
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_paste_clipboard
CeCommandStatus_t command_paste_clipboard(CeCommand_t* command, void* user_data) {
     if(command->arg_count >= 1) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};
     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     CePoint_t resulting_cursor = ce_paste_clipboard_into_buffer(command_context.view->buffer,
                                                                 command_context.view->cursor);
     if(resulting_cursor.x <= 0){
          return CE_COMMAND_FAILURE;
     }

     command_context.view->cursor = resulting_cursor;
     return CE_COMMAND_SUCCESS;
}

// Assembly:
cmpq $0x0, 0x208(%rdi)
jle 0x182ee
pushq $0x2
popq %rax
retq
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x15be9
testb %al, %al
je 0x18332
movq 0x8(%rsp), %rbx
movq 0x40(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
callq 0x143e8
testq %rax, %rax
jle 0x18336
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
xorl %eax, %eax
jmp 0x18339
pushq $0x3
jmp 0x18338
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_clang_goto_def
CeCommandStatus_t command_clang_goto_def(CeCommand_t* command, void* user_data){
     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};
     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     if(!ce_clangd_request_goto_def(&app->clangd,
                                    command_context.view->buffer,
                                    command_context.view->cursor)){
         return CE_COMMAND_FAILURE;
     }

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x18383
addq $0x2cd0, %rbx           # imm = 0x2CD0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rcx
movq %rbx, %rdi
callq 0x1532a
xorb $0x1, %al
movzbl %al, %eax
jmp 0x18386
pushq $0x3
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_clang_goto_decl
CeCommandStatus_t command_clang_goto_decl(CeCommand_t* command, void* user_data){
     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};
     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     if(!ce_clangd_request_goto_decl(&app->clangd,
                                     command_context.view->buffer,
                                     command_context.view->cursor)){
         return CE_COMMAND_FAILURE;
     }

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x183d0
addq $0x2cd0, %rbx           # imm = 0x2CD0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rcx
movq %rbx, %rdi
callq 0x15379
xorb $0x1, %al
movzbl %al, %eax
jmp 0x183d3
pushq $0x3
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_clang_goto_type_def
CeCommandStatus_t command_clang_goto_type_def(CeCommand_t* command, void* user_data){
     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};
     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     if(!ce_clangd_request_goto_type_def(&app->clangd,
                                         command_context.view->buffer,
                                         command_context.view->cursor)){
         return CE_COMMAND_FAILURE;
     }

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x1841d
addq $0x2cd0, %rbx           # imm = 0x2CD0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rcx
movq %rbx, %rdi
callq 0x15136
xorb $0x1, %al
movzbl %al, %eax
jmp 0x18420
pushq $0x3
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_clang_find_references
CeCommandStatus_t command_clang_find_references(CeCommand_t* command, void* user_data){
     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};
     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     if(!ce_clangd_request_find_references(&app->clangd,
                                           command_context.view->buffer,
                                           command_context.view->cursor)){
         return CE_COMMAND_FAILURE;
     }

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x1846a
addq $0x2cd0, %rbx           # imm = 0x2CD0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rcx
movq %rbx, %rdi
callq 0x15417
xorb $0x1, %al
movzbl %al, %eax
jmp 0x1846d
pushq $0x3
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_clang_format
CeCommandStatus_t command_clang_format(CeCommand_t* command, void* user_data){
     CeApp_t* app = (CeApp_t*)(user_data);
     CommandContext_t command_context = {};
     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;
     if(strlen(app->config_options.clang_format_path) == 0){
         ce_app_message(app, "clang format binary/executable path not configured");
         return CE_COMMAND_FAILURE;
     }
     // Skip attempting to format non c files.
     CeAppBufferData_t* buffer_data = command_context.view->buffer->app_data;
     if(buffer_data->syntax_function != ce_syntax_highlight_c &&
        buffer_data->syntax_function != ce_syntax_highlight_cpp){
         ce_app_message(app, "Attempted to clang format non c/c++ buffer");
         return CE_COMMAND_FAILURE;
     }
     if(app->vim.mode == CE_VIM_MODE_VISUAL ||
        app->vim.mode == CE_VIM_MODE_VISUAL_LINE ||
        app->vim.mode == CE_VIM_MODE_VISUAL_BLOCK){
         if(!ce_clang_format_selection(app->config_options.clang_format_path, command_context.view,
                                       app->vim.mode, &app->visual)){
             return CE_COMMAND_FAILURE;
         }
         app->vim.mode = CE_VIM_MODE_NORMAL;
     }else{
         if(!ce_clang_format_buffer(app->config_options.clang_format_path, command_context.view->buffer,
                                    command_context.view->cursor)){
             return CE_COMMAND_FAILURE;
         }
     }
     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x184ed
cmpb $0x0, 0x22f4(%rbx)
je 0x184f1
movq 0x8(%rsp), %rsi
movq 0x40(%rsi), %rax
movq 0x58(%rax), %rcx
movq 0x600(%rcx), %rcx
cmpq 0x20aac(%rip), %rcx     # 0x38f60
sete %dl
cmpq 0x20a9a(%rip), %rcx     # 0x38f58
sete %cl
orb %dl, %cl
je 0x184fa
leaq 0x22f4(%rbx), %rdi
movl 0x20(%rbx), %edx
leal -0x2(%rdx), %ecx
cmpl $0x2, %ecx
ja 0x18514
leaq 0x1a20(%rbx), %rcx
callq 0x14224
testb %al, %al
je 0x1850b
andl $0x0, 0x20(%rbx)
jmp 0x18528
pushq $0x3
jmp 0x1850d
leaq 0x14012(%rip), %rsi     # 0x2c50a
jmp 0x18501
leaq 0x1403c(%rip), %rsi     # 0x2c53d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11b97
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
movq 0x30(%rsi), %rdx
movq 0x38(%rsi), %rcx
movq %rax, %rsi
callq 0x1414f
testb %al, %al
je 0x1850b
xorl %eax, %eax
jmp 0x1850e
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_vim_e
CeCommandStatus_t command_vim_e(CeCommand_t* command, void* user_data){
     if(command->arg_count != 1) return CE_COMMAND_PRINT_HELP;
     if(command->args[0].type != CE_COMMAND_ARG_STRING) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = user_data;
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     if(load_file_into_view(&app->buffer_node_head, command_context.view, &app->config_options, &app->vim,
                         true, command->args[0].string)){
          ce_clangd_file_open(&app->clangd, app->buffer_node_head->buffer);
     }else{
          return CE_COMMAND_FAILURE;
     }

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x2
popq %rbp
cmpq $0x1, 0x208(%rdi)
jne 0x1875f
movq 0x200(%rdi), %r14
cmpl $0x2, (%r14)
jne 0x1875f
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x1875c
leaq 0x2828(%rbx), %rdi
movq 0x8(%rsp), %rsi
leaq 0x1a50(%rbx), %rdx
leaq 0x20(%rbx), %rcx
movq 0x8(%r14), %r9
pushq $0x1
popq %rbp
movl %ebp, %r8d
callq 0x10fbd
testq %rax, %rax
je 0x1875f
movq 0x2828(%rbx), %rax
addq $0x2cd0, %rbx           # imm = 0x2CD0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x14cd5
xorl %ebp, %ebp
jmp 0x1875f
pushq $0x3
popq %rbp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_vim_q
CeCommandStatus_t command_vim_q(CeCommand_t* command, void* user_data){
     if(command->arg_count != 0) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = user_data;
     if(app->tab_list_layout->tab_list.tab_count == 1 &&
        ce_layout_tab_get_layout_count(app->tab_list_layout->tab_list.current) == 1){
          return command_quit(command, user_data);
     }

     if(!delete_layout(user_data)) return CE_COMMAND_FAILURE;

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x208(%rdi)
je 0x18782
pushq $0x2
popq %rax
jmp 0x187c4
movq %rsi, %rbx
movq 0x2818(%rsi), %rax
cmpq $0x1, 0x18(%rax)
jne 0x187b7
movq %rdi, %r14
movq 0x10(%rax), %rdi
callq 0x1d50a
cmpq $0x1, %rax
jne 0x187b7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15b4b
movq %rbx, %rdi
callq 0x1631a
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_vim_q_exclam
CeCommandStatus_t command_vim_q_exclam(CeCommand_t* command, void* user_data){
     if(command->arg_count != 0) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = user_data;
     if(app->tab_list_layout->tab_list.tab_count == 1 &&
        ce_layout_tab_get_layout_count(app->tab_list_layout->tab_list.current) == 1){
          app->quit = true;
          return command_quit(command, user_data);
     }

     if(!delete_layout(user_data)) return CE_COMMAND_FAILURE;

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x208(%rdi)
je 0x187df
pushq $0x2
popq %rax
jmp 0x18828
movq %rsi, %rbx
movq 0x2818(%rsi), %rax
cmpq $0x1, 0x18(%rax)
jne 0x1881b
movq %rdi, %r14
movq 0x10(%rax), %rdi
callq 0x1d50a
cmpq $0x1, %rax
jne 0x1881b
movb $0x1, 0x2c78(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15b4b
movq %rbx, %rdi
callq 0x1631a
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_vim_wq
CeCommandStatus_t command_vim_wq(CeCommand_t* command, void* user_data){
     if(command->arg_count != 0) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = user_data;
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     try_save_buffer(app, command_context.view->buffer);

     if(app->tab_list_layout->tab_list.tab_count == 1 &&
        ce_layout_tab_get_layout_count(app->tab_list_layout->tab_list.current) == 1){
          return command_quit(command, user_data);
     }

     if(!delete_layout(user_data)) return CE_COMMAND_FAILURE;
     return CE_COMMAND_SUCCESS;
}

// Assembly:
cmpq $0x0, 0x208(%rdi)
je 0x18856
pushq $0x2
popq %rax
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x188b3
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rsi
movq %rbx, %rdi
callq 0x15ebf
movq 0x2818(%rbx), %rax
cmpq $0x1, 0x18(%rax)
jne 0x188b8
movq 0x10(%rax), %rdi
callq 0x1d50a
cmpq $0x1, %rax
jne 0x188b8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15b4b
jmp 0x188c5
pushq $0x3
popq %rax
jmp 0x188c5
movq %rbx, %rdi
callq 0x1631a
xorb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_vim_make
CeCommandStatus_t command_vim_make(CeCommand_t* command, void* user_data){
     CeApp_t* app = user_data;

     if(command->arg_count == 0){
          CommandContext_t command_context = {};
          if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;
          ce_app_run_shell_command(app, "make", command_context.tab_layout, command_context.view, false);
     }else if(command->arg_count == 1 &&
              command->args[0].type == CE_COMMAND_ARG_STRING){
          CommandContext_t command_context = {};
          if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;
          char command_string[256];
          snprintf(command_string, 256, "make %s", command->args[0].string);
          ce_app_run_shell_command(app, command_string, command_context.tab_layout, command_context.view, false);
     }else{
          return CE_COMMAND_PRINT_HELP;
     }

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movq 0x208(%rdi), %rax
pushq $0x2
popq %rbp
cmpq $0x1, %rax
je 0x18ada
testq %rax, %rax
jne 0x18b39
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x18b36
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x12da1(%rip), %rsi     # 0x2b874
xorl %ebp, %ebp
movq %rbx, %rdi
jmp 0x18b2c
movq 0x200(%rdi), %r14
cmpl $0x2, (%r14)
jne 0x18b39
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x18b36
movq 0x8(%r14), %rcx
leaq 0x13a7e(%rip), %rdx     # 0x2c585
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0xd260
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x13bef
jmp 0x18b39
pushq $0x3
popq %rbp
movl %ebp, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_commands.c
// Function: command_vim_find
CeCommandStatus_t command_vim_find(CeCommand_t* command, void* user_data){
     if(command->arg_count != 1) return CE_COMMAND_PRINT_HELP;
     if(command->args[0].type != CE_COMMAND_ARG_STRING) return CE_COMMAND_PRINT_HELP;

     CeApp_t* app = user_data;
     CommandContext_t command_context = {};

     if(!get_command_context(app, &command_context)) return CE_COMMAND_NO_ACTION;

     char* base_directory = buffer_base_directory(command_context.view->buffer);
     if(!base_directory) base_directory = strdup(CE_CURRENT_DIR_SEARCH_STR);
     open_file_in_dir_recursively(base_directory, command->args[0].string, app, command_context.view);
     free(base_directory);

     return CE_COMMAND_SUCCESS;
}

// Assembly:
pushq $0x2
popq %rax
cmpq $0x1, 0x208(%rdi)
jne 0x18be2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x200(%rdi), %rcx
cmpl $0x2, (%rcx)
jne 0x18bd7
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x15be9
testb %al, %al
je 0x18bd4
movq 0x8(%rsp), %r15
movq 0x40(%r15), %rdi
callq 0x1132c
movq %rax, %r12
testq %rax, %rax
jne 0x18baf
leaq 0x116c3(%rip), %rdi     # 0x2a26a
callq 0xd640
movq %rax, %r12
movq 0x200(%r14), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x18be3
movq %r12, %rdi
callq 0xd090
xorl %eax, %eax
jmp 0x18bd7
pushq $0x3
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_complete.c
// Function: ce_complete_init
bool ce_complete_init(CeComplete_t* complete, const char** strings, const char** descriptions, int64_t string_count){
     ce_complete_free(complete);

     complete->elements = calloc(string_count, sizeof(*complete->elements));
     if(!complete->elements) return false;

     for(int64_t i = 0; i < string_count; i++){
          complete->elements[i].string = strdup(strings[i]);
          if(descriptions && descriptions[i]){
               complete->elements[i].description = strdup(descriptions[i]);
          }
          if(!complete->elements[i].string) return false;
          complete->elements[i].match = true;
     }

     complete->count = string_count;
     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x18e0f
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0xd380
movq %rax, (%r15)
testq %rax, %rax
je 0x18dec
movq %rax, %r13
movq %r15, 0x8(%rsp)
xorl %r15d, %r15d
testq %rbx, %rbx
movq %rbx, %rax
movl $0x0, %ebx
movq %rax, 0x10(%rsp)
cmovgq %rax, %rbx
addq $0x10, %r13
cmpq %r15, %rbx
je 0x18df0
movq (%r12,%r15,8), %rdi
callq 0xd640
movq %rax, %rbp
movq %rax, -0x10(%r13)
testq %r14, %r14
je 0x18dd9
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x18dd9
callq 0xd640
movq %rax, -0x8(%r13)
testq %rbp, %rbp
je 0x18dec
movb $0x1, (%r13)
incq %r15
addq $0x18, %r13
jmp 0x18dad
xorl %eax, %eax
jmp 0x18e00
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_complete.c
// Function: ce_complete_free
void ce_complete_free(CeComplete_t* complete){
     for(int64_t i = 0; i < complete->count; i++){
          free(complete->elements[i].string);
          free(complete->elements[i].description);
     }

     free(complete->elements);
     free(complete->current_match);
     memset(complete, 0, sizeof(*complete));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r15
jge 0x18e45
movq (%rdi,%r14), %rdi
callq 0xd090
movq (%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0xd090
incq %r15
addq $0x18, %r14
jmp 0x18e1d
callq 0xd090
movq 0x10(%rbx), %rdi
callq 0xd090
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_complete.c
// Function: ce_complete_reset
void ce_complete_reset(CeComplete_t* complete){
     free(complete->current_match);
     complete->current_match = NULL;
     complete->current = 0;

     for(int64_t i = 0; i < complete->count; i++){
          complete->elements[i].match = true;
     }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xd090
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x8(%rbx), %rax
pushq $0x10
popq %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x18e95
movq (%rbx), %rsi
movb $0x1, (%rsi,%rcx)
incq %rdx
addq $0x18, %rcx
jmp 0x18e80
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_complete.c
// Function: ce_complete_current_match
int64_t ce_complete_current_match(CeComplete_t* complete){
     int64_t result = 0;
     for(int64_t i = 0; i < complete->count; i++){
          if(i == complete->current){
               return result;
          }
          if(complete->elements[i].match){
               result++;
          }
     }
     return 0;
}

// Assembly:
movq 0x8(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
pushq $0x10
popq %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x19029
cmpq 0x18(%rdi), %rsi
je 0x1902b
movq (%rdi), %r8
movzbl (%r8,%rdx), %r8d
addq %r8, %rax
incq %rsi
addq $0x18, %rdx
jmp 0x1900a
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_complete.c
// Function: ce_complete_next_match
void ce_complete_next_match(CeComplete_t* complete){
     if(complete->current < 0) return;

     for(int64_t i = complete->current + 1; i != complete->current; i++){
          if(i >= complete->count) i = 0;
          if(complete->elements[i].match){
               complete->current = i;
               break;
          }

          if(i == 0 && complete->current == 0) break;
     }
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
js 0x1906c
xorl %ecx, %ecx
movq %rax, %rsi
movq %rsi, %rdx
incq %rdx
cmpq %rax, %rdx
je 0x1906c
movq 0x8(%rdi), %r8
cmpq %r8, %rdx
movq %rdx, %rsi
cmovgeq %rcx, %rsi
movq (%rdi), %r9
imulq $0x18, %rsi, %r10
cmpb $0x1, 0x10(%r9,%r10)
je 0x1906d
testq %rax, %rax
jne 0x1903a
cmpq %r8, %rdx
jl 0x1903a
retq
movq %rsi, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_complete.c
// Function: ce_complete_previous_match
void ce_complete_previous_match(CeComplete_t* complete){
     if(complete->current < 0) return;

     for(int64_t i = complete->current - 1; i != complete->current; i--){
          if(i < 0) i = complete->count - 1;
          if(complete->elements[i].match){
               complete->current = i;
               break;
          }

          if(i == complete->count - 1 && complete->current == complete->count - 1) break;
     }
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
js 0x190b9
movq %rax, %rdx
leaq -0x1(%rdx), %rcx
cmpq %rax, %rcx
je 0x190b9
testq %rdx, %rdx
jg 0x19093
movq 0x8(%rdi), %rcx
decq %rcx
movq (%rdi), %rdx
imulq $0x18, %rcx, %rsi
cmpb $0x1, 0x10(%rdx,%rsi)
je 0x190ba
movq 0x8(%rdi), %rdx
decq %rdx
movq %rcx, %rsi
xorq %rdx, %rsi
xorq %rax, %rdx
orq %rsi, %rdx
movq %rcx, %rdx
jne 0x1907e
retq
movq %rcx, 0x18(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: ce_json_array_add_obj
void ce_json_array_add_obj(CeJsonArray_t* array, CeJsonObj_t* obj){
     uint64_t new_count = array->count + 1;
     array->values = realloc(array->values, new_count * sizeof(array->values[0]));
     CeJsonValue_t* new_value = array->values + array->count;
     memset(new_value, 0, sizeof(*new_value));
     new_value->type = CE_JSON_TYPE_OBJECT;
     _obj_copy(&new_value->obj, obj);
     array->count = new_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %r15
incq %r15
imulq $0x18, %r15, %rsi
callq 0xd520
movq %rax, (%r14)
imulq $0x18, 0x8(%r14), %rcx
xorps %xmm0, %xmm0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movups %xmm0, -0x8(%rdi)
andq $0x0, 0x8(%rdi)
movl $0x1, -0x8(%rdi)
movq %rbx, %rsi
callq 0x1a70f
movq %r15, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: obj_copy
static void _obj_copy(CeJsonObj_t* a, CeJsonObj_t* b){
     _obj_free(a);

     for(int64_t i = 0; i < b->count; i++){
          CeJsonField_t* field = b->fields + i;
          switch(field->value.type){
          case CE_JSON_TYPE_OBJECT:
               ce_json_obj_set_obj(a, field->name, &field->value.obj);
               break;
          case CE_JSON_TYPE_ARRAY:
               ce_json_obj_set_array(a, field->name, &field->value.array);
               break;
          case CE_JSON_TYPE_STRING:
               ce_json_obj_set_string(a, field->name, field->value.string);
               break;
          case CE_JSON_TYPE_NUMBER:
               ce_json_obj_set_number(a, field->name, field->value.number);
               break;
          case CE_JSON_TYPE_BOOL:
               ce_json_obj_set_boolean(a, field->name, field->value.boolean);
               break;
          case CE_JSON_TYPE_NULL:
               ce_json_obj_set_null(a, field->name);
               break;
          default:
               break;
          }
     }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1ad0d
pushq $0x10
popq %r15
xorl %r12d, %r12d
leaq 0x11f67(%rip), %r13     # 0x2c698
cmpq 0x8(%rbx), %r12
jge 0x1a7cd
movq (%rbx), %rdx
movl -0x8(%rdx,%r15), %eax
decl %eax
cmpl $0x5, %eax
ja 0x1a7c1
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq -0x10(%rdx,%r15), %rsi
addq %r15, %rdx
movq %r14, %rdi
callq 0x1a949
jmp 0x1a7c1
movq -0x10(%rdx,%r15), %rsi
movzbl (%rdx,%r15), %edx
movq %r14, %rdi
callq 0x1ac2a
jmp 0x1a7c1
movq -0x10(%rdx,%r15), %rsi
movq (%rdx,%r15), %rdx
movq %r14, %rdi
callq 0x1ab25
jmp 0x1a7c1
movq -0x10(%rdx,%r15), %rsi
movsd (%rdx,%r15), %xmm0
movq %r14, %rdi
callq 0x1aba5
jmp 0x1a7c1
movq -0x10(%rdx,%r15), %rsi
addq %r15, %rdx
movq %r14, %rdi
callq 0x1aa13
jmp 0x1a7c1
movq -0x10(%rdx,%r15), %rsi
movq %r14, %rdi
callq 0x1aca1
incq %r12
addq $0x20, %r15
jmp 0x1a731
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: ce_json_array_add_string
void ce_json_array_add_string(CeJsonArray_t* array, const char* string){
     uint64_t new_count = array->count + 1;
     array->values = realloc(array->values, new_count * sizeof(array->values[0]));
     CeJsonValue_t* new_value = array->values + array->count;
     memset(new_value, 0, sizeof(*new_value));
     new_value->type = CE_JSON_TYPE_STRING;
     new_value->string = strdup(string);
     array->count = new_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %r12
incq %r12
imulq $0x18, %r12, %rsi
callq 0xd520
movq %rax, %r15
movq %rax, (%r14)
imulq $0x18, 0x8(%r14), %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%r13)
andq $0x0, 0x10(%rax,%r13)
movl $0x3, (%rax,%r13)
movq %rbx, %rdi
callq 0xd640
movq %rax, 0x8(%r15,%r13)
movq %r12, 0x8(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: ce_json_array_add_number
void ce_json_array_add_number(CeJsonArray_t* array, double number){
     uint64_t new_count = array->count + 1;
     array->values = realloc(array->values, new_count * sizeof(array->values[0]));
     CeJsonValue_t* new_value = array->values + array->count;
     memset(new_value, 0, sizeof(*new_value));
     new_value->type = CE_JSON_TYPE_NUMBER;
     new_value->number = number;
     array->count = new_count;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %r14
incq %r14
imulq $0x18, %r14, %rsi
callq 0xd520
movq %rax, (%rbx)
imulq $0x18, 0x8(%rbx), %rcx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movl $0x4, (%rax,%rcx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rcx)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: ce_json_array_add_boolean
void ce_json_array_add_boolean(CeJsonArray_t* array, bool boolean){
     uint64_t new_count = array->count + 1;
     array->values = realloc(array->values, new_count * sizeof(array->values[0]));
     CeJsonValue_t* new_value = array->values + array->count;
     memset(new_value, 0, sizeof(*new_value));
     new_value->type = CE_JSON_TYPE_BOOL;
     new_value->boolean = boolean;
     array->count = new_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %r15
incq %r15
imulq $0x18, %r15, %rsi
callq 0xd520
movq %rax, (%r14)
imulq $0x18, 0x8(%r14), %rcx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movl $0x5, (%rax,%rcx)
movb %bl, 0x8(%rax,%rcx)
movq %r15, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: ce_json_array_add_null
void ce_json_array_add_null(CeJsonArray_t* array){
     uint64_t new_count = array->count + 1;
     array->values = realloc(array->values, new_count * sizeof(array->values[0]));
     CeJsonValue_t* new_value = array->values + array->count;
     memset(new_value, 0, sizeof(*new_value));
     new_value->type = CE_JSON_TYPE_NULL;
     array->count = new_count;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %r14
incq %r14
imulq $0x18, %r14, %rsi
callq 0xd520
movq %rax, (%rbx)
imulq $0x18, 0x8(%rbx), %rcx
andq $0x0, 0x10(%rax,%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx)
movl $0x6, (%rax,%rcx)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq