LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_get_array_item
json_object *json_get_array_item(json_object *json, int seq, json_object **prev)
{
    int count = 0;
    json_object *p = NULL, *pos = NULL, *n = NULL;

    if (json->type_member == JSON_ARRAY) {
        json_list_for_each_entry_safe(p, pos, n, &json->value.head, list, json_object) {
            if (count++ == seq) {
                if (prev)
                    *prev = p;
                return pos;
            }
        }
    }

    return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movq $0x0, -0x30(%rsp)
movq $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x38cc
movq -0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
movq -0x10(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x38ca
movl -0x24(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rsp)
cmpl -0x14(%rsp), %eax
jne 0x38a5
cmpq $0x0, -0x20(%rsp)
je 0x3899
movq -0x30(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x38(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x38d5
jmp 0x38a7
movq -0x38(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x40(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rsp)
jmp 0x385e
jmp 0x38cc
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_get_object_item
json_object *json_get_object_item(json_object *json, const char *key, json_object **prev)
{
    json_object *p = NULL, *pos = NULL, *n = NULL;

    if (json->type_member == JSON_OBJECT) {
        if (key && key[0]) {
            json_list_for_each_entry_safe(p, pos, n, &json->value.head, list, json_object) {
                if (pos->key_member && strcmp(key, pos->key_member) == 0) {
                    if (prev)
                        *prev = p;
                    return pos;
                }
            }
        } else {
            json_list_for_each_entry_safe(p, pos, n, &json->value.head, list, json_object) {
                if (!pos->jkey.len) {
                    if (prev)
                        *prev = p;
                    return pos;
                }
            }
        }
    }

    return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x3a7a
cmpq $0x0, 0x20(%rsp)
je 0x39e8
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x39e8
movq 0x28(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x39e3
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x39c1
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2180
cmpl $0x0, %eax
jne 0x39c1
cmpq $0x0, 0x18(%rsp)
je 0x39b2
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3a83
jmp 0x39c3
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x3966
jmp 0x3a78
movq 0x28(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x3a76
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
shrl $0x8, %eax
cmpl $0x0, %eax
jne 0x3a54
cmpq $0x0, 0x18(%rsp)
je 0x3a48
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3a83
jmp 0x3a56
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x3a10
jmp 0x3a78
jmp 0x3a7a
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_free_items
void json_free_items(json_items_t *items)
{
    if (items->items)
        json_free(items->items);
    items->items = NULL;
    items->conflicted = 0;
    items->total = 0;
    items->count = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3e6d
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_object_items_sort
static inline void json_object_items_sort(json_items_t *items)
{
    items->conflicted = 0;
    if (items->count > 1) {
        uint32_t i = 0;
        qsort(items->items, items->count, sizeof(json_item_t), _json_hash_cmp);
        for (i = 1; i < items->count; ++i) {
            if (items->items[i-1].hash == items->items[i].hash) {
                items->conflicted = 1;
                break;
            }
        }
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jbe 0x423e
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
movl $0x10, %edx
leaq 0x95f2(%rip), %rcx      # 0xd7c0
callq 0x2090
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x423c
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movl 0xc(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x422d
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x423c
jmp 0x422f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x41db
jmp 0x423e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_add_item_to_array
int json_add_item_to_array(json_object *array, json_object *item)
{
    if (array->type_member == JSON_ARRAY) {
        json_list_add_tail(&item->list, &array->value.head);
        return 0;
    }
    return -1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x4289
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movl $0x0, 0x14(%rsp)
jmp 0x4291
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_add_item_to_object
int json_add_item_to_object(json_object *object, json_object *item)
{
    if (object->type_member == JSON_OBJECT) {
        json_list_add_tail(&item->list, &object->value.head);
        return 0;
    }
    return -1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x42d9
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movl $0x0, 0x14(%rsp)
jmp 0x42e1
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_detach_item_from_array
json_object *json_detach_item_from_array(json_object *json, int seq)
{
    json_object *item = NULL, *prev = NULL;

    if ((item = json_get_array_item(json, seq, &prev)) == NULL)
        return NULL;
    json_list_del(&item->list, &prev->list, &json->value.head);

    return item;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
callq 0x21a0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x4335
movq $0x0, 0x20(%rsp)
jmp 0x4356
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0x25d0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_detach_item_from_object
json_object *json_detach_item_from_object(json_object *json, const char *key)
{
    json_object *item = NULL, *prev = NULL;

    if ((item = json_get_object_item(json, key, &prev)) == NULL)
        return NULL;
    json_list_del(&item->list, &prev->list, &json->value.head);

    return item;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rsp, %rdx
callq 0x2210
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x43a7
movq $0x0, 0x20(%rsp)
jmp 0x43c8
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0x25d0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_del_item_from_array
int json_del_item_from_array(json_object *json, int seq)
{
    json_object *item = NULL;

    if ((item = json_detach_item_from_array(json, seq)) == NULL)
        return -1;
    json_del_object(item);

    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x20c0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x4419
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x442b
movq 0x8(%rsp), %rdi
callq 0x22a0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_del_item_from_object
int json_del_item_from_object(json_object *json, const char *key)
{
    json_object *item = NULL;

    if ((item = json_detach_item_from_object(json, key)) == NULL)
        return -1;
    json_del_object(item);

    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x22d0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x447b
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x448d
movq 0x8(%rsp), %rdi
callq 0x22a0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_replace_item_in_array
int json_replace_item_in_array(json_object *array, int seq, json_object *new_item)
{
    json_object *item = NULL, *prev = NULL;

    if (array->type_member == JSON_ARRAY) {
        if ((item = json_get_array_item(array, seq, &prev)) != NULL) {
            json_list_del(&item->list, &prev->list, &array->value.head);
            json_del_object(item);
            json_list_add(&new_item->list, &prev->list, &array->value.head);
        } else {
            json_list_add_tail(&new_item->list, &array->value.head);
        }

        return 0;
    }

    return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x454b
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0x21a0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x452e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq $0x18, %rdx
callq 0x25d0
movq 0x10(%rsp), %rdi
callq 0x22a0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq $0x18, %rdx
callq 0x4560
jmp 0x4541
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movl $0x0, 0x34(%rsp)
jmp 0x4553
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_list_add
static inline void json_list_add(struct json_list *list, struct json_list *prev, struct json_list_head *head)
{
    if (prev->next == (struct json_list *)head) {
        head->prev = list;
    }
    list->next = prev->next;
    prev->next = list;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x458c
movq -0x8(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_replace_item_in_object
int json_replace_item_in_object(json_object *object, json_object *new_item)
{
    json_object *item = NULL, *prev = NULL;

    if (object->type_member == JSON_OBJECT) {
        if ((item = json_get_object_item(object, new_item->key_member, &prev)) != NULL) {
            json_list_del(&item->list, &prev->list, &object->value.head);
            json_del_object(item);
            json_list_add(&new_item->list, &prev->list, &object->value.head);
        } else {
            json_list_add_tail(&new_item->list, &object->value.head);
        }

        return 0;
    }

    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x4657
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq %rsp, %rdx
callq 0x2210
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x463a
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0x25d0
movq 0x8(%rsp), %rdi
callq 0x22a0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0x4560
jmp 0x464d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movl $0x0, 0x24(%rsp)
jmp 0x465f
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_copy_item_to_array
int json_copy_item_to_array(json_object *array, json_object *item)
{
    json_object *node = NULL;

    if (array->type_member == JSON_ARRAY) {
        if ((node = json_deepcopy(item)) == NULL) {
            JsonErr("copy failed!\n");
            return -1;
        }
        json_list_add_tail(&node->list, &array->value.head);
        return 0;
    }

    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x4a5d
movq 0x10(%rsp), %rdi
callq 0x2290
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x4a40
jmp 0x4a0e
leaq 0xee23(%rip), %rdi      # 0x13838
leaq 0xef47(%rip), %rsi      # 0x13963
movl $0x384, %edx            # imm = 0x384
movb $0x0, %al
callq 0x2100
leaq 0xeec7(%rip), %rdi      # 0x138f6
movb $0x0, %al
callq 0x2100
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x4a65
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movl $0x0, 0x24(%rsp)
jmp 0x4a65
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_copy_item_to_object
int json_copy_item_to_object(json_object *object, json_object *item)
{
    json_object *node = NULL;

    if (object->type_member == JSON_OBJECT) {
        if ((node = json_deepcopy(item)) == NULL) {
            JsonErr("copy failed!\n");
            return -1;
        }
        json_list_add_tail(&node->list, &object->value.head);
        return 0;
    }

    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x4afd
movq 0x10(%rsp), %rdi
callq 0x2290
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x4ae0
jmp 0x4aae
leaq 0xed83(%rip), %rdi      # 0x13838
leaq 0xeec0(%rip), %rsi      # 0x1397c
movl $0x394, %edx            # imm = 0x394
movb $0x0, %al
callq 0x2100
leaq 0xee27(%rip), %rdi      # 0x138f6
movb $0x0, %al
callq 0x2100
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x4b05
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movl $0x0, 0x24(%rsp)
jmp 0x4b05
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_add_new_item_to_array
json_object *json_add_new_item_to_array(json_object *array, json_type_t type, void *value)
{
    json_object *item = NULL;

    if (array->type_member == JSON_ARRAY) {
        switch (type) {
        case JSON_NULL:
        case JSON_BOOL:
        case JSON_INT:
        case JSON_HEX:
        case JSON_LINT:
        case JSON_LHEX:
        case JSON_DOUBLE:
        case JSON_STRING:
        case JSON_ARRAY:
        case JSON_OBJECT:
            if ((item = json_create_item(type, value)) == NULL) {
                JsonErr("create item failed!\n");
                return NULL;
            }
            json_list_add_tail(&item->list, &array->value.head);
            return item;
        default:
            JsonErr("not support json type.\n");
            return NULL;
        }
    }

    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x4be8
movl 0x14(%rsp), %eax
subl $0x9, %eax
ja 0x4bb3
jmp 0x4b49
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x22c0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x4b96
jmp 0x4b63
leaq 0xecce(%rip), %rdi      # 0x13838
leaq 0xee25(%rip), %rsi      # 0x13996
movl $0x3af, %edx            # imm = 0x3AF
movb $0x0, %al
callq 0x2100
leaq 0xed04(%rip), %rdi      # 0x13888
movb $0x0, %al
callq 0x2100
movq $0x0, 0x20(%rsp)
jmp 0x4bf1
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x4bf1
jmp 0x4bb5
leaq 0xec7c(%rip), %rdi      # 0x13838
leaq 0xedd3(%rip), %rsi      # 0x13996
movl $0x3b5, %edx            # imm = 0x3B5
movb $0x0, %al
callq 0x2100
leaq 0xec9a(%rip), %rdi      # 0x13870
movb $0x0, %al
callq 0x2100
movq $0x0, 0x20(%rsp)
jmp 0x4bf1
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_add_new_item_to_object
json_object *json_add_new_item_to_object(json_object *object, json_type_t type, json_string_t *jkey, void *value)
{
    json_object *item = NULL;

    if (object->type_member == JSON_OBJECT) {
        switch (type) {
        case JSON_NULL:
        case JSON_BOOL:
        case JSON_INT:
        case JSON_HEX:
        case JSON_LINT:
        case JSON_LHEX:
        case JSON_DOUBLE:
        case JSON_STRING:
        case JSON_ARRAY:
        case JSON_OBJECT:
            if ((item = json_create_item(type, value)) == NULL) {
                JsonErr("create item failed!\n");
                return NULL;
            }
            if (json_set_key(item, jkey) < 0) {
                JsonErr("add key failed!\n");
                json_del_object(item);
                return NULL;
            }
            json_list_add_tail(&item->list, &object->value.head);
            return item;
        default:
            JsonErr("not support json type.\n");
            return NULL;
        }
    }

    return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x4d3b
movl 0x24(%rsp), %eax
subl $0x9, %eax
ja 0x4d06
jmp 0x4c43
movl 0x24(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x22c0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x4c94
jmp 0x4c5e
leaq 0xebd3(%rip), %rdi      # 0x13838
leaq 0xed46(%rip), %rsi      # 0x139b2
movl $0x3ce, %edx            # imm = 0x3CE
movb $0x0, %al
callq 0x2100
leaq 0xec09(%rip), %rdi      # 0x13888
movb $0x0, %al
callq 0x2100
movq $0x0, 0x30(%rsp)
jmp 0x4d44
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4d50
cmpl $0x0, %eax
jge 0x4ce7
jmp 0x4caa
leaq 0xeb87(%rip), %rdi      # 0x13838
leaq 0xecfa(%rip), %rsi      # 0x139b2
movl $0x3d2, %edx            # imm = 0x3D2
movb $0x0, %al
callq 0x2100
leaq 0xec1a(%rip), %rdi      # 0x138e5
movb $0x0, %al
callq 0x2100
movq 0x8(%rsp), %rdi
callq 0x22a0
movq $0x0, 0x30(%rsp)
jmp 0x4d44
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x4d44
jmp 0x4d08
leaq 0xeb29(%rip), %rdi      # 0x13838
leaq 0xec9c(%rip), %rsi      # 0x139b2
movl $0x3d9, %edx            # imm = 0x3D9
movb $0x0, %al
callq 0x2100
leaq 0xeb47(%rip), %rdi      # 0x13870
movb $0x0, %al
callq 0x2100
movq $0x0, 0x30(%rsp)
jmp 0x4d44
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_mem_refresh
static void _json_mem_refresh(json_mem_mgr_t *mgr)
{
    json_mem_node_t *p = NULL, *pos = NULL, *n = NULL;
    int i = 0;
    json_list_for_each_entry_safe(p, pos, n, &mgr->head, list, json_mem_node_t) {
        if (++i == 1) {
            pos->cur = pos->ptr;
            mgr->cur_node = pos;
        } else {
            json_list_del(&pos->list, &p->list, &mgr->head);
            json_free(pos->ptr);
            json_free(pos);
            pos = p;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq %rcx, %rax
je 0x5003
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x1, %eax
jne 0x4fa5
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x4fdb
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x25d0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq 0x10(%rsp), %rdi
callq 0x2050
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4fdd
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x4f60
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_new_object
json_object *pjson_new_object(json_type_t type, json_mem_t *mem)
{
    json_object *json = NULL;

    if ((json = (json_object *)pjson_memory_alloc(sizeof(json_object), &mem->obj_mgr)) == NULL) {
        JsonErr("malloc failed!\n");
        return NULL;
    }
    memset(json, 0, sizeof(json_object));
    json->type_member = type;

    switch (type) {
    case JSON_ARRAY:
    case JSON_OBJECT:
        INIT_JSON_LIST_HEAD(&json->value.head);
        break;
    default:
        break;
    }

    return json;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
movl $0x28, %edi
callq 0x5140
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x50d9
jmp 0x50a6
leaq 0xe78b(%rip), %rdi      # 0x13838
leaq 0xe850(%rip), %rsi      # 0x13904
movl $0x453, %edx            # imm = 0x453
movb $0x0, %al
callq 0x2100
leaq 0xe783(%rip), %rdi      # 0x1384a
movb $0x0, %al
callq 0x2100
movq $0x0, 0x20(%rsp)
jmp 0x5131
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movl 0x1c(%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
andl $0xf, %edx
andl $-0x10, %ecx
orl %edx, %ecx
movl %ecx, 0x8(%rax)
movl 0x1c(%rsp), %eax
addl $-0x8, %eax
subl $0x1, %eax
ja 0x5125
jmp 0x5115
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x26d0
jmp 0x5127
jmp 0x5127
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_create_item
json_object *pjson_create_item(json_type_t type, void *value, json_mem_t *mem)
{
    json_object *json = NULL;

    if ((json = (json_object *)pjson_memory_alloc(sizeof(json_object), &mem->obj_mgr)) == NULL) {
        JsonErr("malloc failed!\n");
        return NULL;
    }
    memset(json, 0, sizeof(json_object));
    json->type_member = type;

    switch (type) {
    case JSON_NULL:
        break;
    case JSON_BOOL:   json->value.vnum.vbool = *(bool *)value;      break;
    case JSON_INT:    json->value.vnum.vint  = *(int32_t *)value;   break;
    case JSON_HEX:    json->value.vnum.vhex  = *(uint32_t *)value;  break;
    case JSON_LINT:   json->value.vnum.vlint = *(int64_t *)value;   break;
    case JSON_LHEX:   json->value.vnum.vlhex = *(uint64_t *)value;  break;
    case JSON_DOUBLE: json->value.vnum.vdbl  = *(double *)value;    break;
    case JSON_STRING:
        if (pjson_set_string_value(json, (json_string_t *)value, mem) < 0)
            return NULL;
        break;
    case JSON_ARRAY:
    case JSON_OBJECT:
        INIT_JSON_LIST_HEAD(&json->value.head);
        break;
    default:
        break;
    }

    return json;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
movl $0x28, %edi
callq 0x5140
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x5291
jmp 0x525b
leaq 0xe5d6(%rip), %rdi      # 0x13838
leaq 0xe6ac(%rip), %rsi      # 0x13915
movl $0x46a, %edx            # imm = 0x46A
movb $0x0, %al
callq 0x2100
leaq 0xe5ce(%rip), %rdi      # 0x1384a
movb $0x0, %al
callq 0x2100
movq $0x0, 0x30(%rsp)
jmp 0x53a5
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movl 0x2c(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
andl $0xf, %edx
andl $-0x10, %ecx
orl %edx, %ecx
movl %ecx, 0x8(%rax)
movl 0x2c(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x9, %rax
ja 0x5399
movq 0x8(%rsp), %rax
leaq 0xde82(%rip), %rcx      # 0x13160
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x539b
movq 0x20(%rsp), %rax
movb (%rax), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
jmp 0x539b
movq 0x20(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
jmp 0x539b
movq 0x20(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
jmp 0x539b
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x539b
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x539b
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0x539b
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x53b0
cmpl $0x0, %eax
jge 0x5387
movq $0x0, 0x30(%rsp)
jmp 0x53a5
jmp 0x539b
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x26d0
jmp 0x539b
jmp 0x539b
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_string_strdup
int pjson_string_strdup(json_string_t *src, json_string_t *dst, json_mem_mgr_t *mgr)
{
    json_string_info_update(src);
    json_string_info_update(dst);
    if (src->len) {
        if (dst->len < src->len) {
            if ((dst->str = (char *)pjson_memory_alloc(src->len + 1, mgr)) == NULL) {
                JsonErr("malloc failed!\n");
                dst->len = 0;
                return -1;
            }
        }
        dst->escaped = src->escaped;
        dst->len = src->len;
        memcpy(dst->str, src->str, src->len);
        dst->str[src->len] = '\0';
    } else {
        dst->escaped = 0;
        dst->len = 0;
        dst->str = NULL;
    }

    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20a0
movq 0x10(%rsp), %rdi
callq 0x20a0
movq 0x18(%rsp), %rax
movl (%rax), %eax
shrl $0x8, %eax
cmpl $0x0, %eax
je 0x57bb
movq 0x10(%rsp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
shrl $0x8, %ecx
cmpl %ecx, %eax
jge 0x5736
movq 0x18(%rsp), %rax
movl (%rax), %eax
shrl $0x8, %eax
addl $0x1, %eax
movslq %eax, %rdi
movq 0x8(%rsp), %rsi
callq 0x5140
movq 0x10(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x5734
jmp 0x56ed
leaq 0xe144(%rip), %rdi      # 0x13838
leaq 0xe244(%rip), %rsi      # 0x1393f
movl $0x4b0, %edx            # imm = 0x4B0
movb $0x0, %al
callq 0x2100
leaq 0xe13c(%rip), %rdi      # 0x1384a
movb $0x0, %al
callq 0x2100
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $0xff, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x57f1
jmp 0x5736
movq 0x18(%rsp), %rax
movl (%rax), %edx
shrl $0x4, %edx
andl $0x1, %edx
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $0x1, %edx
shll $0x4, %edx
andl $-0x11, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %edx
shrl $0x8, %edx
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $0xffffff, %edx         # imm = 0xFFFFFF
shll $0x8, %edx
andl $0xff, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x21c0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
shrl $0x8, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
jmp 0x57e9
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $-0x11, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $0xff, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_copy_item_to_array
int pjson_copy_item_to_array(json_object *array, json_object *item, json_mem_t *mem)
{
    json_object *node = NULL;

    if (array->type_member == JSON_ARRAY) {
        if ((node = pjson_deepcopy(item, mem)) == NULL) {
            JsonErr("copy failed!\n");
            return -1;
        }
        json_list_add_tail(&node->list, &array->value.head);
        return 0;
    }

    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x5e24
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x21b0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x5e08
jmp 0x5dd6
leaq 0xda5b(%rip), %rdi      # 0x13838
leaq 0xdb7e(%rip), %rsi      # 0x13962
movl $0x512, %edx            # imm = 0x512
movb $0x0, %al
callq 0x2100
leaq 0xdaff(%rip), %rdi      # 0x138f6
movb $0x0, %al
callq 0x2100
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5e2c
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movl $0x0, 0x24(%rsp)
jmp 0x5e2c
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_copy_item_to_object
int pjson_copy_item_to_object(json_object *object, json_object *item, json_mem_t *mem)
{
    json_object *node = NULL;

    if (object->type_member == JSON_OBJECT) {
        if ((node = pjson_deepcopy(item, mem)) == NULL) {
            JsonErr("copy failed!\n");
            return -1;
        }
        json_list_add_tail(&node->list, &object->value.head);
        return 0;
    }

    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x5ed4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x21b0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x5eb8
jmp 0x5e86
leaq 0xd9ab(%rip), %rdi      # 0x13838
leaq 0xdae7(%rip), %rsi      # 0x1397b
movl $0x522, %edx            # imm = 0x522
movb $0x0, %al
callq 0x2100
leaq 0xda4f(%rip), %rdi      # 0x138f6
movb $0x0, %al
callq 0x2100
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5edc
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movl $0x0, 0x24(%rsp)
jmp 0x5edc
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_add_new_item_to_array
json_object *pjson_add_new_item_to_array(json_object *array, json_type_t type, void *value, json_mem_t *mem)
{
    json_object *item = NULL;

    if (array->type_member == JSON_ARRAY) {
        switch (type) {
        case JSON_NULL:
        case JSON_BOOL:
        case JSON_INT:
        case JSON_HEX:
        case JSON_LINT:
        case JSON_LHEX:
        case JSON_DOUBLE:
        case JSON_STRING:
        case JSON_ARRAY:
        case JSON_OBJECT:
            if ((item = pjson_create_item(type, value, mem)) == NULL) {
                JsonErr("create item failed!\n");
                return NULL;
            }
            json_list_add_tail(&item->list, &array->value.head);
            return item;
        default:
            JsonErr("not support json type.\n");
            return NULL;
        }
    }

    return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x5fd6
movl 0x24(%rsp), %eax
subl $0x9, %eax
ja 0x5fa1
jmp 0x5f2f
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x21d0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x5f82
jmp 0x5f4f
leaq 0xd8e2(%rip), %rdi      # 0x13838
leaq 0xda38(%rip), %rsi      # 0x13995
movl $0x53d, %edx            # imm = 0x53D
movb $0x0, %al
callq 0x2100
leaq 0xd918(%rip), %rdi      # 0x13888
movb $0x0, %al
callq 0x2100
movq $0x0, 0x30(%rsp)
jmp 0x5fdf
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5fdf
jmp 0x5fa3
leaq 0xd88e(%rip), %rdi      # 0x13838
leaq 0xd9e4(%rip), %rsi      # 0x13995
movl $0x543, %edx            # imm = 0x543
movb $0x0, %al
callq 0x2100
leaq 0xd8ac(%rip), %rdi      # 0x13870
movb $0x0, %al
callq 0x2100
movq $0x0, 0x30(%rsp)
jmp 0x5fdf
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_add_new_item_to_object
json_object *pjson_add_new_item_to_object(json_object *object, json_type_t type, json_string_t *jkey, void *value, json_mem_t *mem)
{
    json_object *item = NULL;

    if (object->type_member == JSON_OBJECT) {
        switch (type) {
        case JSON_NULL:
        case JSON_BOOL:
        case JSON_INT:
        case JSON_HEX:
        case JSON_LINT:
        case JSON_LHEX:
        case JSON_DOUBLE:
        case JSON_STRING:
        case JSON_ARRAY:
        case JSON_OBJECT:
            if ((item = pjson_create_item(type, value, mem)) == NULL) {
                JsonErr("create item failed!\n");
                return NULL;
            }
            if (pjson_set_key(item, jkey, mem) < 0) {
                JsonErr("add key failed!\n");
                return NULL;
            }
            json_list_add_tail(&item->list, &object->value.head);
            return item;
        default:
            JsonErr("not support json type.\n");
            return NULL;
        }
    }

    return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x612b
movl 0x24(%rsp), %eax
subl $0x9, %eax
ja 0x60f6
jmp 0x6037
movl 0x24(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x21d0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x608c
jmp 0x6056
leaq 0xd7db(%rip), %rdi      # 0x13838
leaq 0xd94d(%rip), %rsi      # 0x139b1
movl $0x55c, %edx            # imm = 0x55C
movb $0x0, %al
callq 0x2100
leaq 0xd811(%rip), %rdi      # 0x13888
movb $0x0, %al
callq 0x2100
movq $0x0, 0x30(%rsp)
jmp 0x6134
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6140
cmpl $0x0, %eax
jge 0x60d9
jmp 0x60a6
leaq 0xd78b(%rip), %rdi      # 0x13838
leaq 0xd8fd(%rip), %rsi      # 0x139b1
movl $0x560, %edx            # imm = 0x560
movb $0x0, %al
callq 0x2100
leaq 0xd81e(%rip), %rdi      # 0x138e5
movb $0x0, %al
callq 0x2100
movq $0x0, 0x30(%rsp)
jmp 0x6134
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
callq 0x2b00
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x6134
jmp 0x60f8
leaq 0xd739(%rip), %rdi      # 0x13838
leaq 0xd8ab(%rip), %rsi      # 0x139b1
movl $0x566, %edx            # imm = 0x566
movb $0x0, %al
callq 0x2100
leaq 0xd757(%rip), %rdi      # 0x13870
movb $0x0, %al
callq 0x2100
movq $0x0, 0x30(%rsp)
jmp 0x6134
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/9-File/read_eof.c
// Function: main
int main(void)
{
	int ret;
	char c;
	unsigned long long count = 0;
	while(1)
	{
		ret = read(fileno(stdin), &c, 1);
		if(ret == 0)
			break;
		else
		{
			count += ret;
			if(c == EOF)
				printf("WoW!\n");
		}
	}
	printf("EOF is reached. Read %lld bytes.\n", count);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x2e62(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1050
movl %eax, %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x11a1
jmp 0x11c8
movslq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $-0x1, %eax
jne 0x11c4
leaq 0xe47(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x11c6
jmp 0x1177
movq -0x18(%rbp), %rsi
leaq 0xe37(%rip), %rdi       # 0x200a
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: mtgp32_init
int mtgp32_init(mtgp32_ref_t *mtgp32,
		const mtgp32_params_ref_t *para, uint32_t seed) {
    int i;
    int size = para->mexp / 32 + 1;
    uint32_t hidden_seed;
    uint32_t tmp;
    mtgp32_status_ref_t *st;

    st = (mtgp32_status_ref_t *)malloc(sizeof(mtgp32_status_ref_t)
				     + sizeof(uint32_t) * size);
    if (st == NULL) {
	return -1;
    }
    hidden_seed = para->tbl[2] ^ (para->tbl[3] << 16);
    tmp = hidden_seed;
    tmp += tmp >> 16;
    tmp += tmp >> 8;
    memset(st->array, tmp & 0xff, sizeof(uint32_t) * size);
    mtgp32->params = *para;
    mtgp32->status = st;
    st->size = size;
    st->idx = size - 1;
    st->array[0] = seed;
    st->array[1] = hidden_seed;
    for (i = 1; i < size; i++) {
	st->array[i] ^= UINT32_C(1812433253) * (st->array[i - 1]
						^ (st->array[i - 1] >> 30))
	    + i;
    }
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl $0x20, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movslq 0x14(%rsp), %rdi
shlq $0x2, %rdi
addq $0x8, %rdi
callq 0x10b0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1212
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x132d
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x20(%rsp), %rcx
movl 0x1c(%rcx), %ecx
shll $0x10, %ecx
xorl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
shrl $0x10, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
shrl $0x8, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
movl 0xc(%rsp), %eax
andl $0xff, %eax
movslq 0x14(%rsp), %rdx
shlq $0x2, %rdx
movzbl %al, %esi
callq 0x1070
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x4c, %edx
callq 0x10a0
movq (%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x50(%rax)
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x1c(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x10(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rax)
movl $0x1, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x1325
movq (%rsp), %rax
movl 0x18(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x8(%rax,%rcx,4), %eax
movq (%rsp), %rcx
movl 0x18(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl 0x8(%rcx,%rdx,4), %ecx
shrl $0x1e, %ecx
xorl %ecx, %eax
imull $0x6c078965, %eax, %edx # imm = 0x6C078965
addl 0x18(%rsp), %edx
movq (%rsp), %rax
movslq 0x18(%rsp), %rcx
xorl 0x8(%rax,%rcx,4), %edx
movl %edx, 0x8(%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x12ca
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: mtgp32_print_idstring
void mtgp32_print_idstring(const mtgp32_ref_t *mtgp32, FILE *fp) {
    int i;
    fprintf(fp, "mtgp32:%d:", mtgp32->params.mexp);
    for (i = 0; i < 20; i++) {
	fprintf(fp, "%02x", (unsigned int)mtgp32->params.poly_sha1[i]);
    }
    fprintf(fp, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %edx
leaq 0xb7b(%rip), %rsi       # 0x300c
movb $0x0, %al
callq 0x1080
movl $0x0, 0x4(%rsp)
cmpl $0x14, 0x4(%rsp)
jge 0x24d6
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzbl 0x34(%rax,%rcx), %edx
leaq 0xb55(%rip), %rsi       # 0x3017
movb $0x0, %al
callq 0x1080
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x24a0
movq 0x8(%rsp), %rdi
leaq 0xb57(%rip), %rsi       # 0x3039
movb $0x0, %al
callq 0x1080
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: mtgp32_genrand_uint32
uint32_t mtgp32_genrand_uint32(mtgp32_ref_t *mtgp32) {
    next_state(mtgp32);
    return temper(mtgp32->params.tmp_tbl,
		  mtgp32->status->array[mtgp32->status->idx],
		  mtgp32->status->array[(mtgp32->status->idx
					 + mtgp32->params.pos - 1)
					% mtgp32->status->size]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2570
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %rcx
movslq 0x4(%rcx), %rcx
movl 0x8(%rax,%rcx,4), %esi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rax), %eax
movq 0x10(%rsp), %rcx
addl 0x4(%rcx), %eax
subl $0x1, %eax
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %rcx
cltd
idivl (%rcx)
movq 0x8(%rsp), %rax
movslq %edx, %rcx
movl 0x8(%rax,%rcx,4), %edx
callq 0x2700
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: next_state
static void next_state(mtgp32_ref_t *mtgp32) {
    uint32_t *array = mtgp32->status->array;
    int idx;
    int size = mtgp32->status->size;
    uint32_t x;
    uint32_t y;
    uint32_t yl;

    mtgp32->status->idx += 1;
    if (mtgp32->status->idx >= size) {
	mtgp32->status->idx = 0;
    }
    idx = mtgp32->status->idx;
    x = (array[idx] & mtgp32->params.mask) ^ array[(idx + 1) % size];
    y = array[(idx + mtgp32->params.pos) % size];
    x ^= x << mtgp32->params.sh1;
    y = x ^ (y >> mtgp32->params.sh2);
    yl = y & 0x0f;
    if (yl & 1) {
	y ^= mtgp32->params.tbl[0];
    }
    if (yl & 2) {
	y ^= mtgp32->params.tbl[1];
    }
    if (yl & 4) {
	y ^= mtgp32->params.tbl[2];
    }
    if (yl & 8) {
	y ^= mtgp32->params.tbl[3];
    }
    array[idx] = y;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl (%rax), %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rsp), %eax
jl 0x25ca
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rsp), %rcx
andl 0x30(%rcx), %eax
movl %eax, -0x34(%rsp)
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %eax
addl $0x1, %eax
cltd
idivl -0x18(%rsp)
movl -0x34(%rsp), %eax
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
addl 0x4(%rcx), %eax
cltd
idivl -0x18(%rsp)
movq -0x30(%rsp), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
movq -0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
shll %cl, %eax
xorl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl -0x20(%rsp), %edx
movq -0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
shrl %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
andl $0xf, %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2693
movq -0x8(%rsp), %rax
movl 0x10(%rax), %eax
xorl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x24(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x26af
movq -0x8(%rsp), %rax
movl 0x14(%rax), %eax
xorl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x24(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x26cb
movq -0x8(%rsp), %rax
movl 0x18(%rax), %eax
xorl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x24(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x26e7
movq -0x8(%rsp), %rax
movl 0x1c(%rax), %eax
xorl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: temper
static uint32_t temper(const uint32_t tmp_tbl[4], uint32_t r, uint32_t t) {
    t ^= t >> 16;
    t ^= t >> 8;
    if (t & 1) {
	r ^= tmp_tbl[0];
    }
    if (t & 2) {
	r ^= tmp_tbl[1];
    }
    if (t & 4) {
	r ^= tmp_tbl[2];
    }
    if (t & 8) {
	r ^= tmp_tbl[3];
    }
    return r;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x10, %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x8, %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2746
movq -0x8(%rsp), %rax
movl (%rax), %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2762
movq -0x8(%rsp), %rax
movl 0x4(%rax), %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x277e
movq -0x8(%rsp), %rax
movl 0x8(%rax), %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x279a
movq -0x8(%rsp), %rax
movl 0xc(%rax), %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nop