LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_del_object
void json_del_object(json_object *json)
{
    json_object *p = NULL, *pos = NULL, *n = NULL;

    if (!json)
        return;

    if (json->key_member)
        json_free(json->key_member);

    switch (json->type_member) {
    case JSON_STRING:
        if (json->value.str_member)
            json_free(json->value.str_member);
        break;
    case JSON_ARRAY:
    case JSON_OBJECT:
        json_list_for_each_entry_safe(p, pos, n, &json->value.head, list, json_object) {
            json_list_del(&pos->list, &p->list, &json->value.head);
            json_del_object(pos);
            pos = p;
        }
        break;
    default:
        break;
    }

    json_free(json);
}

// Assembly:
testq %rdi, %rdi
je 0x1fa3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1030
movl 0x8(%rbx), %eax
andl $0xf, %eax
leal -0x8(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1fa4
leaq 0x18(%rbx), %r14
movq 0x18(%rbx), %rdi
cmpq %r14, %rdi
je 0x1fb2
movq (%rdi), %r15
cmpq %r14, %r15
jne 0x1f92
movq %r14, 0x20(%rbx)
movq %r15, (%r14)
andq $0x0, (%rdi)
callq 0x1f55
movq %r15, %rdi
jmp 0x1f81
retq
cmpl $0x7, %eax
jne 0x1fb2
movq 0x20(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_string_info_update
void json_string_info_update(json_string_t *jstr)
{
    const char *str = jstr->str;
    int i = 0;
    int escaped = 0;

    if (jstr->len)
        return;

    if (str) {
        for (i = 0; str[i]; ++i) {
            switch (str[i]) {
            case '\"': case '\\': case '\b': case '\f': case '\n': case '\r': case '\t': case '\v':
                escaped = 1;
                break;
            default:
#if JSON_PRINT_UTF16_SUPPORT
                {
                    if ((unsigned char)str[i] < ' ')
                        escaped = 1;
                }
#endif
                break;
            }
        }
    }

    jstr->escaped = escaped;
    jstr->len = i;
}

// Assembly:
movl (%rdi), %eax
cmpl $0xff, %eax
ja 0x201b
movq 0x8(%rdi), %rsi
xorl %ecx, %ecx
testq %rsi, %rsi
je 0x200e
pushq $0x1
popq %r8
xorl %edx, %edx
movzbl (%rsi), %r9d
leal -0x8(%r9), %r10d
cmpl $0x6, %r10d
jae 0x1ff5
movl %r8d, %edx
addl $0x100, %ecx            # imm = 0x100
incq %rsi
jmp 0x1fd9
cmpl $0x22, %r9d
je 0x1fe7
cmpl $0x5c, %r9d
je 0x1fe7
testl %r9d, %r9d
jne 0x1fea
shll $0x4, %edx
andl $0x10, %edx
jmp 0x2010
xorl %edx, %edx
orl %edx, %ecx
andl $0xef, %eax
orl %ecx, %eax
movl %eax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_mem_free
static void _json_mem_free(json_mem_mgr_t *mgr)
{
    json_mem_node_t *p = NULL, *pos = NULL, *n = NULL;
    json_list_for_each_entry_safe(p, pos, n, &mgr->head, list, json_mem_node_t) {
        json_list_del(&pos->list, &p->list, &mgr->head);
        json_free(pos->ptr);
        json_free(pos);
        pos = p;
    }
    mgr->cur_node = &s_invalid_json_mem_node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpq %rbx, %r14
je 0x20c1
movq (%r14), %r15
cmpq %rbx, %r15
jne 0x20a4
movq %rbx, 0x8(%rbx)
movq %r15, (%rbx)
andq $0x0, (%r14)
movq 0x10(%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
jmp 0x2093
leaq 0xc1c8(%rip), %rax      # 0xe290
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_memory_alloc
static inline void *pjson_memory_alloc(size_t size, json_mem_mgr_t *mgr)
{
    void *p = NULL;

    if ((mgr->cur_node->cur - mgr->cur_node->ptr) + size > mgr->cur_node->size) {
        if ((_json_mem_new((mgr->mem_size >= size) ? mgr->mem_size : size, mgr) == NULL)) {
            return NULL;
        }
        mgr->cur_node = (json_mem_node_t *)(mgr->head.next);
    }

    p = mgr->cur_node->cur;
    mgr->cur_node->cur += size;
    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x18(%rsi), %r14
movq 0x18(%r14), %rbx
leaq (%rbx,%rdi), %rax
subq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
jbe 0x215b
movq %rsi, %r12
movq 0x10(%rsi), %r13
cmpq %r15, %r13
cmovbeq %r15, %r13
pushq $0x20
popq %rdi
callq 0x1150
testq %rax, %rax
je 0x2164
movq %rax, %r14
movq %r13, 0x8(%rax)
movq %r13, %rdi
callq 0x1150
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x218e
movq %rax, %rbx
movq %rax, 0x18(%r14)
movq (%r12), %rax
cmpq %r12, %rax
jne 0x214f
movq %r14, 0x8(%r12)
movq %rax, (%r14)
movq %r14, (%r12)
movq %r14, 0x18(%r12)
addq %rbx, %r15
movq %r15, 0x18(%r14)
jmp 0x21c3
leaq 0x62f1(%rip), %rdi      # 0x845c
leaq 0x64a9(%rip), %rsi      # 0x861b
xorl %ebx, %ebx
movl $0x40f, %edx            # imm = 0x40F
xorl %eax, %eax
callq 0x10c0
leaq 0x67d9(%rip), %rdi      # 0x8960
callq 0x1060
jmp 0x21c3
leaq 0x62c7(%rip), %rdi      # 0x845c
leaq 0x647f(%rip), %rsi      # 0x861b
xorl %ebx, %ebx
movl $0x414, %edx            # imm = 0x414
xorl %eax, %eax
callq 0x10c0
leaq 0x6478(%rip), %rdi      # 0x8629
movl %r13d, %esi
xorl %eax, %eax
callq 0x10c0
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: print_val_release
static int _print_val_release(json_print_t *print_ptr, bool free_all_flag, size_t *length, json_print_ptr_t *ptr)
{
#define _clear_free_ptr(ptr)    do { if (ptr) json_free(ptr); ptr = NULL; } while(0)
#define _clear_close_fd(fd)     do { if (fd >= 0) close(fd); fd = -1; } while(0)
    int ret = 0;
    size_t used = GET_BUF_USED_SIZE(print_ptr);

    if (print_ptr->fd >= 0) {
        if (!free_all_flag && used > 0) {
            if (used != (size_t)write(print_ptr->fd, print_ptr->ptr, used)) {
                JsonErr("write failed!\n");
                ret = -1;
            }
        }
        _clear_close_fd(print_ptr->fd);
        if (ptr) {
            ptr->size = print_ptr->size;
            ptr->p = print_ptr->ptr;
        } else {
            _clear_free_ptr(print_ptr->ptr);
        }
    } else {
        if (free_all_flag) {
            _clear_free_ptr(print_ptr->ptr);
        } else {
            if (length)
                *length = print_ptr->cur - print_ptr->ptr;
            *print_ptr->cur = '\0';


            if (ptr) {
                ptr->size = print_ptr->size;
                ptr->p = print_ptr->ptr;
            } else {
                /* Reduce size, never fail */
                print_ptr->ptr = (char *)json_realloc(print_ptr->ptr, used + 1);
            }
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %esi, %eax
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x8(%rdi), %rsi
movq %rcx, %r15
subq %rsi, %r15
movl (%rdi), %edi
testl %edi, %edi
js 0x2c85
cmpq %rsi, %rcx
sete %cl
xorl %ebp, %ebp
orb %cl, %al
jne 0x2c67
movq %r15, %rdx
callq 0x1090
xorl %ebp, %ebp
cmpq %rax, %r15
je 0x2c61
leaq 0x581d(%rip), %rdi      # 0x845c
leaq 0x5a47(%rip), %rsi      # 0x868d
movl $0x6e7, %edx            # imm = 0x6E7
xorl %eax, %eax
callq 0x10c0
leaq 0x5cf9(%rip), %rdi      # 0x8952
callq 0x1060
pushq $-0x1
popq %rbp
movl (%rbx), %edi
testl %edi, %edi
js 0x2c6c
callq 0x1100
orl $-0x1, (%rbx)
testq %r14, %r14
je 0x2c98
movq 0x20(%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x2cde
testb %al, %al
je 0x2ca8
movq %rsi, %rdi
callq 0x1030
andq $0x0, 0x8(%rbx)
jmp 0x2cdc
movq 0x8(%rbx), %rdi
callq 0x1030
andq $0x0, 0x8(%rbx)
jmp 0x2cde
testq %rdx, %rdx
je 0x2cb0
movq %r15, (%rdx)
movb $0x0, (%rcx)
testq %r14, %r14
je 0x2cc9
movq 0x20(%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x2cdc
movq 0x8(%rbx), %rdi
incq %r15
movq %r15, %rsi
callq 0x1180
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: print_addi_format
static inline int _print_addi_format(json_print_t *print_ptr, size_t depth)
{
    _PRINT_PTR_REALLOC((depth + 2));
    *print_ptr->cur++ = '\n';
    memset(print_ptr->cur, '\t', depth);
    print_ptr->cur += depth;

    return 0;
err:
    return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
addq 0x8(%rdi), %rcx
addq $0x2, %rsi
cmpq %rsi, %rcx
jae 0x34bd
movq %r14, %rdi
callq *0x18(%r14)
testl %eax, %eax
js 0x34e5
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%r14)
movb $0xa, (%rax)
movq 0x10(%r14), %rdi
pushq $0x9
popq %rsi
movq %rbx, %rdx
callq 0x10f0
addq %rbx, 0x10(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
jmp 0x34dd
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_sax_print_start
json_sax_print_hd json_sax_print_start(json_print_choice_t *choice)
{
    json_sax_print_t *print_handle = NULL;

    if ((print_handle = (json_sax_print_t *)json_calloc(1, sizeof(json_sax_print_t))) == NULL) {
        JsonErr("malloc failed!\n");
        return NULL;
    }
    print_handle->print_val.item_total = choice->item_total ? choice->item_total : JSON_PRINT_NUM_INIT_DEF;
    if (_print_val_init(&print_handle->print_val, choice) < 0) {
        json_free(print_handle);
        return NULL;
    }

    print_handle->total = JSON_PRINT_DEPTH_DEF;
    if ((print_handle->array = (json_sax_print_depth_t *)json_malloc(print_handle->total * sizeof(json_sax_print_depth_t))) == NULL) {
        _print_val_release(&print_handle->print_val, true, NULL, NULL);
        json_free(print_handle);
        JsonErr("malloc failed!\n");
        return NULL;
    }

    return print_handle;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
callq 0x1120
testq %rax, %rax
je 0x3736
movq %rax, %rbx
movl 0x18(%r15), %eax
testl %eax, %eax
movl $0x400, %ecx            # imm = 0x400
cmovnel %eax, %ecx
movq %rbx, %r14
addq $0x10, %r14
movl %ecx, 0x48(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2abf
testl %eax, %eax
js 0x3760
movl $0x10, (%rbx)
movl $0x80, %edi
callq 0x1150
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x376a
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2bfa
movq %rbx, %rdi
callq 0x1030
leaq 0x4d47(%rip), %rdi      # 0x845c
leaq 0x4e91(%rip), %rsi      # 0x85ad
movl $0x823, %edx            # imm = 0x823
xorl %eax, %eax
callq 0x10c0
leaq 0x5231(%rip), %rdi      # 0x8960
callq 0x1060
jmp 0x3768
leaq 0x4d1f(%rip), %rdi      # 0x845c
leaq 0x4e69(%rip), %rsi      # 0x85ad
xorl %ebx, %ebx
movl $0x816, %edx            # imm = 0x816
xorl %eax, %eax
callq 0x10c0
leaq 0x5207(%rip), %rdi      # 0x8960
callq 0x1060
jmp 0x376a
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_sax_print_finish
char *json_sax_print_finish(json_sax_print_hd handle, size_t *length, json_print_ptr_t *ptr)
{
    char *ret = NULL;

    json_sax_print_t *print_handle = (json_sax_print_t *)handle;
    if (!print_handle)
        return NULL;
    if (print_handle->array)
        json_free(print_handle->array);
    if (print_handle->error_flag) {
        _print_val_release(&print_handle->print_val, true, NULL, NULL);
        json_free(print_handle);
        return NULL;
    }

    ret = (print_handle->print_val.fd >= 0) ? (char *)"ok" : print_handle->print_val.ptr;
    if (_print_val_release(&print_handle->print_val, false, length, ptr) < 0) {
        json_free(print_handle);
        return NULL;
    }
    json_free(print_handle);

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x37b8
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1030
leaq 0x10(%rbx), %rdi
cmpb $0x1, 0x5c(%rbx)
jne 0x37bd
xorl %r14d, %r14d
pushq $0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2bfa
movq %rbx, %rdi
callq 0x1030
jmp 0x37ef
xorl %r14d, %r14d
jmp 0x37ef
cmpl $0x0, (%rdi)
js 0x37cb
leaq 0x4dbc(%rip), %r13      # 0x8585
jmp 0x37cf
movq 0x18(%rbx), %r13
xorl %r14d, %r14d
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2bfa
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1030
testl %ebp, %ebp
cmovnsq %r13, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: skip_blank
static inline void _skip_blank(json_parse_t *parse_ptr)
{
    unsigned char *str = NULL;
    int cnt = 0;

    while (_get_parse_ptr(parse_ptr, cnt, 64, (char **)&str)) {
        while (IS_BLANK(*str)) {
            ++str;
            ++cnt;
        }
        if (likely(*str)) {
#if JSON_PARSE_SKIP_COMMENT
            if (unlikely(*str == '/')) {
                if (!_skip_comment(parse_ptr, &cnt))
                    continue;
            }
#endif
            break;
        }
    }
    _UPDATE_PARSE_OFFSET(cnt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %r14
andq $0x0, (%r14)
movq %rdi, %rbx
xorl %ebp, %ebp
pushq $0x40
popq %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5b5b
testl %eax, %eax
je 0x3a81
movq (%rsp), %rax
movb (%rax), %cl
leal -0x1(%rcx), %edx
cmpb $0x1f, %dl
ja 0x3a79
incq %rax
incl %ebp
jmp 0x3a68
movq %rax, (%rsp)
testb %cl, %cl
je 0x3a50
movslq %ebp, %rax
addq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: print_file_ptr_realloc
static int _print_file_ptr_realloc(json_print_t *print_ptr, size_t slen)
{
    size_t len = GET_BUF_USED_SIZE(print_ptr);

    if (len > 0) {
        if (len != (size_t)write(print_ptr->fd, print_ptr->ptr, len)) {
            JsonErr("write failed!\n");
            return -1;
        }
        print_ptr->cur = print_ptr->ptr;
    }

    len = slen + 1;
    if (print_ptr->size < len) {
        while (print_ptr->size < len)
            print_ptr->size += print_ptr->plus_size;
        char *new_str = (char *)json_realloc(print_ptr->ptr, print_ptr->size);
        if (new_str) {
            print_ptr->ptr = new_str;
            print_ptr->cur = print_ptr->ptr;
        } else {
            JsonErr("malloc failed!\n");
            json_free(print_ptr->ptr);
            print_ptr->ptr = NULL;
            print_ptr->cur = print_ptr->ptr;
            return -1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %r15
subq %rsi, %r15
je 0x59dd
movl (%rbx), %edi
movq %r15, %rdx
callq 0x1090
cmpq %rax, %r15
jne 0x5a1c
movq 0x8(%rbx), %rsi
movq %rsi, 0x10(%rbx)
incq %r14
movq 0x20(%rbx), %rax
xorl %ebp, %ebp
cmpq %r14, %rax
jae 0x5a7c
leaq 0x8(%rbx), %r15
cmpq %r14, %rax
jae 0x5a02
addq 0x28(%rbx), %rax
movq %rax, 0x20(%rbx)
jmp 0x59f3
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1180
testq %rax, %rax
je 0x5a44
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
jmp 0x5a7c
leaq 0x2a39(%rip), %rdi      # 0x845c
leaq 0x2c22(%rip), %rsi      # 0x864c
movl $0x587, %edx            # imm = 0x587
xorl %eax, %eax
callq 0x10c0
leaq 0x2f15(%rip), %rdi      # 0x8952
callq 0x1060
jmp 0x5a79
leaq 0x2a11(%rip), %rdi      # 0x845c
leaq 0x2bfa(%rip), %rsi      # 0x864c
movl $0x596, %edx            # imm = 0x596
xorl %eax, %eax
callq 0x10c0
leaq 0x2efb(%rip), %rdi      # 0x8960
callq 0x1060
movq (%r15), %rdi
callq 0x1030
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: print_str_ptr_realloc
static int _print_str_ptr_realloc(json_print_t *print_ptr, size_t slen)
{
    size_t used = GET_BUF_USED_SIZE(print_ptr);
    size_t len = used + slen + 1;

    while (print_ptr->item_total < print_ptr->item_count) {
        print_ptr->item_total += JSON_PRINT_NUM_PLUS_DEF;
        print_ptr->size += print_ptr->plus_size >> 2;
    }
    if (print_ptr->item_total - print_ptr->item_count > print_ptr->item_count) {
        print_ptr->size += print_ptr->size;
    } else {
        print_ptr->size += (uint64_t)print_ptr->size *
            (print_ptr->item_total - print_ptr->item_count) / print_ptr->item_count;
    }

    while (print_ptr->size < len)
        print_ptr->size += print_ptr->plus_size;

    char *new_str = (char *)json_realloc(print_ptr->ptr, print_ptr->size);
    if (new_str) {
        print_ptr->ptr = new_str;
        print_ptr->cur = print_ptr->ptr + used;
    } else {
        JsonErr("malloc failed!\n");
        json_free(print_ptr->ptr);
        print_ptr->ptr = NULL;
        print_ptr->cur = print_ptr->ptr;
        return -1;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %r15
incq %rsi
movslq 0x3c(%rbx), %r8
movslq 0x38(%rbx), %rax
cmpl %r8d, %eax
jge 0x5ac1
addq $0x40, %rax
movl %eax, 0x38(%rbx)
movq 0x28(%rbx), %rcx
shrq $0x2, %rcx
addq %rcx, 0x20(%rbx)
jmp 0x5aa7
subq %rdi, %r15
movl %eax, %edx
subl %r8d, %edx
movq 0x20(%rbx), %rcx
cmpl %r8d, %edx
jle 0x5ad7
addq %rcx, %rcx
jmp 0x5ae6
subq %r8, %rax
imulq %rcx, %rax
xorl %edx, %edx
divq %r8
addq %rax, %rcx
addq %r15, %rsi
cmpq %rsi, %rcx
jae 0x5af4
addq 0x28(%rbx), %rcx
jmp 0x5ae9
movq %rcx, 0x20(%rbx)
movq %rcx, %rsi
callq 0x1180
movq %rax, %r14
testq %rax, %rax
je 0x5b12
movq %r14, %r12
addq %r15, %r12
xorl %eax, %eax
jmp 0x5b47
leaq 0x2943(%rip), %rdi      # 0x845c
leaq 0x2b44(%rip), %rsi      # 0x8664
xorl %r12d, %r12d
movl $0x5b9, %edx            # imm = 0x5B9
xorl %eax, %eax
callq 0x10c0
leaq 0x2e2a(%rip), %rdi      # 0x8960
callq 0x1060
movq 0x8(%rbx), %rdi
callq 0x1030
pushq $-0x1
popq %rax
movq %r14, 0x8(%rbx)
movq %r12, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: jnum_itoa
int jnum_itoa(int32_t num, char *buffer)
{
    char *s = buffer;
    uint32_t n = 0;
    int32_t tz = 0;

    if (num == 0) {
        memcpy(s, "0", 2);
        return 1;
    }

    if (num < 0) {
        n = -num;
        *s++ = '-';
    } else {
        n = num;
    }

    if (n < 100000000) {
        s += fill_1_8_digits(s, n, &tz);
    } else {
        uint32_t q = (uint32_t)(((uint64_t)n * 1441151881) >> 57); /* n / 100000000 */
        uint32_t r = n - q * 100000000;

        if (q >= 10) {
            tz = tz_100_lut[q];
            memcpy(s, &ch_100_lut[q<<1], 2);
            s += 2;
        } else {
            tz = 0;
            *s++ = q + '0';
        }

        if (!r) {
            tz += 8;
            memset(s, '0', 8);
            s += 8;
        } else {
            s += fill_t_8_digits(s, r, &tz);
        }
    }

    *s = '\0';
    return (int)(s - buffer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
andl $0x0, 0xc(%rsp)
testl %edi, %edi
je 0x6a35
movl %edi, %eax
js 0x6a43
movq %rbx, %r14
jmp 0x6a4c
movw $0x30, (%rbx)
pushq $0x1
popq %r15
jmp 0x6ae3
negl %eax
leaq 0x1(%rbx), %r14
movb $0x2d, (%rbx)
cmpl $0x5f5e0ff, %eax        # imm = 0x5F5E0FF
ja 0x6a6a
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x6af0
movslq %eax, %r15
addq %r14, %r15
jmp 0x6adc
movl %eax, %ecx
imulq $0x55e63b89, %rcx, %rcx # imm = 0x55E63B89
shrq $0x39, %rcx
imull $0xfa0a1f00, %ecx, %esi # imm = 0xFA0A1F00
addl %eax, %esi
cmpl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
jb 0x6aa6
leaq 0x2113(%rip), %rax      # 0x8ba0
movzbl (%rcx,%rax), %eax
leaq 0x2038(%rip), %rdx      # 0x8ad0
movzwl (%rdx,%rcx,2), %ecx
movw %cx, (%r14)
addq $0x2, %r14
jmp 0x6ab1
orb $0x30, %cl
movb %cl, (%r14)
incq %r14
xorl %eax, %eax
movq %r14, %r15
movl %eax, 0xc(%rsp)
testl %esi, %esi
je 0x6acb
leaq 0xc(%rsp), %rdx
movq %r15, %rdi
callq 0x6b75
jmp 0x6ad8
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, (%r15)
addq $0x8, %r15
movb $0x0, (%r15)
subl %ebx, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_1_8_digits
static inline int32_t fill_1_8_digits(char *buffer, uint32_t digits, int32_t *ptz)
{
    char *s = buffer;

    if (digits < 10000) {
        return fill_1_4_digits(s, digits, ptz);
    } else {
        uint32_t q = FAST_DIV10000(digits);
        uint32_t r = digits - q * 10000;

        s += fill_1_4_digits(s, q, ptz);
        if (!r) {
            *ptz += 4;
            memset(s, '0', 4);
            s += 4;
        } else {
            s += fill_t_4_digits(s, r, ptz);
        }
    }

    return (int32_t)(s - buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x270f, %esi           # imm = 0x270F
ja 0x6b1d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a99
movl %ebp, %eax
imulq $0x68db8bb, %rax, %rsi  # imm = 0x68DB8BB
shrq $0x28, %rsi
imull $0xffffd8f0, %esi, %r12d # imm = 0xFFFFD8F0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7a99
movslq %eax, %r15
addq %rbx, %r15
addl %ebp, %r12d
je 0x6b57
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x7b55
jmp 0x6b62
addl $0x4, (%r14)
movl $0x30303030, (%r15)     # imm = 0x30303030
subl %ebx, %r15d
addl $0x4, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_t_8_digits
static inline int32_t fill_t_8_digits(char *buffer, uint32_t digits, int32_t *ptz)
{
    char *s = buffer;

    if (digits < 10000) {
        memset(s, '0', 4);
        fill_t_4_digits(s + 4, digits, ptz);
    } else {
        uint32_t q = FAST_DIV10000(digits);
        uint32_t r = digits - q * 10000;

        fill_t_4_digits(s, q, ptz);
        if (!r) {
            memset(s + 4, '0', 4);
            *ptz += 4;
        } else {
            fill_t_4_digits(s + 4, r, ptz);
        }
    }

    return 8;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x270f, %esi           # imm = 0x270F
ja 0x6b9e
movl $0x30303030, (%r14)     # imm = 0x30303030
addq $0x4, %r14
movq %r14, %rdi
movl %ebp, %esi
jmp 0x6bcc
movl %ebp, %eax
imulq $0x68db8bb, %rax, %rsi  # imm = 0x68DB8BB
shrq $0x28, %rsi
imull $0xffffd8f0, %esi, %r15d # imm = 0xFFFFD8F0
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7b55
addq $0x4, %r14
addl %ebp, %r15d
je 0x6bde
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7b55
movl $0x30303030, (%r14)     # imm = 0x30303030
addl $0x4, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: jnum_ltoa
int jnum_ltoa(int64_t num, char *buffer)
{
    char *s = buffer;
    uint64_t n = 0;
    int32_t tz = 0;

    if (num == 0) {
        memcpy(s, "0", 2);
        return 1;
    }

    if (num < 0) {
        n = -num;
        *s++ = '-';
    } else {
        n = num;
    }

    s += fill_1_20_digits(s, n, &tz);

    *s = '\0';
    return (int)(s - buffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
andl $0x0, 0x4(%rsp)
testq %rdi, %rdi
je 0x6c0e
movq %rdi, %rsi
js 0x6c18
movq %rbx, %r14
jmp 0x6c22
movw $0x30, (%rbx)
pushq $0x1
popq %rax
jmp 0x6c3d
negq %rsi
leaq 0x1(%rbx), %r14
movb $0x2d, (%rbx)
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x6c45
movslq %eax, %rcx
leaq (%r14,%rcx), %rax
movb $0x0, (%r14,%rcx)
subl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_1_20_digits
static inline int32_t fill_1_20_digits(char *buffer, uint64_t digits, int32_t *ptz)
{
    char *s = buffer;

    if (digits < 10000000000000000llu) {
        return fill_1_16_digits(s, digits, ptz);
    } else {
        uint32_t q = (uint32_t)(digits / 10000000000000000llu);
        uint64_t r = (digits - (uint64_t)q * 10000000000000000llu);

        s += fill_1_4_digits(s, q, ptz);
        if (!r) {
            memset(s, '0', 16);
            s += 16;
            *ptz += 16;
        } else {
            s += fill_t_16_digits(s, r, ptz);
        }
    }

    return (int32_t)(s - buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movabsq $0x2386f26fc0ffff, %rax # imm = 0x2386F26FC0FFFF
cmpq %rax, %rsi
ja 0x6c84
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x73bb
movabsq $0x2386f26fc10000, %rcx # imm = 0x2386F26FC10000
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movabsq $-0x2386f26fc10000, %r12 # imm = 0xFFDC790D903F0000
imulq %rax, %r12
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x7a99
movslq %eax, %r15
addq %rbx, %r15
addq %r13, %r12
je 0x6cd8
cmpq $0x5f5e0ff, %r12        # imm = 0x5F5E0FF
ja 0x6ce9
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, (%r15)
leaq 0x8(%r15), %rdi
jmp 0x6d12
movaps 0x1d91(%rip), %xmm0     # 0x8a70
movups %xmm0, (%r15)
addl $0x10, (%r14)
jmp 0x6d1d
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
movq %r12, %rax
xorl %edx, %edx
divq %rcx
imull $0xfa0a1f00, %eax, %ebp # imm = 0xFA0A1F00
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x6b75
leaq 0x8(%r15), %rdi
addl %ebp, %r12d
je 0x6d36
movl %r12d, %esi
movq %r14, %rdx
callq 0x6b75
subl %ebx, %r15d
addl $0x10, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, (%rdi)
addl $0x8, (%r14)
jmp 0x6d1d
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: jnum_htoa
int jnum_htoa(uint32_t num, char *buffer)
{
    char *s = buffer;

    *s++ = '0';
    *s++ = 'x';
    s += fill_1_8_hexs(s, num);

    *s = '\0';
    return (int)(s - buffer);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl %edi, %esi
movw $0x7830, (%rbx)         # imm = 0x7830
leaq 0x2(%rbx), %rdi
callq 0x6d6d
cltq
addq %rbx, %rax
addq $0x2, %rax
movb $0x0, (%rax)
subl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_1_8_hexs
static inline int fill_1_8_hexs(char *buffer, uint32_t num)
{
    char *s = buffer;
    uint32_t q = num >> 16;
    uint32_t r = num & 0xffff;

    if (!q) {
        return fill_1_4_hexs(s, num);
    } else {
        s += fill_1_4_hexs(s, q);
        s += fill_t_4_hexs(s, r);
    }
    return (int)(s - buffer);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x6d88
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ba4
movl %esi, %eax
shrl $0x10, %eax
movzwl %si, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x7ba4
movslq %eax, %r14
addq %rbx, %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x7c0c
subl %ebx, %r14d
addl $0x4, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: jnum_lhtoa
int jnum_lhtoa(uint64_t num, char *buffer)
{
    char *s = buffer;
    uint32_t q = (uint32_t)(num >> 32);
    uint32_t r = (uint32_t)(num & 0xffffffff);

    *s++ = '0';
    *s++ = 'x';
    if (!q) {
        s += fill_1_8_hexs(s, r);
    } else {
        s += fill_1_8_hexs(s, q);
        s += fill_t_8_hexs(s, r);
    }

    *s = '\0';
    return (int)(s - buffer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movw $0x7830, (%rsi)         # imm = 0x7830
leaq 0x2(%rsi), %r14
movq %rdi, %rsi
movq %r14, %rdi
shrq $0x20, %rsi
jne 0x6deb
movl %r15d, %esi
callq 0x6d6d
cltq
addq %r14, %rax
jmp 0x6e1b
callq 0x6d6d
movslq %eax, %r12
leaq (%r14,%r12), %rdi
movl %r15d, %esi
shrl $0x10, %esi
callq 0x7c0c
leaq (%r14,%r12), %rdi
addq $0x4, %rdi
movzwl %r15w, %esi
callq 0x7c0c
leaq (%r14,%r12), %rax
addq $0x8, %rax
movb $0x0, (%rax)
subl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_1_16_digits
static inline int32_t fill_1_16_digits(char *buffer, uint64_t digits, int32_t *ptz)
{
    char *s = buffer;

    if (digits < 100000000llu) {
        return fill_1_8_digits(s, (uint32_t)digits, ptz);
    } else {
        uint32_t q = (uint32_t)(digits / 100000000);
        uint32_t r = (uint32_t)(digits - (uint64_t)q * 100000000);

        s += fill_1_8_digits(s, q, ptz);
        if (!r) {
            *ptz += 8;
            memset(s, '0', 8);
            s += 8;
        } else {
            s += fill_t_8_digits(s, r, ptz);
        }
    }

    return (int32_t)(s - buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x5f5e0ff, %rsi        # imm = 0x5F5E0FF
ja 0x73eb
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6af0
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
movq %r15, %rax
xorl %edx, %edx
divq %rcx
imull $0xfa0a1f00, %eax, %ebp # imm = 0xFA0A1F00
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x6af0
movslq %eax, %r12
addq %rbx, %r12
addl %ebp, %r15d
je 0x7426
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x6b75
jmp 0x7438
addl $0x8, (%r14)
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, (%r12)
subl %ebx, %r12d
addl $0x8, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_1_4_digits
static inline int32_t fill_1_4_digits(char *buffer, uint32_t digits, int32_t *ptz)
{
    char *s = buffer;

    if (digits < 100) {
        if (digits >= 10) {
            *ptz = tz_100_lut[digits];
            memcpy(s, &ch_100_lut[digits<<1], 2);
            s += 2;
        } else {
            *ptz = 0;
            *s++ = digits + '0';
        }
    } else {
        uint32_t q = FAST_DIV100(digits);
        uint32_t r = digits - q * 100;

        if (q >= 10) {
            *ptz = tz_100_lut[q];
            memcpy(s, &ch_100_lut[q<<1], 2);
            s += 2;
        } else {
            *ptz = 0;
            *s++ = q + '0';
        }

        if (!r) {
            *ptz += 2;
            memset(s, '0', 2);
            s += 2;
        } else {
            *ptz = tz_100_lut[r];
            memcpy(s, &ch_100_lut[r<<1], 2);
            s += 2;
        }
    }

    return (int32_t)(s - buffer);
}

// Assembly:
cmpl $0x63, %esi
ja 0x7ac9
cmpl $0xa, %esi
jb 0x7b07
movl %esi, %eax
leaq 0x10f4(%rip), %rcx      # 0x8ba0
movzbl (%rax,%rcx), %ecx
movl %ecx, (%rdx)
leaq 0x1017(%rip), %rcx      # 0x8ad0
movzwl (%rcx,%rax,2), %eax
movw %ax, (%rdi)
leaq 0x2(%rdi), %rax
jmp 0x7b52
imull $0x147b, %esi, %r9d     # imm = 0x147B
shrl $0x13, %r9d
imull $-0x64, %r9d, %ecx
addl %esi, %ecx
leaq 0x10bf(%rip), %r8       # 0x8ba0
cmpl $0x3e8, %esi            # imm = 0x3E8
jb 0x7b17
movzbl (%r9,%r8), %eax
movl %eax, (%rdx)
movl %r9d, %eax
leaq 0xfd6(%rip), %rsi       # 0x8ad0
movzwl (%rsi,%rax,2), %eax
movw %ax, (%rdi)
leaq 0x2(%rdi), %rax
jmp 0x7b25
andl $0x0, (%rdx)
orb $0x30, %sil
leaq 0x1(%rdi), %rax
movb %sil, (%rdi)
jmp 0x7b52
andl $0x0, (%rdx)
orb $0x30, %r9b
leaq 0x1(%rdi), %rax
movb %r9b, (%rdi)
testl %ecx, %ecx
je 0x7b40
movl %ecx, %esi
movzbl (%rsi,%r8), %esi
addl %ecx, %ecx
leaq 0xf97(%rip), %r8        # 0x8ad0
movzwl (%rcx,%r8), %ecx
jmp 0x7b49
movl (%rdx), %esi
addl $0x2, %esi
movw $0x3030, %cx            # imm = 0x3030
movl %esi, (%rdx)
movw %cx, (%rax)
addq $0x2, %rax
subl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_t_4_digits
static inline int32_t fill_t_4_digits(char *buffer, uint32_t digits, int32_t *ptz)
{
    char *s = buffer;
    uint32_t q = FAST_DIV100(digits);
    uint32_t r = digits - q * 100;

    memcpy(s, &ch_100_lut[q<<1], 2);
    memcpy(s + 2, &ch_100_lut[r<<1], 2);

    if (!r) {
        *ptz = tz_100_lut[q] + 2;
    } else {
        *ptz = tz_100_lut[r];
    }

    return 4;
}

// Assembly:
imull $0x147b, %esi, %eax     # imm = 0x147B
shrl $0x13, %eax
imull $-0x64, %eax, %ecx
addl %esi, %ecx
leaq 0xf66(%rip), %rsi       # 0x8ad0
movzwl (%rsi,%rax,2), %r8d
movw %r8w, (%rdi)
leal (%rcx,%rcx), %r8d
movzwl (%r8,%rsi), %esi
movw %si, 0x2(%rdi)
testl %ecx, %ecx
je 0x7b93
movl %ecx, %eax
leaq 0x1013(%rip), %rcx      # 0x8ba0
movzbl (%rax,%rcx), %eax
jmp 0x7ba1
leaq 0x1006(%rip), %rcx      # 0x8ba0
movzbl (%rax,%rcx), %eax
addl $0x2, %eax
movl %eax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_1_4_hexs
static inline int fill_1_4_hexs(char *buffer, uint32_t num)
{
    char *s = buffer;
    uint32_t q = num >> 8;
    uint32_t r = num & 0xff;

    if (!q) {
        return fill_1_2_hexs(s, num);
    } else {
        s += fill_1_2_hexs(s, q);
        s += fill_t_2_hexs(s, r);
    }
    return (int)(s - buffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0xff, %esi
ja 0x7bc8
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7c43
movl %r14d, %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x7c43
movslq %eax, %rcx
leaq (%rbx,%rcx), %rax
movl %r14d, %edx
shrl $0x4, %edx
andl $0xf, %edx
leaq 0xec3(%rip), %rsi       # 0x8ab0
movb (%rdx,%rsi), %dl
movb %dl, (%rbx,%rcx)
andl $0xf, %r14d
movb (%r14,%rsi), %dl
movb %dl, 0x1(%rbx,%rcx)
subl %ebx, %eax
addl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_t_4_hexs
static inline int fill_t_4_hexs(char *buffer, uint32_t num)
{
    char *s = buffer;

    fill_t_2_hexs(s, num >> 8);
    fill_t_2_hexs(s + 2, num & 0xff);
    return 4;
}

// Assembly:
movl %esi, %eax
shrl $0x8, %eax
movl %esi, %ecx
shrl $0xc, %ecx
leaq 0xe93(%rip), %rdx       # 0x8ab0
movb (%rcx,%rdx), %cl
movb %cl, (%rdi)
andl $0xf, %eax
movb (%rax,%rdx), %al
movb %al, 0x1(%rdi)
movl %esi, %eax
shrl $0x4, %eax
andl $0xf, %eax
movb (%rax,%rdx), %al
movb %al, 0x2(%rdi)
andl $0xf, %esi
movb (%rsi,%rdx), %al
movb %al, 0x3(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/jnum.c
// Function: fill_1_2_hexs
static inline int fill_1_2_hexs(char *buffer, uint32_t num)
{
    char *s = buffer;
    uint32_t q = num >> 4;
    uint32_t r = num & 0xf;

    if (q)
        *s++ = hex_char_lut[q];
    *s++ = hex_char_lut[r];
    return (int)(s - buffer);
}

// Assembly:
movq %rdi, %rax
cmpl $0x10, %esi
jb 0x7c60
movl %esi, %eax
shrl $0x4, %eax
leaq 0xe59(%rip), %rcx       # 0x8ab0
movb (%rax,%rcx), %cl
leaq 0x1(%rdi), %rax
movb %cl, (%rdi)
andl $0xf, %esi
leaq 0xe46(%rip), %rcx       # 0x8ab0
movb (%rsi,%rcx), %cl
movb %cl, (%rax)
subl %edi, %eax
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: set
static int
set(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * value)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_set(Q, key, value, callback_done, NULL)) {
		warnp("Error sending SET request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("SET request failed");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
andl $0x0, 0xda31(%rip)      # 0x10608
movq $0x1, 0xda2e(%rip) # 0x10610
leaq 0x4e5(%rip), %rcx       # 0x30ce
xorl %ebx, %ebx
xorl %r8d, %r8d
callq 0x4af6
testl %eax, %eax
je 0x2c0d
callq 0x2090
cmpl $0x0, (%rax)
je 0x2c41
movq %rax, %rbx
leaq 0x750a(%rip), %rdi      # 0xa115
jmp 0x2c35
leaq 0xd9f4(%rip), %rdi      # 0x10608
callq 0x348b
orl 0xd9ed(%rip), %eax      # 0x1060c
je 0x2c5b
callq 0x2090
cmpl $0x0, (%rax)
je 0x2c4a
movq %rax, %rbx
leaq 0x74fa(%rip), %rdi      # 0xa12f
xorl %eax, %eax
callq 0x45e1
andl $0x0, (%rbx)
jmp 0x2c58
leaq 0x74cd(%rip), %rdi      # 0xa115
jmp 0x2c51
leaq 0x74de(%rip), %rdi      # 0xa12f
xorl %eax, %eax
callq 0x4770
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: verify
static int
verify(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * value)
{

	/* Perform a get. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_get(Q, key, callback_get,
	    (void *)(uintptr_t)value)) {
		warnp("Error sending GET request");
		goto err0;
	}
	if (events_spin(&op_done) || op_failed) {
		warnp("GET request failed");
		goto err0;
	}
	if (op_badval) {
		warn0("Bad value returned by GET!");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
movq %rdx, %rcx
andl $0x0, 0xd99e(%rip)      # 0x10608
movq $0x1, 0xd99b(%rip) # 0x10610
leaq 0x47b(%rip), %rdx       # 0x30f7
callq 0x51fe
testl %eax, %eax
je 0x2c9b
callq 0x2090
cmpl $0x0, (%rax)
je 0x2ccf
movq %rax, %rbx
leaq 0x74a9(%rip), %rdi      # 0xa142
jmp 0x2cc3
leaq 0xd966(%rip), %rdi      # 0x10608
callq 0x348b
orl 0xd95f(%rip), %eax      # 0x1060c
je 0x2cd8
callq 0x2090
cmpl $0x0, (%rax)
je 0x2cfb
movq %rax, %rbx
leaq 0x7499(%rip), %rdi      # 0xa15c
xorl %eax, %eax
callq 0x45e1
andl $0x0, (%rbx)
jmp 0x2d09
leaq 0x746c(%rip), %rdi      # 0xa142
jmp 0x2d02
xorl %eax, %eax
cmpb $0x1, 0xd937(%rip)      # 0x10618
jne 0x2d0c
leaq 0x7485(%rip), %rdi      # 0xa16f
xorl %eax, %eax
callq 0x4770
callq 0x2090
andl $0x0, (%rax)
jmp 0x2d09
leaq 0x745a(%rip), %rdi      # 0xa15c
xorl %eax, %eax
callq 0x4770
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: add
static int
add(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * value, int noop)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_add(Q, key, value, callback_donep, NULL)) {
		warnp("Error sending ADD request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("ADD request failed");
		goto err0;
	}

	/* Check for no-op. */
	if (noop && op_p) {
		warn0("ADD should have been a no-op");
		goto err0;
	}
	if (!noop && !op_p) {
		warn0("ADD should not have been a no-op");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
movl %ecx, %ebx
andl $0x0, 0xd8f0(%rip)      # 0x10608
movq $0x1, 0xd8ed(%rip) # 0x10610
leaq 0x44a(%rip), %rcx       # 0x3174
xorl %r8d, %r8d
callq 0x4e59
testl %eax, %eax
je 0x2d4c
callq 0x2090
cmpl $0x0, (%rax)
je 0x2d80
movq %rax, %rbx
leaq 0x7440(%rip), %rdi      # 0xa18a
jmp 0x2d74
leaq 0xd8b5(%rip), %rdi      # 0x10608
callq 0x348b
orl 0xd8ae(%rip), %eax      # 0x1060c
je 0x2d89
callq 0x2090
cmpl $0x0, (%rax)
je 0x2dc7
movq %rax, %rbx
leaq 0x7430(%rip), %rdi      # 0xa1a4
xorl %eax, %eax
callq 0x45e1
andl $0x0, (%rbx)
jmp 0x2dd5
leaq 0x7403(%rip), %rdi      # 0xa18a
jmp 0x2dce
testl %ebx, %ebx
setne %al
movl 0xd888(%rip), %ecx      # 0x1061c
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x2da9
leaq 0x7410(%rip), %rdi      # 0xa1b7
jmp 0x2db6
xorl %eax, %eax
orl %ecx, %ebx
jne 0x2dd8
leaq 0x741e(%rip), %rdi      # 0xa1d4
xorl %eax, %eax
callq 0x4770
callq 0x2090
andl $0x0, (%rax)
jmp 0x2dd5
leaq 0x73d6(%rip), %rdi      # 0xa1a4
xorl %eax, %eax
callq 0x4770
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: delete
static int
delete(struct wire_requestqueue * Q, const struct kvldskey * key)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_delete(Q, key, callback_done, NULL)) {
		warnp("Error sending DELETE request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("DELETE request failed");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
andl $0x0, 0xd826(%rip)      # 0x10608
movq $0x1, 0xd823(%rip) # 0x10610
leaq 0x2da(%rip), %rdx       # 0x30ce
xorl %ebx, %ebx
xorl %ecx, %ecx
callq 0x5055
testl %eax, %eax
je 0x2e17
callq 0x2090
cmpl $0x0, (%rax)
je 0x2e4b
movq %rax, %rbx
leaq 0x73e0(%rip), %rdi      # 0xa1f5
jmp 0x2e3f
leaq 0xd7ea(%rip), %rdi      # 0x10608
callq 0x348b
orl 0xd7e3(%rip), %eax      # 0x1060c
je 0x2e65
callq 0x2090
cmpl $0x0, (%rax)
je 0x2e54
movq %rax, %rbx
leaq 0x752d(%rip), %rdi      # 0xa36c
xorl %eax, %eax
callq 0x45e1
andl $0x0, (%rbx)
jmp 0x2e62
leaq 0x73a3(%rip), %rdi      # 0xa1f5
jmp 0x2e5b
leaq 0x7511(%rip), %rdi      # 0xa36c
xorl %eax, %eax
callq 0x4770
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: modify
static int
modify(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * value, int noop)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_modify(Q, key, value, callback_donep, NULL)) {
		warnp("Error sending MODIFY request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("MODIFY request failed");
		goto err0;
	}

	/* Check for no-op. */
	if (noop && op_p) {
		warn0("MODIFY should have been a no-op");
		goto err0;
	}
	if (!noop && !op_p) {
		warn0("MODIFY should not have been a no-op");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
movl %ecx, %ebx
andl $0x0, 0xd795(%rip)      # 0x10608
movq $0x1, 0xd792(%rip) # 0x10610
leaq 0x2ef(%rip), %rcx       # 0x3174
xorl %r8d, %r8d
callq 0x4f57
testl %eax, %eax
je 0x2ea7
callq 0x2090
cmpl $0x0, (%rax)
je 0x2edb
movq %rax, %rbx
leaq 0x736d(%rip), %rdi      # 0xa212
jmp 0x2ecf
leaq 0xd75a(%rip), %rdi      # 0x10608
callq 0x348b
orl 0xd753(%rip), %eax      # 0x1060c
je 0x2ee4
callq 0x2090
cmpl $0x0, (%rax)
je 0x2f22
movq %rax, %rbx
leaq 0x7360(%rip), %rdi      # 0xa22f
xorl %eax, %eax
callq 0x45e1
andl $0x0, (%rbx)
jmp 0x2f30
leaq 0x7330(%rip), %rdi      # 0xa212
jmp 0x2f29
testl %ebx, %ebx
setne %al
movl 0xd72d(%rip), %ecx      # 0x1061c
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x2f04
leaq 0x7343(%rip), %rdi      # 0xa245
jmp 0x2f11
xorl %eax, %eax
orl %ecx, %ebx
jne 0x2f33
leaq 0x7354(%rip), %rdi      # 0xa265
xorl %eax, %eax
callq 0x4770
callq 0x2090
andl $0x0, (%rax)
jmp 0x2f30
leaq 0x7306(%rip), %rdi      # 0xa22f
xorl %eax, %eax
callq 0x4770
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: cas
static int
cas(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * oval,
    const struct kvldskey * value, int noop)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_cas(Q, key, oval, value, callback_donep, NULL)) {
		warnp("Error sending CAS request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("CAS request failed");
		goto err0;
	}

	/* Check for no-op. */
	if (noop && op_p) {
		warn0("CAS should have been a no-op");
		goto err0;
	}
	if (!noop && !op_p) {
		warn0("CAS should not have been a no-op");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
movl %r8d, %ebx
andl $0x0, 0xd6c8(%rip)      # 0x10608
movq $0x1, 0xd6c5(%rip) # 0x10610
leaq 0x222(%rip), %r8        # 0x3174
xorl %r9d, %r9d
callq 0x4c7b
testl %eax, %eax
je 0x2f74
callq 0x2090
cmpl $0x0, (%rax)
je 0x2fa8
movq %rax, %rbx
leaq 0x7317(%rip), %rdi      # 0xa289
jmp 0x2f9c
leaq 0xd68d(%rip), %rdi      # 0x10608
callq 0x348b
orl 0xd686(%rip), %eax      # 0x1060c
je 0x2fb1
callq 0x2090
cmpl $0x0, (%rax)
je 0x2fef
movq %rax, %rbx
leaq 0x7307(%rip), %rdi      # 0xa2a3
xorl %eax, %eax
callq 0x45e1
andl $0x0, (%rbx)
jmp 0x2ffd
leaq 0x72da(%rip), %rdi      # 0xa289
jmp 0x2ff6
testl %ebx, %ebx
setne %al
movl 0xd660(%rip), %ecx      # 0x1061c
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x2fd1
leaq 0x72e7(%rip), %rdi      # 0xa2b6
jmp 0x2fde
xorl %eax, %eax
orl %ecx, %ebx
jne 0x3000
leaq 0x72f5(%rip), %rdi      # 0xa2d3
xorl %eax, %eax
callq 0x4770
callq 0x2090
andl $0x0, (%rax)
jmp 0x2ffd
leaq 0x72ad(%rip), %rdi      # 0xa2a3
xorl %eax, %eax
callq 0x4770
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: cad
static int
cad(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * oval, int noop)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_cad(Q, key, oval, callback_donep, NULL)) {
		warnp("Error sending CAD request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("CAD request failed");
		goto err0;
	}

	/* Check for no-op. */
	if (noop && op_p) {
		warn0("CAD should have been a no-op");
		goto err0;
	}
	if (!noop && !op_p) {
		warn0("CAD should not have been a no-op");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
movl %ecx, %ebx
andl $0x0, 0xd5fc(%rip)      # 0x10608
movq $0x1, 0xd5f9(%rip) # 0x10610
leaq 0x156(%rip), %rcx       # 0x3174
xorl %r8d, %r8d
callq 0x5100
testl %eax, %eax
je 0x3040
callq 0x2090
cmpl $0x0, (%rax)
je 0x3074
movq %rax, %rbx
leaq 0x72b6(%rip), %rdi      # 0xa2f4
jmp 0x3068
leaq 0xd5c1(%rip), %rdi      # 0x10608
callq 0x348b
orl 0xd5ba(%rip), %eax      # 0x1060c
je 0x307d
callq 0x2090
cmpl $0x0, (%rax)
je 0x30bb
movq %rax, %rbx
leaq 0x72a6(%rip), %rdi      # 0xa30e
xorl %eax, %eax
callq 0x45e1
andl $0x0, (%rbx)
jmp 0x30c9
leaq 0x7279(%rip), %rdi      # 0xa2f4
jmp 0x30c2
testl %ebx, %ebx
setne %al
movl 0xd594(%rip), %ecx      # 0x1061c
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x309d
leaq 0x7286(%rip), %rdi      # 0xa321
jmp 0x30aa
xorl %eax, %eax
orl %ecx, %ebx
jne 0x30cc
leaq 0x7294(%rip), %rdi      # 0xa33e
xorl %eax, %eax
callq 0x4770
callq 0x2090
andl $0x0, (%rax)
jmp 0x30c9
leaq 0x724c(%rip), %rdi      # 0xa30e
xorl %eax, %eax
callq 0x4770
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: callback_get
static int
callback_get(void * cookie, int failed, struct kvldskey * value)
{
	struct kvldskey * value_correct = cookie;

	/* Record failure status. */
	if (failed) {
		op_failed = 1;
		op_done = 1;
	}

	/* Check that the value matches. */
	if (failed == 0) {
		if ((value == NULL) ^ (value_correct == NULL))
			goto bad;
		if ((value != NULL) &&
		    (value->len != value_correct->len))
			goto bad;
		if ((value != NULL) &&
		    memcmp(value->buf, value_correct->buf, value->len))
			goto bad;
		kvldskey_free(value);
	}

	/* Decrement the counter. */
	op_count -= 1;

	/* Are we done? */
	if (op_count == 0)
		op_done = 1;

	/* Success! */
	return (0);

bad:
	op_done = 1;
	op_badval = 1;
	return (0);
}

// Assembly:
pushq %rbx
testl %esi, %esi
je 0x3120
pushq $0x1
popq %rax
movl %eax, 0xd507(%rip)      # 0x1060c
movl %eax, 0xd4fd(%rip)      # 0x10608
decq 0xd4fe(%rip)            # 0x10610
jne 0x3166
movl $0x1, 0xd4ea(%rip)      # 0x10608
jmp 0x3166
movq %rdx, %rbx
movq %rdi, %rax
testq %rdx, %rdx
sete %cl
testq %rdi, %rdi
sete %dl
xorb %cl, %dl
jne 0x3155
testq %rbx, %rbx
je 0x316a
movzbl (%rbx), %edx
cmpb (%rax), %dl
jne 0x3155
leaq 0x1(%rbx), %rdi
incq %rax
movq %rax, %rsi
callq 0x2210
testl %eax, %eax
je 0x316a
movl $0x1, 0xd4a9(%rip)      # 0x10608
movb $0x1, 0xd4b2(%rip)      # 0x10618
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0x2040
jmp 0x310b