LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq 0x208(%rdi), %rax
movl $0x2, %ebx
cmpq $0x1, %rax
je 0x196aa
testq %rax, %rax
jne 0x19712
movl $0x3, %ebx
cmpq $0x0, 0x27f8(%r14)
jne 0x19712
movq 0x2818(%r14), %rax
movq 0x10(%rax), %rdx
movq 0x10(%rdx), %rax
leaq 0x8(%rax), %rcx
xorl %ebx, %ebx
cmpl $0x0, (%rax)
cmovneq %rbx, %rcx
leaq 0x151cf(%rip), %rsi     # 0x2e874
movq %r14, %rdi
jmp 0x1970a
movq 0x200(%rdi), %rax
cmpl $0x2, (%rax)
jne 0x19712
movl $0x3, %ebx
cmpq $0x0, 0x27f8(%r14)
jne 0x19712
movq 0x2818(%r14), %rcx
movq 0x10(%rcx), %r15
movq 0x10(%r15), %rcx
xorl %ebx, %ebx
cmpl $0x0, (%rcx)
leaq 0x8(%rcx), %r12
cmovneq %rbx, %r12
movq 0x8(%rax), %rcx
leaq 0x15e99(%rip), %rdx     # 0x2f585
movq %rsp, %r13
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
xorl %eax, %eax
callq 0xd260
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x1452c
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x197c2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x200(%rdi), %rcx
cmpl $0x2, (%rcx)
jne 0x197b7
movq %rsi, %rbx
movl $0x3, %eax
cmpq $0x0, 0x27f8(%rsi)
jne 0x197b7
movq 0x2818(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r15
movq 0x48(%r15), %rdi
addq $0x8, %r15
callq 0x11a2b
movq %rax, %r12
testq %rax, %rax
jne 0x19794
leaq 0x13ade(%rip), %rdi     # 0x2d26a
callq 0xd640
movq %rax, %r12
movq 0x200(%r14), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x197c3
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_O3/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
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x199ea
movl $0x18, %esi
movq %rbx, %rdi
callq 0xd380
movq %rax, (%r15)
testq %rax, %rax
je 0x199d9
movq %r15, (%rsp)
testq %rbx, %rbx
jle 0x199cd
movq %rax, %r13
addq $0x10, %r13
xorl %r15d, %r15d
movq (%r12,%r15,8), %rdi
callq 0xd640
movq %rax, %rbp
movq %rax, -0x10(%r13)
testq %r14, %r14
je 0x199b7
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x199b7
callq 0xd640
movq %rax, -0x8(%r13)
testq %rbp, %rbp
je 0x199d9
movb $0x1, (%r13)
incq %r15
addq $0x18, %r13
cmpq %r15, %rbx
jne 0x19990
movq (%rsp), %rax
movq %rbx, 0x8(%rax)
movb $0x1, %al
jmp 0x199db
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19a25
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 0x199ff
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_O3/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 0x1a67b
movq 0x18(%rdi), %rdx
movl $0x10, %esi
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %r8, %rdx
je 0x1a67d
movq (%rdi), %r9
movzbl (%r9,%rsi), %r9d
addq %r9, %rax
incq %r8
addq $0x18, %rsi
cmpq %r8, %rcx
jne 0x1a65f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a6be
xorl %ecx, %ecx
movq %rax, %rsi
movq %rsi, %rdx
incq %rdx
cmpq %rax, %rdx
je 0x1a6be
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 0x1a6bf
testq %rax, %rax
jne 0x1a68c
cmpq %r8, %rdx
jl 0x1a68c
retq
movq %rsi, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a70b
movq %rax, %rdx
leaq -0x1(%rdx), %rcx
cmpq %rax, %rcx
je 0x1a70b
testq %rdx, %rdx
jg 0x1a6e5
movq 0x8(%rdi), %rcx
decq %rcx
movq (%rdi), %rdx
leaq (%rcx,%rcx,2), %rsi
cmpb $0x1, 0x10(%rdx,%rsi,8)
je 0x1a70c
movq 0x8(%rdi), %rdx
decq %rdx
movq %rcx, %rsi
xorq %rdx, %rsi
xorq %rax, %rdx
orq %rsi, %rdx
movq %rcx, %rdx
jne 0x1a6d0
retq
movq %rcx, 0x18(%rdi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1c6ac
cmpq $0x0, 0x8(%rbx)
jle 0x1bfe4
movl $0x10, %r15d
xorl %r12d, %r12d
leaq 0x137f3(%rip), %r13     # 0x2f740
movq (%rbx), %rdx
movl -0x8(%rdx,%r15), %eax
decl %eax
cmpl $0x5, %eax
ja 0x1bfd3
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq -0x10(%rdx,%r15), %rsi
addq %r15, %rdx
movq %r14, %rdi
callq 0x1c1a3
jmp 0x1bfd3
movq -0x10(%rdx,%r15), %rsi
movzbl (%rdx,%r15), %edx
movq %r14, %rdi
callq 0x1c5c3
jmp 0x1bfd3
movq -0x10(%rdx,%r15), %rsi
movq (%rdx,%r15), %rdx
movq %r14, %rdi
callq 0x1c4b8
jmp 0x1bfd3
movq -0x10(%rdx,%r15), %rsi
movsd (%rdx,%r15), %xmm0
movq %r14, %rdi
callq 0x1c53b
jmp 0x1bfd3
movq -0x10(%rdx,%r15), %rsi
addq %r15, %rdx
movq %r14, %rdi
callq 0x1c296
jmp 0x1bfd3
movq -0x10(%rdx,%r15), %rsi
movq %r14, %rdi
callq 0x1c63d
incq %r12
addq $0x20, %r15
cmpq 0x8(%rbx), %r12
jl 0x1bf4d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c18e
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x1d6cf
incq %r15
addq $0x18, %r14
cmpq 0x8(%rbx), %r15
jl 0x1c176
movq (%rbx), %rdi
callq 0xd090
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c224
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, -0x8(%r12)
movq $0x0, 0x8(%r12)
movq %r15, %rdi
callq 0xd640
movq %rax, -0x10(%r12)
movl $0x1, -0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x1bf1e
movq %r13, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r13
testq %r13, %r13
jle 0x1c287
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%r14), %rbp
movq -0x8(%rbp,%r15), %rdi
movq %rbx, %rsi
callq 0xd390
testl %eax, %eax
jne 0x1c27b
leaq (%r15,%rbp), %rdi
callq 0x1d6cf
movq -0x8(%rbp,%r15), %rdi
callq 0xd090
movq $0x0, -0x8(%rbp,%r15)
movq 0x8(%r14), %r13
incq %r12
addq $0x20, %r15
cmpq %r13, %r12
jl 0x1c247
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, -0x8(%r12)
movq $0x0, 0x8(%r12)
movq %r13, %rdi
callq 0xd640
movq %rax, -0x10(%r12)
movl $0x2, -0x8(%r12)
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x1c161
cmpq $0x0, 0x8(%rbx)
jle 0x1c47c
addq %r14, %r15
movl $0x8, %r13d
xorl %ebp, %ebp
leaq 0x13426(%rip), %r12     # 0x2f758
movq (%rbx), %rsi
movl -0x8(%rsi,%r13), %eax
decl %eax
cmpl $0x5, %eax
ja 0x1c46b
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
addq %r13, %rsi
movq 0x8(%rsp), %rdi
callq 0x1bec0
jmp 0x1c46b
movq (%rsi,%r13), %rsi
movq 0x8(%rsp), %rdi
callq 0x1bfee
jmp 0x1c46b
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 0x1c403
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 0x13355(%rip), %r12     # 0x2f758
movq %r14, 0x18(%r15)
jmp 0x1c46b
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 0x132ed(%rip), %r12     # 0x2f758
incq %rbp
addq $0x18, %r13
cmpq 0x8(%rbx), %rbp
jl 0x1c332
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 0x13300(%rip), %rdi     # 0x2f7a0
leaq 0x1331f(%rip), %rsi     # 0x2f7c6
leaq 0x13322(%rip), %rcx     # 0x2f7d0
movl $0x3a, %edx
callq 0xd280
// File: /workspace/github_c_makefile_star2_O3/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 0x1c6f3
movl $0x8, %r14d
xorl %r15d, %r15d
movq (%rbx), %r12
leaq (%r12,%r14), %rdi
callq 0x1d6cf
movq -0x8(%r12,%r14), %rdi
callq 0xd090
movq $0x0, -0x8(%r12,%r14)
incq %r15
addq $0x20, %r14
cmpq 0x8(%rbx), %r15
jl 0x1c6c7
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_O3/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
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %rdx, 0x8(%r14)
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1c753
addq (%r14), %rbx
movq 0x8(%r14), %rsi
leaq 0x127af(%rip), %rdx     # 0x2eef1
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xd260
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_json.c
// Function: ce_json_obj_find
CeJsonFindResult_t ce_json_obj_find(CeJsonObj_t* obj, const char* name){
     CeJsonFindResult_t result = {};
     for(int64_t i = 0; i < obj->count; i++){
          if(strcmp(obj->fields[i].name, name) == 0){
               result.type = obj->fields[i].value.type;
               result.index = i;
               return result;
          }
     }
     return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
testq %r15, %r15
jle 0x1c97d
movq %rsi, %r14
movq (%rdi), %r12
addq $0x8, %r12
xorl %ebx, %ebx
movq -0x8(%r12), %rdi
movq %r14, %rsi
callq 0xd390
testl %eax, %eax
je 0x1c983
incq %rbx
addq $0x20, %r12
cmpq %rbx, %r15
jne 0x1c960
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0x1c987
movl (%r12), %eax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_json.c
// Function: ce_json_parse
bool ce_json_parse(const char* string, CeJsonObj_t* json, bool verbose){
     ParsePos_t parse_pos = {};
     parse_pos.x = 1;
     parse_pos.y = 1;
     parse_pos.str = string;
     bool result = _obj_parse(&parse_pos, json, verbose);
     if(!result){
          ce_json_obj_free(json);
     }
     return result;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl $0x1, %ecx
movq %rsp, %rax
movq %rcx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rdi, (%rax)
movq %rax, %rdi
callq 0x1ca56
movl %eax, %ebp
testb %al, %al
jne 0x1ca4d
movq %rbx, %rdi
callq 0x1c6ac
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_json.c
// Function: value_free
static void _value_free(CeJsonValue_t* value){
     switch(value->type){
     case CE_JSON_TYPE_OBJECT:
          _obj_free(&value->obj);
          break;
     case CE_JSON_TYPE_ARRAY:
          _array_free(&value->array);
          break;
     case CE_JSON_TYPE_STRING:
          free(value->string);
          break;
     default:
          break;
     }
     value->type = CE_JSON_TYPE_NONE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x3, %eax
je 0x1d6fa
cmpl $0x2, %eax
je 0x1d6ef
cmpl $0x1, %eax
jne 0x1d703
leaq 0x8(%rbx), %rdi
callq 0x1c6ac
jmp 0x1d703
leaq 0x8(%rbx), %rdi
callq 0x1c161
jmp 0x1d703
movq 0x8(%rbx), %rdi
callq 0xd090
movl $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_json.c
// Function: eat_whitespace
static void _eat_whitespace(ParsePos_t* pos){
     while(true){
          if(_is_whitespace(*pos->str)){
               advance_parse_pos(pos);
          }else if(_is_newline(*pos->str)){
               advance_newline_parse_pos(pos);
          }else{
               break;
          }
     }
}

// Assembly:
movq (%rdi), %rax
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0xc, %ecx
jg 0x1d9bc
cmpl $0x9, %ecx
je 0x1d9c6
cmpl $0xa, %ecx
je 0x1d9cf
jmp 0x1d9e1
cmpl $0xd, %ecx
je 0x1d9cf
cmpl $0x20, %ecx
jne 0x1d9e1
movq 0x8(%rdi), %rcx
incq %rcx
jmp 0x1d9d8
incq 0x10(%rdi)
movl $0x1, %ecx
movq %rcx, 0x8(%rdi)
movq %rax, (%rdi)
jmp 0x1d9a4
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_json.c
// Function: parse_string
static bool _parse_string(ParsePos_t* pos, char** result){
     const char* begin = pos->str;
     bool escaped = false;
     while(true){
          char ch = *pos->str;
          if(_is_newline(ch)){
               return false;
          }else if(escaped){
               if(ch != TOKEN_QUOTE &&
                  ch != TOKEN_BACKSLASH &&
                  ch != TOKEN_FORWARDSLASH &&
                  ch != 'b' &&
                  ch != 'f' &&
                  ch != 'n' &&
                  ch != 'r' &&
                  ch != 't' &&
                  ch != 'u'){
                    // TODO: Handle unicode numbers after the \u
                    return pos->str;
               }
               escaped = false;
          }else if(ch == TOKEN_BACKSLASH){
               escaped = true;
          }else if(ch == TOKEN_QUOTE){
               if(*result){
                    free(*result);
               }
               uint64_t string_length = (pos->str - begin);
               *result = malloc(string_length + 1);
               strncpy(*result, begin, string_length);
               (*result)[string_length] = 0;
               break;
          }
          advance_parse_pos(pos);
     }
     return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rbx
xorl %esi, %esi
movabsq $0x400000000002001, %rcx # imm = 0x400000000002001
movl $0xd1011, %edx          # imm = 0xD1011
movq %rbx, %r15
movzbl (%r15), %edi
xorl %eax, %eax
cmpl $0xa, %edi
je 0x1da97
cmpl $0xd, %edi
je 0x1da97
testb $0x1, %sil
je 0x1da42
xorl %esi, %esi
leal -0x62(%rdi), %eax
cmpl $0x13, %eax
ja 0x1da30
btl %eax, %edx
jb 0x1da51
movb $0x1, %al
addl $-0x22, %edi
cmpl $0x3a, %edi
ja 0x1da97
btq %rdi, %rcx
jb 0x1da51
jmp 0x1da97
movb $0x1, %sil
cmpl $0x5c, %edi
je 0x1da51
cmpl $0x22, %edi
je 0x1da5f
xorl %esi, %esi
incq 0x8(%r12)
incq %r15
movq %r15, (%r12)
jmp 0x1da07
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1da70
callq 0xd090
movq (%r12), %r15
subq %rbx, %r15
leaq 0x1(%r15), %rdi
callq 0xd4c0
movq %rax, %r12
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xd0b0
movb $0x0, (%r12,%r15)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_json.c
// Function: parse_boolean
static bool _parse_boolean(ParsePos_t* pos, bool* value){
     if(strncmp(pos->str, "true", 4) == 0){
          *value = true;
          advance_parse_pos_len(pos, 3);
          return true;
     }
     if(strncmp(pos->str, "false", 5) == 0){
          *value = false;
          advance_parse_pos_len(pos, 4);
          return true;
     }
     return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x11d0d(%rip), %rsi     # 0x2f821
movl $0x4, %r12d
movl $0x4, %edx
movq %r14, %rdi
callq 0xd0d0
movb $0x1, %bpl
testl %eax, %eax
je 0x1db4c
leaq 0x11cf1(%rip), %rsi     # 0x2f826
movl $0x5, %edx
movq %r14, %rdi
callq 0xd0d0
xorl %ecx, %ecx
testl %eax, %eax
je 0x1db54
xorl %ebp, %ebp
jmp 0x1db61
movl $0x3, %r12d
movb $0x1, %cl
movb %cl, (%r15)
addq %r12, 0x8(%rbx)
addq %r12, %r14
movq %r14, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_tab_list_init
CeLayout_t* ce_layout_tab_list_init(CeLayout_t* tab_layout){
     CeLayout_t* tab_list_layout = calloc(1, sizeof(*tab_list_layout));
     if(!tab_list_layout) return NULL;
     tab_list_layout->type = CE_LAYOUT_TYPE_TAB_LIST;
     tab_list_layout->tab_list.tabs = malloc(sizeof(*tab_list_layout->tab_list.tabs));
     tab_list_layout->tab_list.tabs[0] = tab_layout;
     tab_list_layout->tab_list.tab_count = 1;
     tab_list_layout->tab_list.current = tab_layout;
     return tab_list_layout;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x60, %esi
callq 0xd380
movq %rax, %r14
testq %rax, %rax
je 0x1dbae
movl $0x3, (%r14)
movl $0x8, %edi
callq 0xd4c0
movq %rax, 0x8(%r14)
movq %rbx, (%rax)
movq $0x1, 0x18(%r14)
movq %rbx, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_tab_list_add
CeLayout_t* ce_layout_tab_list_add(CeLayout_t* tab_list_layout){
     assert(tab_list_layout->type == CE_LAYOUT_TYPE_TAB_LIST);
     CeRect_t rect = tab_list_layout->tab_list.rect;
     int64_t new_tab_count = tab_list_layout->tab_list.tab_count + 1;
     CeLayout_t** new_tabs = realloc(tab_list_layout->tab_list.tabs, new_tab_count * sizeof(*tab_list_layout->tab_list.tabs));
     if(!new_tabs) return false;
     tab_list_layout->tab_list.tabs = new_tabs;
     new_tabs[tab_list_layout->tab_list.tab_count] = ce_layout_tab_init(tab_list_layout->tab_list.current->tab.current->view.buffer, rect);
     tab_list_layout->tab_list.tab_count = new_tab_count;
     for(int64_t i = 0; i < new_tab_count; i++){
         ce_layout_resize_for_tabline(new_tabs[i]);
     }
     return new_tabs[tab_list_layout->tab_list.tab_count - 1];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x3, (%rdi)
jne 0x1dc6c
movq %rdi, %rbx
movups 0x20(%rdi), %xmm0
movups 0x30(%rdi), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x8(%rdi), %rdi
movq 0x18(%rbx), %r15
leaq 0x8(,%r15,8), %rsi
callq 0xd520
testq %rax, %rax
je 0x1dc5e
movq %rax, %r14
leaq 0x1(%r15), %r12
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rdi
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1dc8b
movq 0x18(%rbx), %rcx
movq %rax, (%r14,%rcx,8)
movq %r12, 0x18(%rbx)
testq %r15, %r15
js 0x1dc57
incq %r15
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x1dce4
incq %r12
cmpq %r12, %r15
jne 0x1dc42
movq 0x18(%rbx), %r12
movq -0x8(%r14,%r12,8), %rax
jmp 0x1dc60
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x12025(%rip), %rdi     # 0x2fc98
leaq 0x1204f(%rip), %rsi     # 0x2fcc9
leaq 0x12054(%rip), %rcx     # 0x2fcd5
movl $0x37, %edx
callq 0xd280
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_tab_init
CeLayout_t* ce_layout_tab_init(CeBuffer_t* buffer, CeRect_t rect){
     CeLayout_t* view_layout = ce_layout_view_init(buffer);
     view_layout->view.rect = rect;

     CeLayout_t* tab_layout = calloc(1, sizeof(*tab_layout));
     if(!tab_layout){
         free(view_layout);
         return NULL;
     }
     tab_layout->type = CE_LAYOUT_TYPE_TAB;
     tab_layout->tab.root = view_layout;
     tab_layout->tab.current = view_layout;
     return tab_layout;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1dd8e
movq %rax, %rbx
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm0, 0x8(%rax)
movups %xmm1, 0x18(%rax)
movl $0x1, %edi
movl $0x60, %esi
callq 0xd380
movq %rax, %r14
testq %rax, %rax
je 0x1dcd1
movl $0x2, (%r14)
movq %rbx, 0x8(%r14)
movq %rbx, 0x10(%r14)
jmp 0x1dcd9
movq %rbx, %rdi
callq 0xd090
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_resize_for_tabline
static void ce_layout_resize_for_tabline(CeLayout_t* layout){
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          if(layout->view.rect.top == 0){
               layout->view.rect.top = 1;
          }
          break;
     case CE_LAYOUT_TYPE_LIST:
     {
          if(layout->list.rect.top == 0){
               layout->list.rect.top = 1;
          }

          for(int64_t i = 0; i < layout->list.layout_count; i++){
              ce_layout_resize_for_tabline(layout->list.layouts[i]);
          }
     } break;
     case CE_LAYOUT_TYPE_TAB:
          if(layout->tab.rect.top == 0){
               layout->tab.rect.top = 1;
          }
          ce_layout_resize_for_tabline(layout->tab.root);
          break;
     case CE_LAYOUT_TYPE_TAB_LIST:
          if(layout->tab_list.rect.top == 0){
               layout->tab_list.rect.top = 1;
          }
          for(int64_t i = 0; i < layout->tab_list.tab_count; i++){
               ce_layout_resize_for_tabline(layout->tab_list.tabs[i]);
          }
          break;
     }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rbx), %eax
cmpl $0x2, %eax
jne 0x1dd07
cmpq $0x0, 0x28(%rbx)
jne 0x1dd01
movq $0x1, 0x28(%rbx)
movq 0x8(%rbx), %rbx
jmp 0x1dceb
cmpl $0x3, %eax
je 0x1dd26
cmpl $0x1, %eax
je 0x1dd57
testl %eax, %eax
jne 0x1dd86
cmpq $0x0, 0x18(%rbx)
jne 0x1dd86
movq $0x1, 0x18(%rbx)
jmp 0x1dd86
cmpq $0x0, 0x30(%rbx)
jne 0x1dd35
movq $0x1, 0x30(%rbx)
cmpq $0x0, 0x18(%rbx)
jle 0x1dd86
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1dce4
incq %r14
cmpq 0x18(%rbx), %r14
jl 0x1dd3f
jmp 0x1dd86
cmpq $0x0, 0x30(%rbx)
jne 0x1dd66
movq $0x1, 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
jle 0x1dd86
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1dce4
incq %r14
cmpq 0x10(%rbx), %r14
jl 0x1dd70
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_view_init
CeLayout_t* ce_layout_view_init(CeBuffer_t* buffer){
     CeLayout_t* view_layout = calloc(1, sizeof(*view_layout));
     if(!view_layout) return NULL;
     view_layout->type = CE_LAYOUT_TYPE_VIEW;
     view_layout->view.buffer = buffer;
     view_layout->view.user_data = calloc(1, sizeof(CeAppViewData_t));
     return view_layout;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x60, %esi
callq 0xd380
movq %rax, %rbx
testq %rax, %rax
je 0x1ddc3
movq %r14, 0x48(%rbx)
movl $0x1, %edi
movl $0x4120, %esi           # imm = 0x4120
callq 0xd380
movq %rax, 0x50(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_free
void ce_layout_free(CeLayout_t** root){
     CeLayout_t* layout = *root;
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          free(layout->view.user_data);
          layout->view.user_data = NULL;
          break;
     case CE_LAYOUT_TYPE_LIST:
          for(int64_t i = 0; i < layout->list.layout_count; i++){
               if(layout->list.layouts[i] != NULL){
                    ce_layout_free(&layout->list.layouts[i]);
               }
          }
          free(layout->list.layouts);
          layout->list.layout_count = 0;
          break;
     case CE_LAYOUT_TYPE_TAB:
          ce_layout_free(&layout->tab.root);
          break;
     case CE_LAYOUT_TYPE_TAB_LIST:
          for(int64_t i = 0; i < layout->tab_list.tab_count; i++){
               ce_layout_free(&layout->tab_list.tabs[i]);
          }
          free(layout->tab_list.tabs);
          layout->tab_list.tab_count = 0;
          break;
     }

     free(*root);
     *root = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movl (%r14), %eax
cmpq $0x3, %rax
ja 0x1de99
leaq 0x11e00(%rip), %rcx     # 0x2fbf0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x50(%r14), %rdi
callq 0xd090
movq $0x0, 0x50(%r14)
jmp 0x1de99
addq $0x8, %r14
movq %r14, %rdi
callq 0x1ddce
jmp 0x1de99
cmpq $0x0, 0x18(%r14)
jle 0x1de43
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
addq %r15, %rdi
callq 0x1ddce
incq %r12
addq $0x8, %r15
cmpq 0x18(%r14), %r12
jl 0x1de2a
movq 0x8(%r14), %rdi
callq 0xd090
movq $0x0, 0x18(%r14)
jmp 0x1de99
movq 0x10(%r14), %rax
testq %rax, %rax
jle 0x1de88
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
cmpq $0x0, (%rdi,%r15)
je 0x1de7c
addq %r15, %rdi
callq 0x1ddce
movq 0x10(%r14), %rax
incq %r12
addq $0x8, %r15
cmpq %rax, %r12
jl 0x1de65
movq 0x8(%r14), %rdi
callq 0xd090
movq $0x0, 0x10(%r14)
movq (%rbx), %rdi
callq 0xd090
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_find_parent
CeLayout_t* ce_layout_find_parent(CeLayout_t* root, CeLayout_t* node){
     switch(root->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          break;
     case CE_LAYOUT_TYPE_LIST:
          for(int64_t i = 0; i < root->list.layout_count; i++){
               if(root->list.layouts[i] == node) return root;
               CeLayout_t* found = ce_layout_find_parent(root->list.layouts[i], node);
               if(found) return found;
          }
          break;
     case CE_LAYOUT_TYPE_TAB:
          if(root->tab.root == node) return root;
          else return ce_layout_find_parent(root->tab.root, node);
          break;
     case CE_LAYOUT_TYPE_TAB_LIST:
          for(int64_t i = 0; i < root->tab_list.tab_count; i++){
               if(root->tab_list.tabs[i] == node) return root;
               CeLayout_t* found = ce_layout_find_parent(root->tab_list.tabs[i], node);
               if(found) return found;
          }
          break;
     }

     return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
jne 0x1e130
movq 0x8(%rbx), %rdi
cmpq %r14, %rdi
jne 0x1e11b
jmp 0x1e19a
cmpl $0x3, %eax
je 0x1e16a
cmpl $0x1, %eax
jne 0x1e198
movq 0x10(%rbx), %r15
testq %r15, %r15
jle 0x1e198
movq 0x8(%rbx), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
cmpq %r14, %rdi
je 0x1e19a
movq %r14, %rsi
callq 0x1e10f
testq %rax, %rax
jne 0x1e1a7
incq %r13
cmpq %r13, %r15
jne 0x1e14a
jmp 0x1e198
movq 0x18(%rbx), %r15
testq %r15, %r15
jle 0x1e198
movq 0x8(%rbx), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
cmpq %r14, %rdi
je 0x1e19a
movq %r14, %rsi
callq 0x1e10f
testq %rax, %rax
jne 0x1e1a7
incq %r13
cmpq %r13, %r15
jne 0x1e17a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x1e19a
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_find_buffer
static CeBuffer_t* ce_layout_find_buffer(CeLayout_t* layout){
     switch(layout->type){
     default:
          break;
     case CE_LAYOUT_TYPE_VIEW:
          if(layout->view.buffer) return layout->view.buffer;
          break;
     case CE_LAYOUT_TYPE_LIST:
          for(int64_t i = 0; i < layout->list.layout_count; i++){
               CeBuffer_t* found = ce_layout_find_buffer(layout->list.layouts[i]);
               if(found) return found;
          }
          break;
     case CE_LAYOUT_TYPE_TAB:
          return ce_layout_find_buffer(layout->tab.root);
     case CE_LAYOUT_TYPE_TAB_LIST:
          for(int64_t i = 0; i < layout->tab_list.tab_count; i++){
               CeBuffer_t* buffer = ce_layout_find_buffer(layout->tab_list.tabs[i]);
               if(buffer) return buffer;
          }
          break;
     }

     return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
jne 0x1e1be
movq 0x8(%rdi), %rdi
jmp 0x1e1b1
testl %eax, %eax
je 0x1e1f4
cmpl $0x1, %eax
je 0x1e1ff
cmpl $0x3, %eax
jne 0x1e225
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
jle 0x1e225
movq 0x8(%rdi), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0x1e1ac
testq %rax, %rax
jne 0x1e227
incq %r15
cmpq %r15, %rbx
jne 0x1e1dc
jmp 0x1e225
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x1e227
jmp 0x1e225
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
jle 0x1e225
movq 0x8(%rdi), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0x1e1ac
testq %rax, %rax
jne 0x1e227
incq %r15
cmpq %r15, %rbx
jne 0x1e20f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: ce_layout_rect
static CeRect_t ce_layout_rect(CeLayout_t* layout){
     if(layout->type == CE_LAYOUT_TYPE_VIEW) return layout->view.rect;

     CeRect_t result = {};

     if(layout->type == CE_LAYOUT_TYPE_LIST){
          if(layout->list.layout_count <= 0) return result;
          result = ce_layout_rect(layout->list.layouts[0]);

          for(int64_t i = 1; i < layout->list.layout_count; i++){
               CeRect_t rect = ce_layout_rect(layout->list.layouts[i]);
               if(rect.left < result.left) result.left = rect.left;
               if(rect.right > result.right) result.right = rect.right;
               if(rect.top < result.top) result.top = rect.top;
               if(rect.bottom > result.bottom) result.bottom = rect.bottom;
          }

          return result;
     }

     return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
je 0x1e2f1
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpl $0x1, %eax
jne 0x1e302
cmpq $0x0, 0x10(%r14)
jle 0x1e302
movq 0x8(%r14), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1e22d
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpq $0x2, 0x10(%r14)
jl 0x1e302
movl $0x1, %r12d
leaq 0x8(%rsp), %r15
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x1e22d
movq 0x8(%rsp), %rax
cmpq (%rbx), %rax
jge 0x1e2b9
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
cmpq 0x8(%rbx), %rax
jle 0x1e2c8
movq %rax, 0x8(%rbx)
movq 0x18(%rsp), %rax
cmpq 0x10(%rbx), %rax
jge 0x1e2d7
movq %rax, 0x10(%rbx)
movq 0x20(%rsp), %rax
cmpq 0x18(%rbx), %rax
jle 0x1e2e6
movq %rax, 0x18(%rbx)
incq %r12
cmpq 0x10(%r14), %r12
jl 0x1e29c
jmp 0x1e302
movups 0x8(%r14), %xmm0
movups 0x18(%r14), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: resize_opposites_left
static void resize_opposites_left(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    int64_t bottom_start = layout->view.rect.top;

    for(int64_t i = layout->view.rect.top - 1; i >= rect.top; i--){
         CePoint_t point = {result->adjacent_old_value, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.right == result->adjacent_old_value){
              adjacent_layout->view.rect.right = result->adjacent_new_value;
              i = adjacent_layout->view.rect.top;
              if((adjacent_layout->view.rect.bottom + 1) > bottom_start) bottom_start = adjacent_layout->view.rect.bottom + 1;
         }else{
              break;
         }
    }

    for(int64_t i = bottom_start; i <= rect.bottom; i++){
         CePoint_t point = {result->adjacent_old_value, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.right == result->adjacent_old_value){
              adjacent_layout->view.rect.right = result->adjacent_new_value;
              i = adjacent_layout->view.rect.bottom;
         }else{
              break;
         }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpq %rdx, %rsi
jle 0x1e996
movq %rdx, %r13
movq %r12, %rdx
decq %rdx
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1e996
movq 0x10(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1e996
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r12, %rax
cmovgeq %rcx, %r12
cmpq %r13, %rdx
jg 0x1e958
cmpq %r14, %r12
jg 0x1e9ce
movq 0x8(%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x1ede6
testq %rax, %rax
je 0x1e9ce
movq 0x10(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1e9ce
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rax), %rax
leaq 0x1(%rax), %r12
cmpq %r14, %rax
jl 0x1e99b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: resize_shareds_left
static void resize_shareds_left(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    for(int64_t i = layout->view.rect.top - 1; i >= rect.top; i--){
         CePoint_t point = {layout->view.rect.left, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.left == layout->view.rect.left){
              adjacent_layout->view.rect.left = result->new_value;
              i = adjacent_layout->view.rect.top;
         }else{
              break;
         }
    }

    for(int64_t i = layout->view.rect.bottom + 1; i <= rect.bottom; i++){
         CePoint_t point = {layout->view.rect.left, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.left == layout->view.rect.left){
              adjacent_layout->view.rect.left = result->new_value;
              i = adjacent_layout->view.rect.bottom;
         }else{
              break;
         }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rsi), %rdx
cmpq %r13, %rdx
jle 0x1ea24
decq %rdx
movq 0x8(%r15), %rsi
movq %r12, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1ea24
movq 0x8(%rax), %rcx
cmpq 0x8(%r15), %rcx
jne 0x1ea24
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rax), %rdx
jmp 0x1e9f4
movq 0x20(%r15), %rdx
cmpq %r14, %rdx
jge 0x1ea58
incq %rdx
movq 0x8(%r15), %rsi
movq %r12, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1ea58
movq 0x8(%rax), %rcx
cmpq 0x8(%r15), %rcx
jne 0x1ea58
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rax), %rdx
jmp 0x1ea28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: resize_opposites_right
static void resize_opposites_right(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    int64_t bottom_start = layout->view.rect.top;
    for(int64_t i = layout->view.rect.top - 1; i >= rect.top; i--){
         CePoint_t point = {result->adjacent_old_value, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.left == result->adjacent_old_value){
              adjacent_layout->view.rect.left = result->adjacent_new_value;
              i = adjacent_layout->view.rect.top;
              if((adjacent_layout->view.rect.bottom + 1) > bottom_start) bottom_start = adjacent_layout->view.rect.bottom + 1;
         }else{
              break;
         }
    }

    for(int64_t i = bottom_start; i <= rect.bottom; i++){
         CePoint_t point = {result->adjacent_old_value, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.left == result->adjacent_old_value){
              adjacent_layout->view.rect.left = result->adjacent_new_value;
              i = adjacent_layout->view.rect.bottom;
         }else{
              break;
         }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpq %rdx, %rsi
jle 0x1eac0
movq %rdx, %r13
movq %r12, %rdx
decq %rdx
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1eac0
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1eac0
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r12, %rax
cmovgeq %rcx, %r12
cmpq %r13, %rdx
jg 0x1ea82
cmpq %r14, %r12
jg 0x1eaf8
movq 0x8(%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x1ede6
testq %rax, %rax
je 0x1eaf8
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1eaf8
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rax), %rax
leaq 0x1(%rax), %r12
cmpq %r14, %rax
jl 0x1eac5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_layout.c
// Function: resize_shareds_right
static void resize_shareds_right(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    for(int64_t i = layout->view.rect.top - 1; i >= rect.top; i--){
         CePoint_t point = {layout->view.rect.right, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.right == layout->view.rect.right){
              adjacent_layout->view.rect.right = result->new_value;
              i = adjacent_layout->view.rect.top;
         }else{
              break;
         }
    }

    for(int64_t i = layout->view.rect.bottom + 1; i <= rect.bottom; i++){
         CePoint_t point = {layout->view.rect.right, i};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.right == layout->view.rect.right){
              adjacent_layout->view.rect.right = result->new_value;
              i = adjacent_layout->view.rect.bottom;
         }else{
              break;
         }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rsi), %rdx
cmpq %r13, %rdx
jle 0x1eb4e
decq %rdx
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1eb4e
movq 0x10(%rax), %rcx
cmpq 0x10(%r15), %rcx
jne 0x1eb4e
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rax), %rdx
jmp 0x1eb1e
movq 0x20(%r15), %rdx
cmpq %r14, %rdx
jge 0x1eb82
incq %rdx
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x1ede6
testq %rax, %rax
je 0x1eb82
movq 0x10(%rax), %rcx
cmpq 0x10(%r15), %rcx
jne 0x1eb82
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rax), %rdx
jmp 0x1eb52
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq