LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r15
jge 0x1a93a
addq %r14, %rdi
callq 0x1b804
incq %r15
addq $0x18, %r14
jmp 0x1a920
callq 0xd090
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a9c7
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)
andq $0x0, 0x8(%r12)
movq %r15, %rdi
callq 0xd640
movq %rax, -0x10(%r12)
movl $0x1, -0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x1a70f
movq %r13, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq 0x8(%r14), %r13
jge 0x1aa09
movq (%r14), %r15
movq (%r15,%r12), %rdi
movq %rbx, %rsi
callq 0xd390
testl %eax, %eax
jne 0x1aa00
addq %r12, %r15
movq %r15, %rdi
callq 0x1b83d
incq %r13
addq $0x20, %r12
jmp 0x1a9dc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: ce_json_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
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
incq %rsi
movq %rsi, (%rsp)
shlq $0x5, %rsi
callq 0xd520
movq %rax, (%r14)
movq 0x8(%r14), %rcx
shlq $0x5, %rcx
xorps %xmm0, %xmm0
leaq (%rax,%rcx), %r15
addq $0x10, %r15
movups %xmm0, -0x8(%r15)
andq $0x0, 0x8(%r15)
movq %r12, %rdi
callq 0xd640
movq %rax, -0x10(%r15)
movl $0x2, -0x8(%r15)
movq %r15, %rdi
callq 0x1a912
pushq $0x8
popq %r12
xorl %ebp, %ebp
leaq 0x11c29(%rip), %r13     # 0x2c6b0
cmpq 0x8(%rbx), %rbp
jge 0x1aaf1
movq (%rbx), %rsi
movl -0x8(%rsi,%r12), %eax
decl %eax
cmpl $0x5, %eax
ja 0x1aae8
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
addq %r12, %rsi
movq %r15, %rdi
callq 0x1a6bc
jmp 0x1aae8
movq (%rsi,%r12), %rsi
movq %r15, %rdi
callq 0x1a7d7
jmp 0x1aae8
movq %r15, %rdi
callq 0x1a8ce
jmp 0x1aae8
movzbl (%rsi,%r12), %esi
movq %r15, %rdi
callq 0x1a887
jmp 0x1aae8
movsd (%rsi,%r12), %xmm0
movq %r15, %rdi
callq 0x1a835
incq %rbp
addq $0x18, %r12
jmp 0x1aa87
movq (%rsp), %rax
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11be9(%rip), %rdi     # 0x2c6f8
leaq 0x11c08(%rip), %rsi     # 0x2c71e
leaq 0x11c0b(%rip), %rcx     # 0x2c728
pushq $0x3a
popq %rdx
callq 0xd280
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_json.c
// Function: ce_json_obj_set_string
void ce_json_obj_set_string(CeJsonObj_t* obj, const char* name, const char* string){
     _obj_free_field_of_name(obj, name);
     uint64_t new_count = obj->count + 1;
     obj->fields = realloc(obj->fields, new_count * sizeof(obj->fields[0]));
     CeJsonField_t* new_field = obj->fields + obj->count;
     memset(new_field, 0, sizeof(*new_field));
     new_field->name = strdup(name);
     new_field->value.type = CE_JSON_TYPE_STRING;
     new_field->value.string = strdup(string);
     obj->count = new_count;
}

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1a9c7
movq (%rbx), %rdi
movq 0x8(%rbx), %r12
incq %r12
movq %r12, %rsi
shlq $0x5, %rsi
callq 0xd520
movq %rax, %r15
movq %rax, (%rbx)
movq 0x8(%rbx), %r13
shlq $0x5, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax,%r13)
andq $0x0, 0x18(%rax,%r13)
movq %r14, %rdi
callq 0xd640
movq %rax, (%r15,%r13)
movl $0x6, 0x8(%r15,%r13)
movq %r12, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r15
jge 0x1ad35
addq %r14, %rdi
callq 0x1b83d
incq %r15
addq $0x20, %r14
jmp 0x1ad1b
callq 0xd090
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%r14)
movq %rdx, 0x8(%r14)
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1ad89
addq (%r14), %rbx
movq 0x8(%r14), %rsi
leaq 0x11179(%rip), %rdx     # 0x2bef1
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xd260
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %r13
xorl %eax, %eax
testq %r13, %r13
cmovleq %rax, %r13
pushq $0x8
popq %rbp
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x1af70
movq (%r12), %rbx
movq -0x8(%rbx,%rbp), %rdi
movq %r15, %rsi
callq 0xd390
testl %eax, %eax
je 0x1af77
incq %r14
addq $0x20, %rbp
jmp 0x1af4d
xorl %r14d, %r14d
xorl %eax, %eax
jmp 0x1af7a
movl (%rbx,%rbp), %eax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_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
pushq $0x1
popq %rcx
movq %rsp, %rax
movq %rcx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rdi, (%rax)
movq %rax, %rdi
callq 0x1b04a
movl %eax, %ebp
testb %al, %al
jne 0x1b041
movq %rbx, %rdi
callq 0x1ad0d
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b82f
cmpl $0x2, %eax
je 0x1b824
cmpl $0x1, %eax
jne 0x1b838
leaq 0x8(%rbx), %rdi
callq 0x1ad0d
jmp 0x1b838
leaq 0x8(%rbx), %rdi
callq 0x1a912
jmp 0x1b838
movq 0x8(%rbx), %rdi
callq 0xd090
andl $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl $0x3ff, %eax            # imm = 0x3FF
cmpq %rax, %rsi
cmovbq %rsi, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1b874
movb $0x20, (%rdi,%rcx)
incq %rcx
jmp 0x1b866
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rcx
movzbl -0x1(%rax), %edx
cmpl $0x20, %edx
je 0x1bb07
cmpl $0xa, %edx
je 0x1bb10
cmpl $0xd, %edx
je 0x1bb10
cmpl $0x9, %edx
jne 0x1bb23
movq 0x8(%rdi), %rdx
incq %rdx
jmp 0x1bb17
incq 0x10(%rdi)
movq %rcx, %rdx
movq %rdx, 0x8(%rdi)
movq %rax, (%rdi)
incq %rax
jmp 0x1baef
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %ecx, %ecx
je 0x1bb53
movl (%r14), %esi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %r8
movsbl (%rax), %r9d
leaq 0x10ea6(%rip), %rdi     # 0x2c9f0
movl %ebx, %edx
xorl %eax, %eax
callq 0xd240
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq (%rdi), %rbx
leaq 0x1(%rbx), %rcx
xorl %edi, %edi
movabsq $0x400000000002001, %rdx # imm = 0x400000000002001
movl $0xd1011, %esi          # imm = 0xD1011
movzbl -0x1(%rcx), %r8d
xorl %eax, %eax
cmpl $0xa, %r8d
je 0x1bc10
cmpl $0xd, %r8d
je 0x1bc10
testb $0x1, %dil
je 0x1bbc1
xorl %edi, %edi
leal -0x62(%r8), %eax
cmpl $0x13, %eax
ja 0x1bbad
btl %eax, %esi
jb 0x1bbd2
movb $0x1, %al
addl $-0x22, %r8d
cmpl $0x3a, %r8d
ja 0x1bc10
btq %r8, %rdx
jb 0x1bbd2
jmp 0x1bc10
movb $0x1, %dil
cmpl $0x5c, %r8d
je 0x1bbd2
cmpl $0x22, %r8d
je 0x1bbde
xorl %edi, %edi
incq 0x8(%r15)
movq %rcx, (%r15)
incq %rcx
jmp 0x1bb84
movq (%r14), %rdi
callq 0xd090
movq (%r15), %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_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq (%rdi), %rdi
movq %r15, %rsi
callq 0xd170
movsd %xmm0, (%r14)
movq (%rbx), %rax
movq (%r15), %rcx
cmpq %rcx, %rax
jae 0x1bc62
movq %rax, %rdx
notq %rdx
addq %rcx, %rdx
addq %rdx, 0x8(%rbx)
addq %rax, %rdx
movq %rdx, (%rbx)
cmpq %rcx, %rax
setb %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10aef(%rip), %rsi     # 0x2c779
pushq $0x4
popq %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0xd0d0
movb $0x1, %bpl
testl %eax, %eax
je 0x1bcbc
leaq 0x10ad7(%rip), %rsi     # 0x2c77e
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0xd0d0
xorl %ecx, %ecx
testl %eax, %eax
je 0x1bcc2
xorl %ebp, %ebp
jmp 0x1bccf
pushq $0x3
popq %r12
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x10a99(%rip), %rsi     # 0x2c784
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0xd0d0
testl %eax, %eax
jne 0x1bd06
addq $0x3, 0x8(%rbx)
addq $0x3, %r14
movq %r14, (%rbx)
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %ecx, %ecx
je 0x1bd42
movl (%r14), %esi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %r8
movsbl (%rax), %r9d
leaq 0x10d3d(%rip), %rdi     # 0x2ca76
movl %ebx, %edx
xorl %eax, %eax
callq 0xd240
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
callq 0xd380
movq %rax, %r14
testq %rax, %rax
je 0x1bd8c
movl $0x3, (%r14)
pushq $0x8
popq %rdi
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_O2/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 0x1be44
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 0x1be36
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 0x1be61
movq 0x18(%rbx), %rcx
movq %rax, (%r14,%rcx,8)
movq %r12, 0x18(%rbx)
xorl %r12d, %r12d
cmpq %r15, %r12
jg 0x1be2b
movq (%r14,%r12,8), %rdi
callq 0x1beb6
incq %r12
jmp 0x1be18
movq 0x18(%rbx), %rax
movq -0x8(%r14,%rax,8), %rax
jmp 0x1be38
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x10de5(%rip), %rdi     # 0x2cc30
leaq 0x10e0f(%rip), %rsi     # 0x2cc61
leaq 0x10e14(%rip), %rcx     # 0x2cc6d
pushq $0x37
popq %rdx
callq 0xd280
// File: /workspace/github_c_makefile_star2_O2/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 0x1bf55
movq %rax, %rbx
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm0, 0x8(%rax)
movups %xmm1, 0x18(%rax)
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
callq 0xd380
movq %rax, %r14
testq %rax, %rax
je 0x1bea3
movl $0x2, (%r14)
movq %rbx, 0x8(%r14)
movq %rbx, 0x10(%r14)
jmp 0x1beab
movq %rbx, %rdi
callq 0xd090
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x10ca4(%rip), %rax     # 0x2cb68
movl (%rbx), %ecx
cmpq $0x3, %rcx
ja 0x1bef9
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpq $0x0, 0x28(%rbx)
jne 0x1bee4
movq $0x1, 0x28(%rbx)
movq 0x8(%rbx), %rbx
jmp 0x1bec4
cmpq $0x0, 0x18(%rbx)
jne 0x1bef9
movq $0x1, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq $0x0, 0x30(%rbx)
jne 0x1bf10
movq $0x1, 0x30(%rbx)
xorl %r14d, %r14d
cmpq 0x10(%rbx), %r14
jge 0x1bef9
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1beb6
incq %r14
jmp 0x1bf13
cmpq $0x0, 0x30(%rbx)
jne 0x1bf3a
movq $0x1, 0x30(%rbx)
xorl %r14d, %r14d
cmpq 0x18(%rbx), %r14
jge 0x1bef9
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1beb6
incq %r14
jmp 0x1bf3d
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
callq 0xd380
movq %rax, %rbx
testq %rax, %rax
je 0x1bf84
movq %r14, 0x48(%rbx)
pushq $0x1
popq %rdi
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_O2/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 0x1c037
leaq 0x10bc7(%rip), %rcx     # 0x2cb78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x50(%r14), %rdi
callq 0xd090
andq $0x0, 0x50(%r14)
jmp 0x1c037
addq $0x8, %r14
movq %r14, %rdi
callq 0x1bf8f
jmp 0x1c037
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
cmpq 0x18(%r14), %r12
jge 0x1bff9
addq %r15, %rdi
callq 0x1bf8f
incq %r12
addq $0x8, %r15
jmp 0x1bfde
callq 0xd090
andq $0x0, 0x18(%r14)
jmp 0x1c037
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
cmpq 0x10(%r14), %r12
jge 0x1c02d
cmpq $0x0, (%rdi,%r15)
je 0x1c024
addq %r15, %rdi
callq 0x1bf8f
incq %r12
addq $0x8, %r15
jmp 0x1c00b
callq 0xd090
andq $0x0, 0x10(%r14)
movq (%rbx), %rdi
callq 0xd090
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
jne 0x1c2c3
movq 0x8(%rbx), %rdi
cmpq %r14, %rdi
jne 0x1c2ae
jmp 0x1c33a
cmpl $0x3, %eax
je 0x1c301
cmpl $0x1, %eax
jne 0x1c338
movq 0x10(%rbx), %r15
xorl %eax, %eax
testq %r15, %r15
cmovleq %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x1c338
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
cmpq %r14, %rdi
je 0x1c33a
movq %r14, %rsi
callq 0x1c2a3
incq %r12
testq %rax, %rax
je 0x1c2dd
jmp 0x1c333
movq 0x18(%rbx), %r15
xorl %eax, %eax
testq %r15, %r15
cmovleq %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x1c338
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
cmpq %r14, %rdi
je 0x1c33a
movq %r14, %rsi
callq 0x1c2a3
incq %r12
testq %rax, %rax
je 0x1c311
movq %rax, %rbx
jmp 0x1c33a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
leaq 0x10830(%rip), %rax     # 0x2cb88
movl (%rbx), %ecx
cmpq $0x3, %rcx
ja 0x1c378
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rbx), %rbx
jmp 0x1c358
movq 0x48(%rbx), %rax
testq %rax, %rax
jne 0x1c37a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%rbx), %r14
xorl %r15d, %r15d
testq %r14, %r14
cmovleq %r15, %r14
cmpq %r15, %r14
je 0x1c378
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1c349
incq %r15
testq %rax, %rax
je 0x1c38e
jmp 0x1c37a
movq 0x18(%rbx), %r14
xorl %r15d, %r15d
testq %r14, %r14
cmovleq %r15, %r14
cmpq %r15, %r14
je 0x1c378
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1c349
incq %r15
testq %rax, %rax
je 0x1c3b8
jmp 0x1c37a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
je 0x1c482
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpl $0x1, %eax
jne 0x1c4a8
cmpq $0x0, 0x10(%r14)
jle 0x1c4a8
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1c3d4
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rbp
movq %rbx, (%rsp)
movq 0x18(%rbx), %r13
pushq $0x1
popq %rbx
cmpq 0x10(%r14), %rbx
jge 0x1c495
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1c3d4
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %r12, %rax
cmovlq %rax, %r12
cmpq %r15, %rcx
cmovgq %rcx, %r15
movq 0x18(%rsp), %rax
cmpq %rbp, %rax
cmovlq %rax, %rbp
movq 0x20(%rsp), %rax
cmpq %r13, %rax
cmovgq %rax, %r13
incq %rbx
jmp 0x1c435
movups 0x8(%r14), %xmm0
movups 0x18(%r14), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x1c4a8
movq (%rsp), %rbx
movq %r15, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq %r12, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_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 %rdx, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq 0x18(%rsi), %rdx
movq 0x10(%r12), %r13
movq %rdx, %r15
cmpq %r13, %rdx
jle 0x1cbe0
decq %rdx
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1cbe0
movq 0x10(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1cbe0
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r15, %rax
cmovgeq %rcx, %r15
jmp 0x1cba0
movq 0x18(%r12), %r12
cmpq %r12, %r15
jg 0x1cc19
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1d04c
testq %rax, %rax
je 0x1cc19
movq 0x10(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1cc19
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rax), %r15
incq %r15
jmp 0x1cbe5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %r12
movq 0x10(%r12), %r13
movq %rsi, %rax
movq 0x18(%rax), %rdx
cmpq %r13, %rdx
jle 0x1cc72
decq %rdx
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1cc72
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x1cc72
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1cc42
movq 0x18(%r12), %r12
movq %r14, %rax
movq 0x20(%rax), %rdx
cmpq %r12, %rdx
jge 0x1ccaa
incq %rdx
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1ccaa
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x1ccaa
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1cc7a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq 0x18(%rsi), %rdx
movq 0x10(%r12), %r13
movq %rdx, %r15
cmpq %r13, %rdx
jle 0x1cd14
decq %rdx
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1cd14
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1cd14
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r15, %rax
cmovgeq %rcx, %r15
jmp 0x1ccd4
movq 0x18(%r12), %r12
cmpq %r12, %r15
jg 0x1cd4d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1d04c
testq %rax, %rax
je 0x1cd4d
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1cd4d
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rax), %r15
incq %r15
jmp 0x1cd19
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %r12
movq 0x10(%r12), %r13
movq %rsi, %rax
movq 0x18(%rax), %rdx
cmpq %r13, %rdx
jle 0x1cda6
decq %rdx
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1cda6
movq 0x10(%rax), %rcx
cmpq 0x10(%r14), %rcx
jne 0x1cda6
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x1cd76
movq 0x18(%r12), %r12
movq %r14, %rax
movq 0x20(%rax), %rdx
cmpq %r12, %rdx
jge 0x1cdde
incq %rdx
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1cdde
movq 0x10(%rax), %rcx
cmpq 0x10(%r14), %rcx
jne 0x1cdde
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x1cdae
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_layout.c
// Function: resize_opposites_up
static void resize_opposites_up(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    int64_t right_start = layout->view.rect.left;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq 0x8(%rsi), %rsi
movq (%r12), %r13
movq %rsi, %r15
cmpq %r13, %rsi
jle 0x1ce47
decq %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1ce47
movq 0x20(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1ce47
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r15, %rax
cmovgeq %rcx, %r15
jmp 0x1ce07
movq 0x8(%r12), %r12
cmpq %r12, %r15
jg 0x1ce80
movq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d04c
testq %rax, %rax
je 0x1ce80
movq 0x20(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1ce80
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rax), %r15
incq %r15
jmp 0x1ce4c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_layout.c
// Function: resize_shareds_up
static void resize_shareds_up(CeLayout_t* root, CeLayout_t* layout, CeRect_t rect, ResizeRectResult_t* result){
    for(int64_t i = layout->view.rect.left - 1; i >= rect.left; i--){
         CePoint_t point = {i, layout->view.rect.top};
         CeLayout_t* adjacent_layout = ce_layout_find_at(root, point);
         if(adjacent_layout && adjacent_layout->view.rect.top == layout->view.rect.top){
              adjacent_layout->view.rect.top = result->new_value;
              i = adjacent_layout->view.rect.left;
         }else{
              break;
         }
    }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %r12
movq (%r12), %r13
movq %rsi, %rax
movq 0x8(%rax), %rsi
cmpq %r13, %rsi
jle 0x1ced8
decq %rsi
movq 0x18(%r14), %rdx
movq %r15, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1ced8
movq 0x18(%rax), %rcx
cmpq 0x18(%r14), %rcx
jne 0x1ced8
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x1cea8
movq 0x8(%r12), %r12
movq %r14, %rax
movq 0x10(%rax), %rsi
cmpq %r12, %rsi
jge 0x1cf10
incq %rsi
movq 0x18(%r14), %rdx
movq %r15, %rdi
callq 0x1d04c
testq %rax, %rax
je 0x1cf10
movq 0x18(%rax), %rcx
cmpq 0x18(%r14), %rcx
jne 0x1cf10
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x1cee0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq