LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x5, %rsi
callq 0xd500
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd290
movq -0x10(%rbp), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x25750
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_json.c
// Function: array_copy
static void _array_copy(CeJsonArray_t* a, CeJsonArray_t* b){
     _array_free(a);
     for(int64_t i = 0; i < b->count; i++){
          CeJsonValue_t* value = b->values + i;
          switch(value->type){
          case CE_JSON_TYPE_OBJECT:
               ce_json_array_add_obj(a, &value->obj);
               break;
          case CE_JSON_TYPE_ARRAY:
               assert(!"array of arrays not yet supported.");
               break;
          case CE_JSON_TYPE_STRING:
               ce_json_array_add_string(a, value->string);
               break;
          case CE_JSON_TYPE_NUMBER:
               ce_json_array_add_number(a, value->number);
               break;
          case CE_JSON_TYPE_BOOL:
               ce_json_array_add_boolean(a, value->boolean);
               break;
          case CE_JSON_TYPE_NULL:
               ce_json_array_add_null(a);
               break;
          default:
               break;
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x254f0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x25855
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0x25840
movq -0x28(%rbp), %rax
leaq 0x1ee60(%rip), %rcx     # 0x4461c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x250c0
jmp 0x25842
leaq 0x1ee85(%rip), %rdi     # 0x44664
leaq 0x1eea4(%rip), %rsi     # 0x4468a
movl $0x3a, %edx
leaq 0x1eea2(%rip), %rcx     # 0x44694
callq 0xd270
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x25290
jmp 0x25842
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x25330
jmp 0x25842
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x253c0
jmp 0x25842
movq -0x8(%rbp), %rdi
callq 0x25450
jmp 0x25842
jmp 0x25842
jmp 0x25844
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x25771
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25620
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x5, %rsi
callq 0xd500
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd290
movq -0x10(%rbp), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x3, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25620
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x5, %rsi
callq 0xd500
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd290
movq -0x10(%rbp), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x4, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25620
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x5, %rsi
callq 0xd500
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd290
movq -0x10(%rbp), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x5, 0x8(%rax)
movb -0x11(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25620
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
shlq $0x5, %rsi
callq 0xd500
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd290
movq -0x10(%rbp), %rdi
callq 0xd620
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x6, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x25bbf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26830
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x25b84
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xd290
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %r8
leaq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x25c70
movq -0x10(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x1e25c(%rip), %rdx     # 0x43ea8
movb $0x0, %al
callq 0xd250
movslq %eax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x25e40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xd290
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x25efb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xd370
cmpl $0x0, %eax
jne 0x25eeb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25efd
jmp 0x25eed
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x25e98
jmp 0x25efd
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0xd290
movq $0x1, -0x28(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
leaq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x26120
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x26108
movq -0x10(%rbp), %rdi
callq 0x25b50
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x267f0
jmp 0x267dc
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x267ff
jmp 0x267e6
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x2680e
jmp 0x2681d
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x25b70
jmp 0x2681f
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x254f0
jmp 0x2681f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd090
jmp 0x2681f
jmp 0x2681f
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_json.c
// Function: make_indentation
static void _make_indentation(char* indentation, uint64_t max_size, uint64_t current_indent){
     uint64_t size = (current_indent < (max_size - 1)) ? current_indent : (max_size - 1);
     for(uint64_t i = 0; i < size; i++){
          indentation[i] = ' ';
     }
     indentation[size] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2689b
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x268a7
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x268db
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x268b7
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_json.c
// Function: field_print
static void _field_print(CeJsonField_t* field, char* string, PrintState_t* print_state,
                         uint64_t current_indent, uint64_t indent){
     char indentation[MAX_INDENTATION];
     _make_indentation(indentation, MAX_INDENTATION, current_indent);
     _print_state_update(print_state, snprintf(string + print_state->printed, print_state->remaining,
                                               "%s\"%s\" : ", indentation, field->name));
     _value_print(&field->value, string, print_state, current_indent, indent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x430(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x26870
movq -0x18(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
addq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x430(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %r8
leaq 0x1dd7a(%rip), %rdx     # 0x446d1
movb $0x0, %al
callq 0xd250
movq -0x438(%rbp), %rdi
movslq %eax, %rsi
callq 0x25e40
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x269a0
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x27690
testb $0x1, %al
jne 0x26dc1
jmp 0x26dcc
movq -0x8(%rbp), %rdi
callq 0x27510
jmp 0x26df0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x27620
testb $0x1, %al
jne 0x26de1
jmp 0x26dec
movq -0x8(%rbp), %rdi
callq 0x27650
jmp 0x26dee
jmp 0x26df2
jmp 0x26df0
jmp 0x26dac
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_json.c
// Function: transition_obj_stage
static void _transition_obj_stage(ObjParseStage_t* current_stage, ObjParseStage_t new_stage,
                                  ParsePos_t* pos, bool verbose){
     if(verbose){
          printf("obj parse stage change: %d -> %d at %" PRId64 ", %" PRId64 " at %c\n",
                 *current_stage, new_stage, pos->x, pos->y, *pos->str);
     }
     *current_stage = new_stage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x26e52
movq -0x8(%rbp), %rax
movl (%rax), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %r9d
leaq 0x1db37(%rip), %rdi     # 0x44982
movb $0x0, %al
callq 0xd230
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_json.c
// Function: parse_number
static bool _parse_number(ParsePos_t* pos, double* result){
     char* end = NULL;
     *result = strtod(pos->str, &end);
     if(pos->str >= end){
          return false;
     }
     uint64_t string_len = (end - pos->str);
     // Go to the last number in the string, so that when we advance in the state machine, we can
     // consume the next token.
     advance_parse_pos_len(pos, string_len - 1);
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd160
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jb 0x27053
movb $0x0, -0x1(%rbp)
jmp 0x2707a
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
subq $0x1, %rsi
callq 0x276c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1d187(%rip), %rsi     # 0x446e5
movl $0x4, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x27588
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x276c0
movb $0x1, -0x1(%rbp)
jmp 0x275c4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1d154(%rip), %rsi     # 0x446ea
movl $0x5, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x275c0
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x276c0
movb $0x1, -0x1(%rbp)
jmp 0x275c4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_json.c
// Function: parse_null
static bool _parse_null(ParsePos_t* pos){
     if(strncmp(pos->str, "null", 4) == 0){
          advance_parse_pos_len(pos, 3);
          return true;
     }
     return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1d106(%rip), %rsi     # 0x446f0
movl $0x4, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x2760d
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x276c0
movb $0x1, -0x1(%rbp)
jmp 0x27611
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_json.c
// Function: transition_array_stage
static void _transition_array_stage(ArrayParseStage_t* current_stage, ArrayParseStage_t new_stage,
                                    ParsePos_t* pos, bool verbose){
     if(verbose){
          printf("array parse stage change: %d -> %d at %" PRId64 ", %" PRId64 " at %c\n",
                 *current_stage, new_stage, pos->x, pos->y, *pos->str);
     }
     *current_stage = new_stage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x27742
movq -0x8(%rbp), %rax
movl (%rax), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %r9d
leaq 0x1d36b(%rip), %rdi     # 0x44aa6
movb $0x0, %al
callq 0xd230
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x60, %esi
callq 0xd360
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27790
movq $0x0, -0x8(%rbp)
jmp 0x277de
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movl $0x8, %edi
callq 0xd4a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x1, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x27807
jmp 0x27826
leaq 0x1d3ca(%rip), %rdi     # 0x44bd8
leaq 0x1d3f4(%rip), %rsi     # 0x44c09
movl $0x37, %edx
leaq 0x1d3f4(%rip), %rcx     # 0x44c15
callq 0xd270
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x28(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x30(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rsi
shlq $0x3, %rsi
callq 0xd500
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x27887
movq $0x0, -0x8(%rbp)
jmp 0x27936
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rdi
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x27940
movq %rax, %rdx
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x2791e
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x279f0
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x278f5
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27b20
movq -0x28(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x20(%rax)
movl $0x1, %edi
movl $0x60, %esi
callq 0xd360
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x279b5
movq -0x18(%rbp), %rdi
callq 0xd090
movq $0x0, -0x8(%rbp)
jmp 0x279df
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x27a20
movq -0x20(%rbp), %rax
leaq 0x1d0c9(%rip), %rcx     # 0x44ae0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x27b0b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x27a3c
movq -0x8(%rbp), %rax
movq $0x1, 0x18(%rax)
jmp 0x27b0b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x27a58
movq -0x8(%rbp), %rax
movq $0x1, 0x30(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x27a91
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x279f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x27a60
jmp 0x27b0b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x27aaa
movq -0x8(%rbp), %rax
movq $0x1, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x279f0
jmp 0x27b0b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x27ad0
movq -0x8(%rbp), %rax
movq $0x1, 0x30(%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x27b09
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x279f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x27ad8
jmp 0x27b0b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x60, %esi
callq 0xd360
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27b50
movq $0x0, -0x8(%rbp)
jmp 0x27b88
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x1, %edi
movl $0x4120, %esi           # imm = 0x4120
callq 0xd360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0x27bdb
movq -0x28(%rbp), %rax
leaq 0x1cf1e(%rip), %rcx     # 0x44af0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x27cce
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xd090
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
jmp 0x27cce
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x27c4f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x27c3f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x27ba0
jmp 0x27c41
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x27c06
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd090
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x27cce
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x27ba0
jmp 0x27cce
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x27cb5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x27ba0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x27c81
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd090
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x40(%rbp)
subq $0x3, %rax
ja 0x281e4
movq -0x40(%rbp), %rax
leaq 0x1c925(%rip), %rcx     # 0x44b00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x28315
jmp 0x28315
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x28268
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x28227
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2831d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x281b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x28258
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2831d
jmp 0x2825a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x281f6
jmp 0x28315
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x28288
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2831d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x281b0
movq %rax, -0x8(%rbp)
jmp 0x2831d
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x28313
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x282d5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2831d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x281b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x28303
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2831d
jmp 0x28305
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x282a7
jmp 0x28315
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x3, %rax
ja 0x28360
movq -0x38(%rbp), %rax
leaq 0x1c7b9(%rip), %rcx     # 0x44b10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2843d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x28381
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x28445
jmp 0x2843d
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x283d6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x28330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x283c6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28445
jmp 0x283c8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2838e
jmp 0x2843d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28330
movq %rax, -0x8(%rbp)
jmp 0x28445
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x2843b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x28330
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2842b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28445
jmp 0x2842d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x283f3
jmp 0x2843d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x28499
movq -0x60(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x20(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x285ad
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd290
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x285ab
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jg 0x284c6
jmp 0x285ad
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x28450
movq -0x60(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x285a9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x50(%rbp), %rdi
callq 0x28450
movq -0x60(%rbp), %rcx
movq -0x50(%rbp), %rax
cmpq (%rcx), %rax
jge 0x28548
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq 0x8(%rcx), %rax
jle 0x28562
movq -0x60(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x10(%rcx), %rax
jge 0x2857c
movq -0x60(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq 0x18(%rcx), %rax
jle 0x28596
movq -0x60(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x28598
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x28505
jmp 0x285ad
jmp 0x285ad
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jl 0x294bb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x29d60
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x294a9
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x294a9
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x294ab
jmp 0x294bb
jmp 0x294ad
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2943c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x18(%rcx), %rax
jg 0x2954a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x29d60
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x29538
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x29538
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2953a
jmp 0x2954a
jmp 0x2953c
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x294cb
addq $0x60, %rsp
popq %rbp
retq