LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x2, %eax
cmpq $0x1, 0x208(%rdi)
jne 0x19013
pushq %r14
pushq %rbx
pushq %rax
movq 0x200(%rdi), %rcx
cmpl $0x2, (%rcx)
jne 0x1900c
movq %rsi, %rbx
movq 0x8(%rcx), %r14
leaq 0x17550(%rip), %rsi     # 0x304f3
movq %r14, %rdi
callq 0xd390
xorl %ecx, %ecx
testl %eax, %eax
je 0x19004
leaq 0x17540(%rip), %rsi     # 0x304f8
movq %r14, %rdi
callq 0xd390
testl %eax, %eax
je 0x18ff8
leaq 0x1678e(%rip), %rsi     # 0x2f759
movq %r14, %rdi
callq 0xd390
testl %eax, %eax
je 0x18fff
leaq 0x17523(%rip), %rsi     # 0x30501
movq %r14, %rdi
callq 0xd390
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x1900c
movl $0x3, %ecx
jmp 0x19004
movl $0x1, %ecx
jmp 0x19004
movl $0x2, %ecx
movl %ecx, 0x1a50(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl $0x2, %ebp
cmpq $0x0, 0x208(%rdi)
jne 0x190f2
movq %rsi, %rbx
movq 0x27f8(%rsi), %rax
movq 0x2818(%rsi), %rcx
movq 0x10(%rcx), %r14
testq %rax, %rax
je 0x19057
xorl %r15d, %r15d
jmp 0x19069
movq 0x10(%r14), %rcx
leaq 0x8(%rcx), %rdx
xorl %r15d, %r15d
cmpl $0x0, (%rcx)
cmoveq %rdx, %r15
movl $0x3, %ebp
testq %rax, %rax
jne 0x190f2
movq 0x40(%r15), %rsi
movq 0x30(%r15), %rdx
movq 0x38(%r15), %rcx
movq %rsp, %r12
movq %r12, %rdi
callq 0x26db0
movq 0x40(%r15), %rdi
movq 0x10(%r12), %rcx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
subq %rsi, %rcx
incq %rcx
callq 0xf79a
testq %rax, %rax
je 0x190ed
movq %rax, %r12
leaq 0x17450(%rip), %rdx     # 0x30506
xorl %ebp, %ebp
leaq 0x20(%rsp), %r13
movl $0x80, %esi
movq %r13, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xd260
movq %r12, %rdi
callq 0xd090
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x147ef
jmp 0x190f2
movl $0x3, %ebp
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19137
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x27f8(%rsi), %rcx
movq 0x2818(%rsi), %rax
movq 0x10(%rax), %r14
testq %rcx, %rcx
je 0x1913d
xorl %r15d, %r15d
jmp 0x1914f
movl $0x2, %eax
retq
movq 0x10(%r14), %rax
leaq 0x8(%rax), %rdx
xorl %r15d, %r15d
cmpl $0x0, (%rax)
cmoveq %rdx, %r15
movl $0x3, %eax
testq %rcx, %rcx
jne 0x19185
callq 0x19191
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x147ef
movl %eax, %ebx
movq %r12, %rdi
callq 0xd090
xorb $0x1, %bl
movzbl %bl, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x208(%rdi)
jle 0x19283
movq %rdi, %r14
movl $0x8, %r15d
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x200(%r14), %rax
movl -0x8(%rax,%r15), %ecx
cmpl $0x2, %ecx
je 0x19219
cmpl $0x1, %ecx
je 0x191f7
testl %ecx, %ecx
jne 0x19267
leaq (%rsp,%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
subq %rbp, %rsi
movq (%rax,%r15), %rcx
leaq 0x16a2b(%rip), %rdx     # 0x2fc20
jmp 0x19230
leaq (%rsp,%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
subq %rbp, %rsi
movsd (%rax,%r15), %xmm0
leaq 0x173b3(%rip), %rdx     # 0x305c3
movb $0x1, %al
callq 0xd260
jmp 0x19237
leaq (%rsp,%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
subq %rbp, %rsi
movq (%rax,%r15), %rcx
leaq 0x1742a(%rip), %rdx     # 0x3065a
xorl %eax, %eax
callq 0xd260
testl %eax, %eax
js 0x19245
movl %eax, %eax
addq %rax, %rbp
movb $0x1, %r12b
jmp 0x1926a
callq 0xd0a0
movl (%rax), %edi
callq 0xd650
xorl %r12d, %r12d
leaq 0x1736c(%rip), %rdi     # 0x305c7
movq %rax, %rsi
xorl %eax, %eax
callq 0xd954
jmp 0x1926a
xorl %r12d, %r12d
testb %r12b, %r12b
je 0x192a0
incq %r13
addq $0x10, %r15
cmpq 0x208(%r14), %r13
jl 0x191c0
movq %rsp, %rdi
callq 0xd640
movq %rax, %rbx
movq %rax, %rdi
callq 0xd210
testq %rax, %rax
je 0x192a0
movb $0x0, -0x1(%rbx,%rax)
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_O1/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 0x192e6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x27f8(%rsi), %rcx
movq 0x2818(%rsi), %rax
movq 0x10(%rax), %r14
testq %rcx, %rcx
je 0x192ec
xorl %r15d, %r15d
jmp 0x192fe
movl $0x2, %eax
retq
movq 0x10(%r14), %rax
leaq 0x8(%rax), %rdx
xorl %r15d, %r15d
cmpl $0x0, (%rax)
cmoveq %rdx, %r15
movl $0x3, %eax
testq %rcx, %rcx
jne 0x19337
callq 0x19191
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x147ef
movl %eax, %ebx
movq %r12, %rdi
callq 0xd090
xorb $0x1, %bl
movzbl %bl, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x2, %eax
cmpq $0x0, 0x208(%rdi)
jle 0x19375
retq
pushq %rbx
movq 0x27f8(%rsi), %rcx
testq %rcx, %rcx
je 0x19386
xorl %ebx, %ebx
jmp 0x193a2
movq 0x2818(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
leaq 0x8(%rax), %rdx
xorl %ebx, %ebx
cmpl $0x0, (%rax)
cmoveq %rdx, %rbx
movl $0x3, %eax
testq %rcx, %rcx
jne 0x193d3
movq 0x40(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
callq 0x1506c
testq %rax, %rax
jle 0x193ce
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
xorl %eax, %eax
jmp 0x193d3
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_commands.c
// Function: command_clang_goto_def
static bool get_command_context(CeApp_t* app, CommandContext_t* command_context){
     command_context->tab_layout = app->tab_list_layout->tab_list.current;

     if(app->input_complete_func) return false;

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

     return true;
}

// Assembly:
movq 0x27f8(%rsi), %rcx
testq %rcx, %rcx
je 0x193e5
xorl %edi, %edi
jmp 0x19401
movq 0x2818(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
leaq 0x8(%rax), %rdx
xorl %edi, %edi
cmpl $0x0, (%rax)
cmoveq %rdx, %rdi
movl $0x3, %eax
testq %rcx, %rcx
je 0x1940c
retq
pushq %rax
addq $0x2cd0, %rsi           # imm = 0x2CD0
movq 0x40(%rdi), %rax
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rcx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x16065
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %rbx
movq 0x27f8(%rsi), %rcx
testq %rcx, %rcx
je 0x19569
xorl %esi, %esi
jmp 0x19585
movq 0x2818(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
leaq 0x8(%rax), %rdx
xorl %esi, %esi
cmpl $0x0, (%rax)
cmoveq %rdx, %rsi
movl $0x3, %eax
testq %rcx, %rcx
jne 0x19614
cmpb $0x0, 0x22f4(%rbx)
je 0x195f5
movq 0x40(%rsi), %rax
movq 0x58(%rax), %rcx
movq 0x600(%rcx), %rcx
cmpq 0x219ae(%rip), %rcx     # 0x3af60
sete %dl
cmpq 0x2199c(%rip), %rcx     # 0x3af58
sete %cl
orb %dl, %cl
je 0x195fe
leaq 0x22f4(%rbx), %rdi
movl 0x20(%rbx), %edx
leal -0x2(%rdx), %ecx
cmpl $0x2, %ecx
ja 0x19616
leaq 0x1a20(%rbx), %rcx
callq 0x14e9a
movl %eax, %ecx
movl $0x1, %eax
testb %cl, %cl
je 0x19614
movl $0x0, 0x20(%rbx)
jmp 0x19631
leaq 0x16f11(%rip), %rsi     # 0x3050d
jmp 0x19605
leaq 0x16f3b(%rip), %rsi     # 0x30540
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12502
movl $0x1, %eax
popq %rbx
retq
movq 0x30(%rsi), %rdx
movq 0x38(%rsi), %rcx
movq %rax, %rsi
callq 0x14dc0
movl %eax, %ecx
movl $0x1, %eax
testb %cl, %cl
je 0x19614
xorl %eax, %eax
jmp 0x19614
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movl $0x2, %ebp
cmpq $0x1, 0x208(%rdi)
jne 0x198bb
movq 0x200(%rdi), %rax
cmpl $0x2, (%rax)
jne 0x198bb
movq %rsi, %rbx
movq 0x27f8(%rsi), %rcx
testq %rcx, %rcx
je 0x1984f
xorl %esi, %esi
jmp 0x1986b
movq 0x2818(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rdx), %rdx
leaq 0x8(%rdx), %rdi
xorl %esi, %esi
cmpl $0x0, (%rdx)
cmoveq %rdi, %rsi
movl $0x3, %ebp
testq %rcx, %rcx
jne 0x198bb
leaq 0x2828(%rbx), %rdi
leaq 0x1a50(%rbx), %rdx
leaq 0x20(%rbx), %rcx
movq 0x8(%rax), %r9
movl $0x1, %ebp
movl $0x1, %r8d
callq 0x118b2
testq %rax, %rax
je 0x198bb
movq 0x2828(%rbx), %rax
addq $0x2cd0, %rbx           # imm = 0x2CD0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x159ff
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x2, %eax
cmpq $0x0, 0x208(%rdi)
jne 0x1991e
movq %rsi, %rbx
movq 0x2818(%rsi), %rax
cmpq $0x1, 0x18(%rax)
jne 0x19911
movq %rdi, %r14
movq 0x10(%rax), %rdi
callq 0x1f30d
cmpq $0x1, %rax
jne 0x19911
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16903
movq %rbx, %rdi
callq 0x17107
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x2, %eax
cmpq $0x0, 0x208(%rdi)
jne 0x19982
movq %rsi, %rbx
movq 0x2818(%rsi), %rax
cmpq $0x1, 0x18(%rax)
jne 0x19975
movq %rdi, %r14
movq 0x10(%rax), %rdi
callq 0x1f30d
cmpq $0x1, %rax
jne 0x19975
movb $0x1, 0x2c78(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16903
movq %rbx, %rdi
callq 0x17107
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movl $0x2, %eax
cmpq $0x0, 0x208(%rdi)
jne 0x19a3f
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27f8(%rsi), %rcx
testq %rcx, %rcx
je 0x199d1
xorl %edx, %edx
jmp 0x199ed
movq 0x2818(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
leaq 0x8(%rax), %rsi
xorl %edx, %edx
cmpl $0x0, (%rax)
cmoveq %rsi, %rdx
movl $0x3, %eax
testq %rcx, %rcx
jne 0x19a3f
movq 0x40(%rdx), %rsi
movq %rbx, %rdi
callq 0x16c8f
movq 0x2818(%rbx), %rax
cmpq $0x1, 0x18(%rax)
jne 0x19a32
movq 0x10(%rax), %rdi
callq 0x1f30d
cmpq $0x1, %rax
jne 0x19a32
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16903
movq %rbx, %rdi
callq 0x17107
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
movq 0x208(%rdi), %rax
movl $0x2, %ebp
cmpq $0x1, %rax
je 0x19cc7
testq %rax, %rax
jne 0x19d6b
movq 0x27f8(%rbx), %rax
movq 0x2818(%rbx), %rcx
movq 0x10(%rcx), %rdx
testq %rax, %rax
je 0x19cf3
xorl %ecx, %ecx
jmp 0x19d04
movq 0x200(%rdi), %rax
cmpl $0x2, (%rax)
jne 0x19d6b
movq 0x27f8(%rbx), %rcx
movq 0x2818(%rbx), %rdx
movq 0x10(%rdx), %r14
testq %rcx, %rcx
je 0x19d1c
xorl %r15d, %r15d
jmp 0x19d2e
movq 0x10(%rdx), %rsi
leaq 0x8(%rsi), %rdi
xorl %ecx, %ecx
cmpl $0x0, (%rsi)
cmoveq %rdi, %rcx
movl $0x3, %ebp
testq %rax, %rax
jne 0x19d6b
leaq 0x15b5d(%rip), %rsi     # 0x2f872
xorl %ebp, %ebp
movq %rbx, %rdi
jmp 0x19d63
movq 0x10(%r14), %rdx
leaq 0x8(%rdx), %rsi
xorl %r15d, %r15d
cmpl $0x0, (%rdx)
cmoveq %rsi, %r15
movl $0x3, %ebp
testq %rcx, %rcx
jne 0x19d6b
movq 0x8(%rax), %rcx
leaq 0x16845(%rip), %rdx     # 0x30588
xorl %ebp, %ebp
movq %rsp, %r12
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
xorl %eax, %eax
callq 0xd260
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x147ef
movl %ebp, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x2, %eax
cmpq $0x1, 0x208(%rdi)
jne 0x19e30
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x200(%rdi), %rcx
cmpl $0x2, (%rcx)
jne 0x19e25
movq %rsi, %rbx
movq 0x27f8(%rsi), %rcx
testq %rcx, %rcx
je 0x19dbb
xorl %r15d, %r15d
jmp 0x19dd8
movq 0x2818(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
leaq 0x8(%rax), %rdx
xorl %r15d, %r15d
cmpl $0x0, (%rax)
cmoveq %rdx, %r15
movl $0x3, %eax
testq %rcx, %rcx
jne 0x19e25
movq 0x40(%r15), %rdi
callq 0x11c40
movq %rax, %r12
testq %rax, %rax
jne 0x19e02
leaq 0x1658a(%rip), %rdi     # 0x30384
callq 0xd640
movq %rax, %r12
movq 0x200(%r14), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x19e31
movq %r12, %rdi
callq 0xd090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbp
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
callq 0x1a0bc
movl $0x18, %esi
movq %rbp, %rdi
callq 0xd380
movq %rax, (%rbx)
testq %rax, %rax
je 0x1a09f
movq %rbx, (%rsp)
testq %rbp, %rbp
setg %r14b
jle 0x1a0a3
movq %rax, %r13
movq %rbp, %rax
negq %rax
movq %rax, 0x8(%rsp)
addq $0x10, %r13
movl $0x1, %r12d
movq %rbp, %rbx
movq 0x10(%rsp), %rax
movq -0x8(%rax,%r12,8), %rdi
callq 0xd640
movq %rax, %rbp
movq %rax, -0x10(%r13)
testq %r15, %r15
je 0x1a068
movq -0x8(%r15,%r12,8), %rdi
testq %rdi, %rdi
je 0x1a068
callq 0xd640
movq %rax, -0x8(%r13)
testq %rbp, %rbp
je 0x1a096
movb $0x1, (%r13)
movq %rbx, %rbp
cmpq %rbx, %r12
setl %r14b
movq 0x8(%rsp), %rax
addq %r12, %rax
incq %rax
incq %r12
addq $0x18, %r13
cmpq $0x1, %rax
jne 0x1a037
jmp 0x1a0a3
testb $0x1, %r14b
movq %rbx, %rbp
je 0x1a0a3
xorl %eax, %eax
jmp 0x1a0ad
movq (%rsp), %rax
movq %rbp, 0x8(%rax)
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_O1/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
cmpq $0x0, 0x8(%rdi)
jle 0x1a0f7
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r14), %rdi
callq 0xd090
movq (%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0xd090
incq %r15
addq $0x18, %r14
cmpq 0x8(%rbx), %r15
jl 0x1a0d1
movq (%rbx), %rdi
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_O1/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
testq %rax, %rax
jle 0x1a148
movq (%rbx), %rcx
addq $0x10, %rcx
movb $0x1, (%rcx)
addq $0x18, %rcx
decq %rax
jne 0x1a13c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rcx, %rcx
jle 0x1a2a4
movq 0x18(%rdi), %rdx
movl $0x10, %esi
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %r8, %rdx
je 0x1a2a6
movq (%rdi), %r9
movzbl (%r9,%rsi), %r9d
addq %r9, %rax
incq %r8
addq $0x18, %rsi
cmpq %r8, %rcx
jne 0x1a288
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a2e7
xorl %ecx, %ecx
movq %rax, %rsi
movq %rsi, %rdx
incq %rdx
cmpq %rax, %rdx
je 0x1a2e7
movq 0x8(%rdi), %r8
cmpq %r8, %rdx
movq %rdx, %rsi
cmovgeq %rcx, %rsi
movq (%rdi), %r9
leaq (%rsi,%rsi,2), %r10
cmpb $0x1, 0x10(%r9,%r10,8)
je 0x1a2e8
testq %rax, %rax
jne 0x1a2b5
cmpq %r8, %rdx
jl 0x1a2b5
retq
movq %rsi, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a334
movq %rax, %rdx
leaq -0x1(%rdx), %rcx
cmpq %rax, %rcx
je 0x1a334
testq %rdx, %rdx
jg 0x1a30e
movq 0x8(%rdi), %rcx
decq %rcx
movq (%rdi), %rdx
leaq (%rcx,%rcx,2), %rsi
cmpb $0x1, 0x10(%rdx,%rsi,8)
je 0x1a335
movq 0x8(%rdi), %rdx
decq %rdx
movq %rcx, %rsi
xorq %rdx, %rsi
xorq %rax, %rdx
orq %rsi, %rdx
movq %rcx, %rdx
jne 0x1a2f9
retq
movq %rcx, 0x18(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x8(,%r15,8), %rax
incq %r15
leaq (%rax,%rax,2), %rsi
callq 0xd520
movq %rax, (%r14)
movq 0x8(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
xorps %xmm0, %xmm0
leaq 0x8(%rax,%rcx,8), %rdi
movups %xmm0, -0x8(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, -0x8(%rdi)
movq %rbx, %rsi
callq 0x1bb82
movq %r15, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1c2ea
cmpq $0x0, 0x8(%rbx)
jle 0x1bc48
movl $0x10, %r15d
xorl %r12d, %r12d
leaq 0x14ad3(%rip), %r13     # 0x30684
movq (%rbx), %rdx
movl -0x8(%rdx,%r15), %eax
decl %eax
cmpl $0x5, %eax
ja 0x1bc37
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq -0x10(%rdx,%r15), %rsi
addq %r15, %rdx
movq %r14, %rdi
callq 0x1be07
jmp 0x1bc37
movq -0x10(%rdx,%r15), %rsi
movzbl (%rdx,%r15), %edx
movq %r14, %rdi
callq 0x1c20a
jmp 0x1bc37
movq -0x10(%rdx,%r15), %rsi
movq (%rdx,%r15), %rdx
movq %r14, %rdi
callq 0x1c108
jmp 0x1bc37
movq -0x10(%rdx,%r15), %rsi
movsd (%rdx,%r15), %xmm0
movq %r14, %rdi
callq 0x1c186
jmp 0x1bc37
movq -0x10(%rdx,%r15), %rsi
addq %r15, %rdx
movq %r14, %rdi
callq 0x1beea
jmp 0x1bc37
movq -0x10(%rdx,%r15), %rsi
movq %r14, %rdi
callq 0x1c27f
incq %r12
addq $0x20, %r15
cmpq 0x8(%rbx), %r12
jl 0x1bbb1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x8(,%r12,8), %rax
incq %r12
leaq (%rax,%rax,2), %rsi
callq 0xd520
movq %rax, %r15
movq %rax, (%r14)
movq 0x8(%r14), %rax
leaq (%rax,%rax,2), %r13
xorps %xmm0, %xmm0
movups %xmm0, (%r15,%r13,8)
movq $0x0, 0x10(%r15,%r13,8)
movl $0x3, (%r15,%r13,8)
movq %rbx, %rdi
callq 0xd640
movq %rax, 0x8(%r15,%r13,8)
movq %r12, 0x8(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x8(,%r14,8), %rax
incq %r14
leaq (%rax,%rax,2), %rsi
callq 0xd520
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x10(%rax,%rcx,8)
movl $0x4, (%rax,%rcx,8)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rcx,8)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x8(,%r15,8), %rax
incq %r15
leaq (%rax,%rax,2), %rsi
callq 0xd520
movq %rax, (%r14)
movq 0x8(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x10(%rax,%rcx,8)
movl $0x5, (%rax,%rcx,8)
movb %bl, 0x8(%rax,%rcx,8)
movq %r15, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x8(,%r14,8), %rax
incq %r14
leaq (%rax,%rax,2), %rsi
callq 0xd520
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x10(%rax,%rcx,8)
movl $0x6, (%rax,%rcx,8)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: array_free
static void _array_free(CeJsonArray_t* a){
     for(int64_t i = 0; i < a->count; i++){
          CeJsonValue_t* value = a->values + i;
          _value_free(value);
     }
     free(a->values);
     a->values = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jle 0x1bdf2
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x1d336
incq %r15
addq $0x18, %r14
cmpq 0x8(%rbx), %r15
jl 0x1bdda
movq (%rbx), %rdi
callq 0xd090
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: ce_json_obj_set_obj
void ce_json_obj_set_obj(CeJsonObj_t* obj, const char* name, CeJsonObj_t* member_obj){
     _obj_free_field_of_name(obj, name);
     uint64_t new_count = obj->count + 1;
     obj->fields = realloc(obj->fields, new_count * sizeof(obj->fields[0]));
     CeJsonField_t* new_field = obj->fields + obj->count;
     memset(new_field, 0, sizeof(*new_field));
     new_field->name = strdup(name);
     new_field->value.type = CE_JSON_TYPE_OBJECT;
     _obj_copy(&new_field->value.obj, member_obj);
     obj->count = new_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1be84
movq (%rbx), %rdi
movq 0x8(%rbx), %r13
incq %r13
movq %r13, %rsi
shlq $0x5, %rsi
callq 0xd520
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
shlq $0x5, %rcx
xorps %xmm0, %xmm0
leaq (%rax,%rcx), %r12
addq $0x10, %r12
movups %xmm0, (%r12)
movups %xmm0, -0x10(%r12)
movq %r15, %rdi
callq 0xd640
movq %rax, -0x10(%r12)
movl $0x1, -0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x1bb82
movq %r13, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: obj_free_field_of_name
static void _obj_free_field_of_name(CeJsonObj_t* obj, const char* name){
     for(int64_t i = 0; i < obj->count; i++){
          CeJsonField_t* field = obj->fields + i;
          if (strcmp(field->name, name) != 0){
               continue;
          }
          _field_free(field);
     }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
jle 0x1bee9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%r14), %r13
movq -0x8(%r13,%r15), %rdi
movq %rbx, %rsi
callq 0xd390
testl %eax, %eax
jne 0x1bed3
leaq (%r15,%r13), %rdi
callq 0x1d336
movq -0x8(%r13,%r15), %rdi
callq 0xd090
movq $0x0, -0x8(%r13,%r15)
incq %r12
addq $0x20, %r15
cmpq 0x8(%r14), %r12
jl 0x1bea3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: ce_json_obj_set_array
void ce_json_obj_set_array(CeJsonObj_t* obj, const char* name, CeJsonArray_t* array){
     uint64_t new_count = obj->count + 1;
     obj->fields = realloc(obj->fields, new_count * sizeof(obj->fields[0]));
     CeJsonField_t* new_field = obj->fields + obj->count;
     memset(new_field, 0, sizeof(*new_field));
     new_field->name = strdup(name);
     new_field->value.type = CE_JSON_TYPE_ARRAY;
     _array_copy(&new_field->value.array, array);
     obj->count = new_count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
incq %rsi
movq %rsi, 0x10(%rsp)
shlq $0x5, %rsi
callq 0xd520
movq %rax, %r15
movq %rax, (%r14)
movq %r14, 0x18(%rsp)
movq 0x8(%r14), %r14
shlq $0x5, %r14
xorps %xmm0, %xmm0
leaq (%rax,%r14), %r12
addq $0x10, %r12
movups %xmm0, (%r12)
movups %xmm0, -0x10(%r12)
movq %r13, %rdi
callq 0xd640
movq %rax, -0x10(%r12)
movl $0x2, -0x8(%r12)
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x1bdc5
cmpq $0x0, 0x8(%rbx)
jle 0x1c0cc
addq %r14, %r15
movl $0x8, %r13d
xorl %ebp, %ebp
leaq 0x1471a(%rip), %r12     # 0x3069c
movq (%rbx), %rsi
movl -0x8(%rsi,%r13), %eax
decl %eax
cmpl $0x5, %eax
ja 0x1c0bb
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
addq %r13, %rsi
movq 0x8(%rsp), %rdi
callq 0x1bb24
jmp 0x1c0bb
movq (%rsi,%r13), %rsi
movq 0x8(%rsp), %rdi
callq 0x1bc52
jmp 0x1c0bb
movq 0x10(%r15), %rdi
movq 0x18(%r15), %r14
leaq 0x8(,%r14,8), %rax
incq %r14
leaq (%rax,%rax,2), %rsi
callq 0xd520
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rcx
leaq (%rcx,%rcx,2), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x10(%rax,%rcx,8)
movl $0x6, (%rax,%rcx,8)
jmp 0x1c053
movb (%rsi,%r13), %r12b
movq 0x10(%r15), %rdi
movq 0x18(%r15), %r14
leaq 0x8(,%r14,8), %rax
incq %r14
leaq (%rax,%rax,2), %rsi
callq 0xd520
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rcx
leaq (%rcx,%rcx,2), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x10(%rax,%rcx,8)
movl $0x5, (%rax,%rcx,8)
movb %r12b, 0x8(%rax,%rcx,8)
leaq 0x14649(%rip), %r12     # 0x3069c
movq %r14, 0x18(%r15)
jmp 0x1c0bb
movsd (%rsi,%r13), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x10(%r15), %rdi
movq 0x18(%r15), %r12
leaq 0x8(,%r12,8), %rax
incq %r12
leaq (%rax,%rax,2), %rsi
callq 0xd520
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rcx
leaq (%rcx,%rcx,2), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x10(%rax,%rcx,8)
movl $0x4, (%rax,%rcx,8)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rcx,8)
movq %r12, 0x18(%r15)
leaq 0x145e1(%rip), %r12     # 0x3069c
incq %rbp
addq $0x18, %r13
cmpq 0x8(%rbx), %rbp
jl 0x1bf82
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x145f4(%rip), %rdi     # 0x306e4
leaq 0x14613(%rip), %rsi     # 0x3070a
leaq 0x14616(%rip), %rcx     # 0x30714
movl $0x3a, %edx
callq 0xd280
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: ce_json_obj_set_string
void ce_json_obj_set_string(CeJsonObj_t* obj, const char* name, const char* string){
     _obj_free_field_of_name(obj, name);
     uint64_t new_count = obj->count + 1;
     obj->fields = realloc(obj->fields, new_count * sizeof(obj->fields[0]));
     CeJsonField_t* new_field = obj->fields + obj->count;
     memset(new_field, 0, sizeof(*new_field));
     new_field->name = strdup(name);
     new_field->value.type = CE_JSON_TYPE_STRING;
     new_field->value.string = strdup(string);
     obj->count = new_count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1be84
movq (%rbx), %rdi
movq 0x8(%rbx), %r13
incq %r13
movq %r13, %rsi
shlq $0x5, %rsi
callq 0xd520
movq %rax, %r12
movq %rax, (%rbx)
movq 0x8(%rbx), %rbp
shlq $0x5, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rbp)
movups %xmm0, (%rax,%rbp)
movq %r15, %rdi
callq 0xd640
movq %rax, (%r12,%rbp)
movl $0x3, 0x8(%r12,%rbp)
movq %r14, %rdi
callq 0xd640
movq %rax, 0x10(%r12,%rbp)
movq %r13, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: ce_json_obj_set_number
void ce_json_obj_set_number(CeJsonObj_t* obj, const char* name, double number){
     _obj_free_field_of_name(obj, name);
     uint64_t new_count = obj->count + 1;
     obj->fields = realloc(obj->fields, new_count * sizeof(obj->fields[0]));
     CeJsonField_t* new_field = obj->fields + obj->count;
     memset(new_field, 0, sizeof(*new_field));
     new_field->name = strdup(name);
     new_field->value.type = CE_JSON_TYPE_NUMBER;
     new_field->value.number = number;
     obj->count = new_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1be84
movq (%rbx), %rdi
movq 0x8(%rbx), %r12
incq %r12
movq %r12, %rsi
shlq $0x5, %rsi
callq 0xd520
movq %rax, %r15
movq %rax, (%rbx)
movq 0x8(%rbx), %r13
shlq $0x5, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%r13)
movups %xmm0, (%rax,%r13)
movq %r14, %rdi
callq 0xd640
movq %rax, (%r15,%r13)
movl $0x4, 0x8(%r15,%r13)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%r15,%r13)
movq %r12, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: ce_json_obj_set_boolean
void ce_json_obj_set_boolean(CeJsonObj_t* obj, const char* name, bool boolean){
     _obj_free_field_of_name(obj, name);
     uint64_t new_count = obj->count + 1;
     obj->fields = realloc(obj->fields, new_count * sizeof(obj->fields[0]));
     CeJsonField_t* new_field = obj->fields + obj->count;
     memset(new_field, 0, sizeof(*new_field));
     new_field->name = strdup(name);
     new_field->value.type = CE_JSON_TYPE_BOOL;
     new_field->value.boolean = boolean;
     obj->count = new_count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1be84
movq (%r14), %rdi
movq 0x8(%r14), %r13
incq %r13
movq %r13, %rsi
shlq $0x5, %rsi
callq 0xd520
movq %rax, %r12
movq %rax, (%r14)
movq 0x8(%r14), %rbp
shlq $0x5, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rbp)
movups %xmm0, (%rax,%rbp)
movq %r15, %rdi
callq 0xd640
movq %rax, (%r12,%rbp)
movl $0x5, 0x8(%r12,%rbp)
movb %bl, 0x10(%r12,%rbp)
movq %r13, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: ce_json_obj_set_null
void ce_json_obj_set_null(CeJsonObj_t* obj, const char* name){
     _obj_free_field_of_name(obj, name);
     uint64_t new_count = obj->count + 1;
     obj->fields = realloc(obj->fields, new_count * sizeof(obj->fields[0]));
     CeJsonField_t* new_field = obj->fields + obj->count;
     memset(new_field, 0, sizeof(*new_field));
     new_field->name = strdup(name);
     new_field->value.type = CE_JSON_TYPE_NULL;
     obj->count = new_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1be84
movq (%rbx), %rdi
movq 0x8(%rbx), %r12
incq %r12
movq %r12, %rsi
shlq $0x5, %rsi
callq 0xd520
movq %rax, %r15
movq %rax, (%rbx)
movq 0x8(%rbx), %r13
shlq $0x5, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%r13)
movups %xmm0, (%rax,%r13)
movq %r14, %rdi
callq 0xd640
movq %rax, (%r15,%r13)
movl $0x6, 0x8(%r15,%r13)
movq %r12, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: obj_free
static void _obj_free(CeJsonObj_t* obj){
     for(int64_t i = 0; i < obj->count; i++){
          CeJsonField_t* field = obj->fields + i;
          _field_free(field);
     }
     free(obj->fields);
     obj->fields = NULL;
     obj->count = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jle 0x1c331
movl $0x8, %r14d
xorl %r15d, %r15d
movq (%rbx), %r12
leaq (%r12,%r14), %rdi
callq 0x1d336
movq -0x8(%r12,%r14), %rdi
callq 0xd090
movq $0x0, -0x8(%r12,%r14)
incq %r15
addq $0x20, %r14
cmpq 0x8(%rbx), %r15
jl 0x1c305
movq (%rbx), %rdi
callq 0xd090
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_json.c
// Function: ce_json_obj_to_string
void ce_json_obj_to_string(CeJsonObj_t* json, char* string, uint64_t size, uint64_t indent){
     PrintState_t print_state = {};
     print_state.remaining = size;
     _obj_print(json, string, &print_state, 0, indent);
     _print_state_update(&print_state, snprintf(string + print_state.printed, print_state.remaining, "\n"));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r8
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %rdx, 0x8(%r14)
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1c390
addq (%r14), %rbx
movq 0x8(%r14), %rsi
leaq 0x13b77(%rip), %rdx     # 0x2fef5
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd260
addq $0x18, %rsp
popq %rbx
popq %r14
retq