LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x4d04
cmpq %rsi, %rcx
sete %cl
xorl %ebp, %ebp
orb %cl, %al
jne 0x4ce3
movq %r15, %rdx
callq 0x1090
xorl %ebp, %ebp
cmpq %rax, %r15
je 0x4cdd
leaq 0x57a3(%rip), %rdi      # 0xa45c
leaq 0x59cd(%rip), %rsi      # 0xa68d
movl $0x6e7, %edx            # imm = 0x6E7
xorl %eax, %eax
callq 0x10c0
leaq 0x5c7f(%rip), %rdi      # 0xa952
callq 0x1060
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl (%rbx), %edi
testl %edi, %edi
js 0x4ce8
callq 0x1100
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x4d1f
movq 0x20(%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x4d6d
testb %al, %al
je 0x4d37
testq %rsi, %rsi
je 0x4d15
movq %rsi, %rdi
callq 0x1030
movq $0x0, 0x8(%rbx)
jmp 0x4d6b
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4d2d
callq 0x1030
movq $0x0, 0x8(%rbx)
jmp 0x4d6d
testq %rdx, %rdx
je 0x4d3f
movq %r15, (%rdx)
movb $0x0, (%rcx)
testq %r14, %r14
je 0x4d58
movq 0x20(%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x4d6b
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_O3/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
movl $0x1, %edi
movl $0x60, %esi
callq 0x1120
testq %rax, %rax
je 0x4ec5
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 0x4b2f
testl %eax, %eax
js 0x4eef
movl $0x10, (%rbx)
movl $0x80, %edi
callq 0x1150
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x4ef9
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4c74
movq %rbx, %rdi
callq 0x1030
leaq 0x55b8(%rip), %rdi      # 0xa45c
leaq 0x5702(%rip), %rsi      # 0xa5ad
movl $0x823, %edx            # imm = 0x823
xorl %eax, %eax
callq 0x10c0
leaq 0x5aa2(%rip), %rdi      # 0xa960
callq 0x1060
jmp 0x4ef7
leaq 0x5590(%rip), %rdi      # 0xa45c
leaq 0x56da(%rip), %rsi      # 0xa5ad
xorl %ebx, %ebx
movl $0x816, %edx            # imm = 0x816
xorl %eax, %eax
callq 0x10c0
leaq 0x5a78(%rip), %rdi      # 0xa960
callq 0x1060
jmp 0x4ef9
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f4e
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4f29
callq 0x1030
leaq 0x10(%rbx), %rdi
cmpb $0x1, 0x5c(%rbx)
jne 0x4f53
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4c74
movq %rbx, %rdi
callq 0x1030
jmp 0x4f85
xorl %r15d, %r15d
jmp 0x4f85
cmpl $0x0, (%rdi)
js 0x4f61
leaq 0x5626(%rip), %r13      # 0xa585
jmp 0x4f65
movq 0x18(%rbx), %r13
xorl %r15d, %r15d
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x4c74
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1030
testl %ebp, %ebp
cmovnsq %r13, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
xorl %ebp, %ebp
movl $0x40, %edx
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rcx
callq 0x7498
testl %eax, %eax
je 0x527b
movq 0x8(%rsp), %rax
movb (%rax), %cl
leal -0x1(%rcx), %edx
cmpb $0x1f, %dl
ja 0x5272
incl %ebp
movb 0x1(%rax), %cl
incq %rax
leal -0x1(%rcx), %edx
cmpb $0x20, %dl
jb 0x5262
movq %rax, 0x8(%rsp)
testb %cl, %cl
je 0x523d
movslq %ebp, %rax
addq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x72ee
movl (%rbx), %edi
movq %r15, %rdx
callq 0x1090
cmpq %rax, %r15
jne 0x732e
movq 0x8(%rbx), %rsi
movq %rsi, 0x10(%rbx)
incq %r14
movq 0x20(%rbx), %rax
xorl %ebp, %ebp
cmpq %r14, %rax
jae 0x7390
leaq 0x8(%rbx), %r15
movq 0x28(%rbx), %rcx
addq %rcx, %rax
cmpq %r14, %rax
jb 0x7308
movq %rax, 0x20(%rbx)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1180
testq %rax, %rax
je 0x7356
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
jmp 0x7390
leaq 0x3127(%rip), %rdi      # 0xa45c
leaq 0x3310(%rip), %rsi      # 0xa64c
movl $0x587, %edx            # imm = 0x587
xorl %eax, %eax
callq 0x10c0
leaq 0x3603(%rip), %rdi      # 0xa952
callq 0x1060
jmp 0x738b
leaq 0x30ff(%rip), %rdi      # 0xa45c
leaq 0x32e8(%rip), %rsi      # 0xa64c
movl $0x596, %edx            # imm = 0x596
xorl %eax, %eax
callq 0x10c0
leaq 0x35e9(%rip), %rdi      # 0xa960
callq 0x1060
movq (%r15), %rdi
callq 0x1030
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq %rdi, %r15
movslq 0x3c(%rbx), %rcx
movl 0x38(%rbx), %eax
cmpl %ecx, %eax
jge 0x73f9
movq 0x28(%rbx), %rdx
shrq $0x2, %rdx
leal 0x40(%rax), %r8d
cmpl %r8d, %ecx
cmovgl %ecx, %r8d
movl %eax, %r9d
notl %r9d
addl %r8d, %r9d
movl %r9d, %r8d
andl $-0x40, %r8d
shrl $0x6, %r9d
incl %r9d
imulq %rdx, %r9
addl %r8d, %eax
addl $0x40, %eax
movl %eax, 0x38(%rbx)
addq %r9, 0x20(%rbx)
leaq (%rsi,%r15), %r8
incq %r8
subl %ecx, %eax
movq 0x20(%rbx), %rsi
cmpl %ecx, %eax
jle 0x740f
addq %rsi, %rsi
jmp 0x741d
cltq
imulq %rsi, %rax
xorl %edx, %edx
divq %rcx
addq %rax, %rsi
movq %rsi, 0x20(%rbx)
cmpq %r8, %rsi
jae 0x7436
movq 0x28(%rbx), %rax
addq %rax, %rsi
cmpq %r8, %rsi
jb 0x742a
movq %rsi, 0x20(%rbx)
callq 0x1180
movq %rax, %r14
testq %rax, %rax
je 0x744d
movq %r14, %r12
addq %r15, %r12
xorl %eax, %eax
jmp 0x7484
leaq 0x3008(%rip), %rdi      # 0xa45c
leaq 0x3209(%rip), %rsi      # 0xa664
xorl %r12d, %r12d
movl $0x5b9, %edx            # imm = 0x5B9
xorl %eax, %eax
callq 0x10c0
leaq 0x34ef(%rip), %rdi      # 0xa960
callq 0x1060
movq 0x8(%rbx), %rdi
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0x0, 0x4(%rsp)
testl %edi, %edi
je 0x7b22
movl %edi, %esi
js 0x7b31
movq %rbx, %r14
jmp 0x7b3a
movw $0x30, (%rbx)
movl $0x1, %eax
jmp 0x7c49
negl %esi
leaq 0x1(%rbx), %r14
movb $0x2d, (%rbx)
cmpl $0x5f5e0ff, %esi        # imm = 0x5F5E0FF
ja 0x7b59
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x7c5a
cltq
addq %r14, %rax
jmp 0x7c44
movl %esi, %eax
imulq $0x55e63b89, %rax, %rax # imm = 0x55E63B89
shrq $0x39, %rax
imull $0xfa0a1f00, %eax, %ecx # imm = 0xFA0A1F00
addl %esi, %ecx
cmpl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
jb 0x7b8b
leaq 0x2f53(%rip), %rdx      # 0xaad0
movzwl (%rdx,%rax,2), %eax
movw %ax, (%r14)
addq $0x2, %r14
jmp 0x7b93
orb $0x30, %al
movb %al, (%r14)
incq %r14
movq %r14, %rax
testl %ecx, %ecx
je 0x7bcd
cmpl $0x270f, %ecx           # imm = 0x270F
ja 0x7bdc
movl $0x30303030, (%rax)     # imm = 0x30303030
imull $0x147b, %ecx, %edx     # imm = 0x147B
shrl $0x13, %edx
imull $-0x64, %edx, %esi
addl %ecx, %esi
leaq 0x2f13(%rip), %rcx      # 0xaad0
movzwl (%rcx,%rdx,2), %edx
movw %dx, 0x4(%rax)
addl %esi, %esi
movzwl (%rsi,%rcx), %ecx
jmp 0x7c3c
movabsq $0x3030303030303030, %rcx # imm = 0x3030303030303030
movq %rcx, (%rax)
jmp 0x7c40
movl %ecx, %edx
imulq $0x68db8bb, %rdx, %rsi  # imm = 0x68DB8BB
shrq $0x28, %rsi
imull $0xffffd8f0, %esi, %edx # imm = 0xFFFFD8F0
imull $0x147b, %esi, %edi     # imm = 0x147B
shrl $0x13, %edi
imull $-0x64, %edi, %r8d
addl %esi, %r8d
addl %r8d, %r8d
leaq 0x2ec7(%rip), %rsi      # 0xaad0
movzwl (%rsi,%rdi,2), %edi
movw %di, (%rax)
movzwl (%r8,%rsi), %edi
movw %di, 0x2(%rax)
addl %ecx, %edx
je 0x7c51
imull $0x147b, %edx, %ecx     # imm = 0x147B
shrl $0x13, %ecx
imull $0x7fffff9c, %ecx, %edi # imm = 0x7FFFFF9C
addl %edx, %edi
movzwl (%rsi,%rcx,2), %ecx
movw %cx, 0x4(%rax)
addl %edi, %edi
movzwl (%rdi,%rsi), %ecx
movw %cx, 0x6(%rax)
addq $0x8, %rax
movb $0x0, (%rax)
subl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x30303030, 0x4(%rax)  # imm = 0x30303030
jmp 0x7c40
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0x4(%rsp)
testq %rdi, %rdi
je 0x7ead
movq %rdi, %rsi
js 0x7eb9
movq %rbx, %r14
jmp 0x7ec3
movw $0x30, (%rbx)
movl $0x1, %eax
jmp 0x7ede
negq %rsi
leaq 0x1(%rbx), %r14
movb $0x2d, (%rbx)
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x7ee6
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_O3/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:
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x8444
cmpl $0xff, %esi
ja 0x848f
movq %rdi, %rax
cmpl $0x10, %esi
jb 0x842e
movl %esi, %eax
shrl $0x4, %eax
leaq 0x268b(%rip), %rcx      # 0xaab0
movb (%rax,%rcx), %cl
leaq 0x1(%rdi), %rax
movb %cl, (%rdi)
andl $0xf, %esi
leaq 0x2678(%rip), %rcx      # 0xaab0
movb (%rsi,%rcx), %cl
movb %cl, (%rax)
subq %rdi, %rax
incq %rax
retq
movl %esi, %eax
shrl $0x10, %eax
cmpl $0xffffff, %esi         # imm = 0xFFFFFF
ja 0x84e7
movq %rdi, %rcx
cmpl $0x100000, %esi         # imm = 0x100000
jb 0x8475
movl %esi, %ecx
shrl $0x14, %ecx
leaq 0x2644(%rip), %rdx      # 0xaab0
movb (%rcx,%rdx), %dl
leaq 0x1(%rdi), %rcx
movb %dl, (%rdi)
andl $0xf, %eax
leaq 0x2631(%rip), %rdx      # 0xaab0
movb (%rax,%rdx), %al
movb %al, (%rcx)
subq %rdi, %rcx
incq %rcx
jmp 0x8543
movl %esi, %eax
shrl $0x8, %eax
movq %rdi, %rcx
cmpl $0x1000, %esi           # imm = 0x1000
jb 0x84b4
movl %esi, %ecx
shrl $0xc, %ecx
leaq 0x2605(%rip), %rdx      # 0xaab0
movb (%rcx,%rdx), %dl
leaq 0x1(%rdi), %rcx
movb %dl, (%rdi)
andl $0xf, %eax
leaq 0x25f2(%rip), %rdx      # 0xaab0
movb (%rax,%rdx), %al
movb %al, (%rcx)
subl %edi, %ecx
incl %ecx
movslq %ecx, %rax
movl %esi, %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
movb (%rcx,%rdx), %cl
movb %cl, (%rdi,%rax)
andl $0xf, %esi
movb (%rsi,%rdx), %cl
movb %cl, 0x1(%rdi,%rax)
addq $0x2, %rax
retq
movl %esi, %ecx
shrl $0x18, %ecx
movq %rdi, %rdx
cmpl $0x10000000, %esi       # imm = 0x10000000
jb 0x850e
movl %esi, %edx
shrl $0x1c, %edx
leaq 0x25ad(%rip), %r8       # 0xaab0
movb (%rdx,%r8), %r8b
leaq 0x1(%rdi), %rdx
movb %r8b, (%rdi)
andl $0xf, %ecx
leaq 0x2598(%rip), %r8       # 0xaab0
movb (%rcx,%r8), %cl
movb %cl, (%rdx)
subl %edi, %edx
incl %edx
movslq %edx, %rcx
movl %esi, %edx
shrl $0x14, %edx
andl $0xf, %edx
movb (%rdx,%r8), %dl
movb %dl, (%rdi,%rcx)
andl $0xf, %eax
movb (%rax,%r8), %al
movb %al, 0x1(%rdi,%rcx)
addq $0x2, %rcx
movslq %ecx, %rcx
leaq (%rdi,%rcx), %rax
movl %esi, %edx
shrl $0x8, %edx
movl %esi, %r8d
shrl $0xc, %r8d
andl $0xf, %r8d
leaq 0x254f(%rip), %r9       # 0xaab0
movb (%r8,%r9), %r8b
movb %r8b, (%rdi,%rcx)
andl $0xf, %edx
movb (%rdx,%r9), %dl
movb %dl, 0x1(%rdi,%rcx)
movl %esi, %edx
shrl $0x4, %edx
andl $0xf, %edx
movb (%rdx,%r9), %dl
movb %dl, 0x2(%rdi,%rcx)
andl $0xf, %esi
movb (%rsi,%r9), %dl
movb %dl, 0x3(%rdi,%rcx)
subq %rdi, %rax
addq $0x4, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movw $0x7830, (%rsi)         # imm = 0x7830
leaq 0x2(%rsi), %r15
movq %rdi, %rsi
movq %r15, %rdi
shrq $0x20, %rsi
jne 0x85c9
movl %r14d, %esi
callq 0x8401
cltq
addq %r15, %rax
jmp 0x8657
callq 0x8401
cltq
movl %r14d, %edx
shrl $0x10, %edx
movl %r14d, %esi
shrl $0x18, %esi
movl %r14d, %edi
shrl $0x1c, %edi
leaq 0x24c7(%rip), %rcx      # 0xaab0
movb (%rdi,%rcx), %dil
addq %r15, %rax
addq $0x8, %rax
movb %dil, -0x8(%rax)
andl $0xf, %esi
movb (%rsi,%rcx), %sil
movb %sil, -0x7(%rax)
movl %r14d, %esi
shrl $0x14, %esi
andl $0xf, %esi
movb (%rsi,%rcx), %sil
movb %sil, -0x6(%rax)
andl $0xf, %edx
movb (%rdx,%rcx), %dl
movb %dl, -0x5(%rax)
movl %r14d, %edx
shrl $0x8, %edx
movl %r14d, %esi
shrl $0xc, %esi
andl $0xf, %esi
movb (%rsi,%rcx), %sil
movb %sil, -0x4(%rax)
andl $0xf, %edx
movb (%rdx,%rcx), %dl
movb %dl, -0x3(%rax)
movl %r14d, %edx
shrl $0x4, %edx
andl $0xf, %edx
movb (%rdx,%rcx), %dl
movb %dl, -0x2(%rax)
andl $0xf, %r14d
movb (%r14,%rcx), %cl
movb %cl, -0x1(%rax)
movb $0x0, (%rax)
subl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x5f5e0ff, %rsi        # imm = 0x5F5E0FF
ja 0x8d63
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x7c5a
movabsq $-0x543388ee7b9e3103, %rcx # imm = 0xABCC77118461CEFD
movq %rsi, %rax
mulq %rcx
shrq $0x1a, %rdx
movl $0xfa0a1f00, %r15d      # imm = 0xFA0A1F00
imulq %rdx, %r15
addq %rsi, %r15
movq %rbx, %rdi
movl %edx, %esi
movq %r14, %rdx
callq 0x7c5a
cltq
addq %rbx, %rax
testl %r15d, %r15d
je 0x8ddf
cmpl $0x270f, %r15d          # imm = 0x270F
ja 0x8df5
movl $0x30303030, (%rax)     # imm = 0x30303030
imull $0x147b, %r15d, %ecx    # imm = 0x147B
shrl $0x13, %ecx
imull $-0x64, %ecx, %edx
addl %r15d, %edx
leaq 0x1d0f(%rip), %rsi      # 0xaad0
movzwl (%rsi,%rcx,2), %edi
movw %di, 0x4(%rax)
leal (%rdx,%rdx), %edi
movzwl (%rdi,%rsi), %esi
movw %si, 0x6(%rax)
testl %edx, %edx
je 0x8e4b
movl %edx, %ecx
jmp 0x8e94
addl $0x8, (%r14)
movabsq $0x3030303030303030, %rcx # imm = 0x3030303030303030
movq %rcx, (%rax)
jmp 0x8ec1
movl %r15d, %ecx
imulq $0x68db8bb, %rcx, %rdx  # imm = 0x68DB8BB
shrq $0x28, %rdx
imull $0xffffd8f0, %edx, %ecx # imm = 0xFFFFD8F0
addl %r15d, %ecx
imull $0x147b, %edx, %esi     # imm = 0x147B
shrl $0x13, %esi
imull $-0x64, %esi, %edi
addl %edx, %edi
leaq 0x1caf(%rip), %rdx      # 0xaad0
movzwl (%rdx,%rsi,2), %r8d
movw %r8w, (%rax)
leal (%rdi,%rdi), %r8d
movzwl (%r8,%rdx), %r8d
movw %r8w, 0x2(%rax)
testl %edi, %edi
je 0x8e58
movl %edi, %esi
leaq 0x1d5b(%rip), %rdi      # 0xaba0
movzbl (%rsi,%rdi), %esi
jmp 0x8e66
leaq 0x1d4e(%rip), %rdx      # 0xaba0
movzbl (%rcx,%rdx), %ecx
jmp 0x8ebb
leaq 0x1d41(%rip), %rdi      # 0xaba0
movzbl (%rsi,%rdi), %esi
addl $0x2, %esi
movl %esi, (%r14)
testl %ecx, %ecx
je 0x8ea1
imull $0x147b, %ecx, %esi     # imm = 0x147B
shrl $0x13, %esi
imull $-0x64, %esi, %edi
addl %ecx, %edi
movzwl (%rdx,%rsi,2), %ecx
movw %cx, 0x4(%rax)
leal (%rdi,%rdi), %ecx
movzwl (%rcx,%rdx), %ecx
movw %cx, 0x6(%rax)
testl %edi, %edi
je 0x8eb0
movl %edi, %ecx
leaq 0x1d05(%rip), %rdx      # 0xaba0
movzbl (%rcx,%rdx), %ecx
jmp 0x8ebe
movl $0x30303030, 0x4(%rax)  # imm = 0x30303030
movl (%r14), %ecx
addl $0x4, %ecx
jmp 0x8ebe
leaq 0x1ce9(%rip), %rcx      # 0xaba0
movzbl (%rsi,%rcx), %ecx
addl $0x2, %ecx
movl %ecx, (%r14)
subl %ebx, %eax
addl $0x8, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0xe6c1(%rip)      # 0x11618
movq $0x1, 0xe6be(%rip) # 0x11620
leaq 0x529(%rip), %rcx       # 0x3492
xorl %ebx, %ebx
xorl %r8d, %r8d
callq 0x513d
testl %eax, %eax
je 0x2f8d
callq 0x2090
cmpl $0x0, (%rax)
je 0x2fc4
movq %rax, %rbx
leaq 0x8206(%rip), %rdi      # 0xb191
jmp 0x2fb5
leaq 0xe684(%rip), %rdi      # 0x11618
callq 0x3865
orl 0xe67d(%rip), %eax      # 0x1161c
je 0x2fe0
callq 0x2090
cmpl $0x0, (%rax)
je 0x2fcd
movq %rax, %rbx
leaq 0x81f6(%rip), %rdi      # 0xb1ab
xorl %eax, %eax
callq 0x4ccc
movl $0x0, (%rbx)
jmp 0x2fdb
leaq 0x81c6(%rip), %rdi      # 0xb191
jmp 0x2fd4
leaq 0x81d7(%rip), %rdi      # 0xb1ab
xorl %eax, %eax
callq 0x4deb
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0xe626(%rip)      # 0x11618
movq $0x1, 0xe623(%rip) # 0x11620
leaq 0x4b9(%rip), %rdx       # 0x34bd
callq 0x5a62
testl %eax, %eax
je 0x3023
callq 0x2090
cmpl $0x0, (%rax)
je 0x305a
movq %rax, %rbx
leaq 0x819d(%rip), %rdi      # 0xb1be
jmp 0x304b
leaq 0xe5ee(%rip), %rdi      # 0x11618
callq 0x3865
orl 0xe5e7(%rip), %eax      # 0x1161c
je 0x3063
callq 0x2090
cmpl $0x0, (%rax)
je 0x3089
movq %rax, %rbx
leaq 0x818d(%rip), %rdi      # 0xb1d8
xorl %eax, %eax
callq 0x4ccc
movl $0x0, (%rbx)
jmp 0x3097
leaq 0x815d(%rip), %rdi      # 0xb1be
jmp 0x3090
xorl %eax, %eax
cmpb $0x1, 0xe5bc(%rip)      # 0x11628
jne 0x309c
leaq 0x8176(%rip), %rdi      # 0xb1eb
xorl %eax, %eax
callq 0x4deb
callq 0x2090
movl $0x0, (%rax)
jmp 0x3097
leaq 0x8148(%rip), %rdi      # 0xb1d8
xorl %eax, %eax
callq 0x4deb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0xe56d(%rip)      # 0x11618
movq $0x1, 0xe56a(%rip) # 0x11620
leaq 0x47f(%rip), %rcx       # 0x353c
xorl %r8d, %r8d
callq 0x5530
testl %eax, %eax
je 0x30df
callq 0x2090
cmpl $0x0, (%rax)
je 0x3116
movq %rax, %rbx
leaq 0x8129(%rip), %rdi      # 0xb206
jmp 0x3107
leaq 0xe532(%rip), %rdi      # 0x11618
callq 0x3865
orl 0xe52b(%rip), %eax      # 0x1161c
je 0x311f
callq 0x2090
cmpl $0x0, (%rax)
je 0x3160
movq %rax, %rbx
leaq 0x8119(%rip), %rdi      # 0xb220
xorl %eax, %eax
callq 0x4ccc
movl $0x0, (%rbx)
jmp 0x316e
leaq 0x80e9(%rip), %rdi      # 0xb206
jmp 0x3167
testl %ebx, %ebx
setne %al
movl 0xe502(%rip), %ecx      # 0x1162c
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x313f
leaq 0x80f6(%rip), %rdi      # 0xb233
jmp 0x314c
xorl %eax, %eax
orl %ecx, %ebx
jne 0x3173
leaq 0x8104(%rip), %rdi      # 0xb250
xorl %eax, %eax
callq 0x4deb
callq 0x2090
movl $0x0, (%rax)
jmp 0x316e
leaq 0x80b9(%rip), %rdi      # 0xb220
xorl %eax, %eax
callq 0x4deb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0xe498(%rip)      # 0x11618
movq $0x1, 0xe495(%rip) # 0x11620
leaq 0x300(%rip), %rdx       # 0x3492
xorl %ebx, %ebx
xorl %ecx, %ecx
callq 0x57f6
testl %eax, %eax
je 0x31b5
callq 0x2090
cmpl $0x0, (%rax)
je 0x31ec
movq %rax, %rbx
leaq 0x80be(%rip), %rdi      # 0xb271
jmp 0x31dd
leaq 0xe45c(%rip), %rdi      # 0x11618
callq 0x3865
orl 0xe455(%rip), %eax      # 0x1161c
je 0x3208
callq 0x2090
cmpl $0x0, (%rax)
je 0x31f5
movq %rax, %rbx
leaq 0x820b(%rip), %rdi      # 0xb3e8
xorl %eax, %eax
callq 0x4ccc
movl $0x0, (%rbx)
jmp 0x3203
leaq 0x807e(%rip), %rdi      # 0xb271
jmp 0x31fc
leaq 0x81ec(%rip), %rdi      # 0xb3e8
xorl %eax, %eax
callq 0x4deb
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0xe3ff(%rip)      # 0x11618
movq $0x1, 0xe3fc(%rip) # 0x11620
leaq 0x311(%rip), %rcx       # 0x353c
xorl %r8d, %r8d
callq 0x5693
testl %eax, %eax
je 0x324d
callq 0x2090
cmpl $0x0, (%rax)
je 0x3284
movq %rax, %rbx
leaq 0x8043(%rip), %rdi      # 0xb28e
jmp 0x3275
leaq 0xe3c4(%rip), %rdi      # 0x11618
callq 0x3865
orl 0xe3bd(%rip), %eax      # 0x1161c
je 0x328d
callq 0x2090
cmpl $0x0, (%rax)
je 0x32ce
movq %rax, %rbx
leaq 0x8036(%rip), %rdi      # 0xb2ab
xorl %eax, %eax
callq 0x4ccc
movl $0x0, (%rbx)
jmp 0x32dc
leaq 0x8003(%rip), %rdi      # 0xb28e
jmp 0x32d5
testl %ebx, %ebx
setne %al
movl 0xe394(%rip), %ecx      # 0x1162c
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x32ad
leaq 0x8016(%rip), %rdi      # 0xb2c1
jmp 0x32ba
xorl %eax, %eax
orl %ecx, %ebx
jne 0x32e1
leaq 0x8027(%rip), %rdi      # 0xb2e1
xorl %eax, %eax
callq 0x4deb
callq 0x2090
movl $0x0, (%rax)
jmp 0x32dc
leaq 0x7fd6(%rip), %rdi      # 0xb2ab
xorl %eax, %eax
callq 0x4deb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0xe327(%rip)      # 0x11618
movq $0x1, 0xe324(%rip) # 0x11620
leaq 0x239(%rip), %r8        # 0x353c
xorl %r9d, %r9d
callq 0x5311
testl %eax, %eax
je 0x3325
callq 0x2090
cmpl $0x0, (%rax)
je 0x335c
movq %rax, %rbx
leaq 0x7fe2(%rip), %rdi      # 0xb305
jmp 0x334d
leaq 0xe2ec(%rip), %rdi      # 0x11618
callq 0x3865
orl 0xe2e5(%rip), %eax      # 0x1161c
je 0x3365
callq 0x2090
cmpl $0x0, (%rax)
je 0x33a6
movq %rax, %rbx
leaq 0x7fd2(%rip), %rdi      # 0xb31f
xorl %eax, %eax
callq 0x4ccc
movl $0x0, (%rbx)
jmp 0x33b4
leaq 0x7fa2(%rip), %rdi      # 0xb305
jmp 0x33ad
testl %ebx, %ebx
setne %al
movl 0xe2bc(%rip), %ecx      # 0x1162c
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x3385
leaq 0x7faf(%rip), %rdi      # 0xb332
jmp 0x3392
xorl %eax, %eax
orl %ecx, %ebx
jne 0x33b9
leaq 0x7fbd(%rip), %rdi      # 0xb34f
xorl %eax, %eax
callq 0x4deb
callq 0x2090
movl $0x0, (%rax)
jmp 0x33b4
leaq 0x7f72(%rip), %rdi      # 0xb31f
xorl %eax, %eax
callq 0x4deb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0xe250(%rip)      # 0x11618
movq $0x1, 0xe24d(%rip) # 0x11620
leaq 0x162(%rip), %rcx       # 0x353c
xorl %r8d, %r8d
callq 0x58ff
testl %eax, %eax
je 0x33fc
callq 0x2090
cmpl $0x0, (%rax)
je 0x3433
movq %rax, %rbx
leaq 0x7f76(%rip), %rdi      # 0xb370
jmp 0x3424
leaq 0xe215(%rip), %rdi      # 0x11618
callq 0x3865
orl 0xe20e(%rip), %eax      # 0x1161c
je 0x343c
callq 0x2090
cmpl $0x0, (%rax)
je 0x347d
movq %rax, %rbx
leaq 0x7f66(%rip), %rdi      # 0xb38a
xorl %eax, %eax
callq 0x4ccc
movl $0x0, (%rbx)
jmp 0x348b
leaq 0x7f36(%rip), %rdi      # 0xb370
jmp 0x3484
testl %ebx, %ebx
setne %al
movl 0xe1e5(%rip), %ecx      # 0x1162c
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x345c
leaq 0x7f43(%rip), %rdi      # 0xb39d
jmp 0x3469
xorl %eax, %eax
orl %ecx, %ebx
jne 0x3490
leaq 0x7f51(%rip), %rdi      # 0xb3ba
xorl %eax, %eax
callq 0x4deb
callq 0x2090
movl $0x0, (%rax)
jmp 0x348b
leaq 0x7f06(%rip), %rdi      # 0xb38a
xorl %eax, %eax
callq 0x4deb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: aez_encrypt
void aez_encrypt(aez_ctx_t *ctx, char *n, unsigned nbytes,
                 char *ad, unsigned adbytes, unsigned abytes,
                 char *src, unsigned bytes, char *dst) {
    
    block t = aez_hash(ctx, n, nbytes, ad, adbytes, abytes);
    if (bytes==0) {
        unsigned i;
        t = aes((block*)ctx, t, vxor(ctx->J[0], ctx->J[1]));
        for (i=0; i<abytes; i++) dst[i] = ((char*)&t)[i];
    } else if (bytes+abytes < 32)
        cipher_aez_tiny(ctx, t, 0, src, bytes, abytes, dst);
    else
        cipher_aez_core(ctx, t, 0, src, bytes, abytes, dst);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r14d
movq %rdi, %r12
movq 0x50(%rsp), %rbx
movl 0x48(%rsp), %r15d
movq 0x40(%rsp), %r13
callq 0x1070
testl %r15d, %r15d
je 0x2e1f
leal (%r15,%r14), %eax
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movl %r15d, %ecx
movl %r14d, %r8d
movq %rbx, %r9
addq $0x10, %rsp
cmpl $0x1f, %eax
ja 0x2e94
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1030
vmovdqa (%r12), %xmm1
vmovdqa 0x30(%r12), %xmm2
vmovdqa 0x60(%r12), %xmm3
vpternlogq $0x96, 0x40(%r12), %xmm2, %xmm0
vaesenc %xmm1, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm1, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm1, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
testl %r14d, %r14d
je 0x2e86
movl %r14d, %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: aez_decrypt
int aez_decrypt(aez_ctx_t *ctx, char *n, unsigned nbytes,
                char *ad, unsigned adbytes, unsigned abytes,
                char *src, unsigned bytes, char *dst) {
    
    block t;
    if (bytes < abytes) return -1;
    t = aez_hash(ctx, n, nbytes, ad, adbytes, abytes);
    if (bytes==abytes) {
        block claimed = zero_pad(load_partial(src,abytes), 16-abytes);
        t = zero_pad(aes((block*)ctx, t, vxor(ctx->J[0], ctx->J[1])), 16-abytes);
        return is_zero(vandnot(t, claimed)) - 1;  /* is_zero return 0 or 1 */
    } else if (bytes < 32) {
        return cipher_aez_tiny(ctx, t, 1, src, bytes, abytes, dst);
    } else {
        return cipher_aez_core(ctx, t, 1, src, bytes, abytes, dst);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x38(%rsp), %r15d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r9d, %r15d
jb 0x2f44
movl %r9d, %ebp
movq %rdi, %r14
movq 0x40(%rsp), %r12
movq 0x30(%rsp), %rbx
callq 0x1070
cmpl %ebp, %r15d
jne 0x2f4d
movl $0x10, %eax
subl %r15d, %eax
leaq 0x11da(%rip), %rcx      # 0x40c0
vmovdqu (%rax,%rcx), %xmm1
vmovdqa (%r14), %xmm2
vmovdqa 0x30(%r14), %xmm3
vmovdqa 0x60(%r14), %xmm4
vpternlogq $0x96, 0x40(%r14), %xmm3, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm4, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm4, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm4, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vpand (%rbx), %xmm1, %xmm1
xorl %eax, %eax
vptest %xmm1, %xmm0
adcl $-0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
movq %r12, %r9
cmpl $0x1f, %r15d
ja 0x2f74
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
)
{
    aez_ctx_t ctx;
    (void)nsec;
    if (clen) *clen = mlen+16;
    aez_setup((unsigned char *)k, 48, &ctx);
    aez_encrypt(&ctx, (char *)npub, 12,
                 (char *)ad, (unsigned)adlen, 16,
                 (char *)m, (unsigned)mlen, (char *)c);
    return 0;
}

// Assembly:
subq $0x88, %rsp
movq %rcx, %r10
movq %rdx, %rax
movq %rsi, %rcx
movq %rdi, %r11
movq 0xa0(%rsp), %rdx
movq 0x98(%rsp), %rsi
testq %rcx, %rcx
je 0x2fb0
leaq 0x10(%r10), %rdi
movq %rdi, (%rcx)
vmovdqu (%rdx), %xmm0
movq %rsp, %rdi
vmovdqa %xmm0, (%rdi)
vmovdqu 0x10(%rdx), %xmm1
vmovdqa %xmm1, 0x30(%rdi)
vmovups 0x20(%rdx), %xmm2
vmovaps %xmm2, 0x60(%rdi)
vmovdqa 0x1059(%rip), %xmm2     # 0x4030
vpshufb %xmm2, %xmm0, %xmm0
vpshufd $0x93, %xmm0, %xmm3     # xmm3 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm3, %xmm3
vpshufd $0x93, 0x1051(%rip), %xmm4 # xmm4 = mem[3,0,1,2]
vpaddd %xmm0, %xmm0, %xmm0
vpternlogd $0x6c, %xmm4, %xmm0, %xmm3
vpshufb %xmm2, %xmm3, %xmm5
vmovdqa %xmm5, 0x10(%rdi)
vpshufd $0x93, %xmm0, %xmm0     # xmm0 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm0, %xmm0
vpaddd %xmm3, %xmm3, %xmm3
vpternlogd $0x78, %xmm4, %xmm0, %xmm3
vpshufb %xmm2, %xmm3, %xmm0
vmovdqa %xmm0, 0x20(%rdi)
vpshufb %xmm2, %xmm1, %xmm0
vpshufd $0x93, %xmm0, %xmm1     # xmm1 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm1, %xmm1
vpaddd %xmm0, %xmm0, %xmm0
vpternlogd $0x6c, %xmm4, %xmm0, %xmm1
vpshufb %xmm2, %xmm1, %xmm3
vmovdqa %xmm3, 0x40(%rdi)
vpshufd $0x93, %xmm0, %xmm0     # xmm0 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm0, %xmm0
vpaddd %xmm1, %xmm1, %xmm1
vpternlogd $0x78, %xmm4, %xmm0, %xmm1
vpshufb %xmm2, %xmm1, %xmm0
vmovdqa %xmm0, 0x50(%rdi)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x70(%rdi)
subq $0x8, %rsp
movl $0xc, %edx
movq %r8, %rcx
movl %r9d, %r8d
movl $0x10, %r9d
pushq %r11
pushq %r10
pushq %rax
callq 0x10d0
addq $0x20, %rsp
xorl %eax, %eax
addq $0x88, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
)
{
    aez_ctx_t ctx;
    (void)nsec;
    if (mlen) *mlen = clen-16;
    aez_setup((unsigned char *)k, 48, &ctx);
    return aez_decrypt(&ctx, (char *)npub, 12,
                 (char *)ad, (unsigned)adlen, 16,
                 (char *)c, (unsigned)clen, (char *)m);
}

// Assembly:
subq $0x88, %rsp
movq %r8, %r10
movq %rcx, %rax
movq %rsi, %rcx
movq %rdi, %r11
movq 0xa0(%rsp), %rdx
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %r8
testq %rcx, %rcx
je 0x30d3
leaq -0x10(%r10), %rdi
movq %rdi, (%rcx)
vmovdqu (%rdx), %xmm0
movq %rsp, %rdi
vmovdqa %xmm0, (%rdi)
vmovdqu 0x10(%rdx), %xmm1
vmovdqa %xmm1, 0x30(%rdi)
vmovups 0x20(%rdx), %xmm2
vmovaps %xmm2, 0x60(%rdi)
vmovdqa 0xf36(%rip), %xmm2      # 0x4030
vpshufb %xmm2, %xmm0, %xmm0
vpshufd $0x93, %xmm0, %xmm3     # xmm3 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm3, %xmm3
vpshufd $0x93, 0xf2e(%rip), %xmm4 # xmm4 = mem[3,0,1,2]
vpaddd %xmm0, %xmm0, %xmm0
vpternlogd $0x6c, %xmm4, %xmm0, %xmm3
vpshufb %xmm2, %xmm3, %xmm5
vmovdqa %xmm5, 0x10(%rdi)
vpshufd $0x93, %xmm0, %xmm0     # xmm0 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm0, %xmm0
vpaddd %xmm3, %xmm3, %xmm3
vpternlogd $0x78, %xmm4, %xmm0, %xmm3
vpshufb %xmm2, %xmm3, %xmm0
vmovdqa %xmm0, 0x20(%rdi)
vpshufb %xmm2, %xmm1, %xmm0
vpshufd $0x93, %xmm0, %xmm1     # xmm1 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm1, %xmm1
vpaddd %xmm0, %xmm0, %xmm0
vpternlogd $0x6c, %xmm4, %xmm0, %xmm1
vpshufb %xmm2, %xmm1, %xmm3
vmovdqa %xmm3, 0x40(%rdi)
vpshufd $0x93, %xmm0, %xmm0     # xmm0 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm0, %xmm0
vpaddd %xmm1, %xmm1, %xmm1
vpternlogd $0x78, %xmm4, %xmm0, %xmm1
vpshufb %xmm2, %xmm1, %xmm0
vmovdqa %xmm0, 0x50(%rdi)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x70(%rdi)
subq $0x8, %rsp
movl $0xc, %edx
movq %r9, %rcx
movl $0x10, %r9d
pushq %r11
pushq %r10
pushq %rax
callq 0x10a0
addq $0xa8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]dohclient/src/log.c
// Function: log_write
void log_write(int mask,
		const char *file, const char *func, int line,
		const char *fmt, ...)
{
	if (log_level_comp(mask) <= loglevel) {
		va_list args;
		va_start(args, fmt);
		log_vwrite(mask, file, func, line, fmt, args);
		va_end(args);
	}
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x2ec4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r9, 0x48(%rsp)
movzbl %dil, %eax
cmpl 0x9331(%rip), %eax      # 0xc204
jg 0x2f29
leaq 0x20(%rsp), %r9
movq %r9, 0x10(%rsp)
leaq 0xe0(%rsp), %r9
movq %r9, 0x8(%rsp)
movabsq $0x3000000028, %r9      # imm = 0x3000000028
movq %r9, (%rsp)
cmpl 0x9304(%rip), %eax      # 0xc204
jg 0x2f29
testb $0x1, 0x92f7(%rip)      # 0xc200
movq 0x92e0(%rip), %rax      # 0xc1f0
movq %rax, %r9
je 0x2f1c
movq 0x92dc(%rip), %r9       # 0xc1f8
btl $0x8, %edi
cmovaeq %r9, %rax
movq %rsp, %r9
callq *%rax
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]dohclient/src/log.c
// Function: log_vprintf_writefile
void log_vprintf_writefile(int mask,
		const char *file, const char *func, int line,
		const char* fmt, va_list args)
{
	char *text = log_text(mask, 1, file, func, line, fmt, args);
	size_t len;
	if (text && (len = strlen(text)) > 0) {
		FILE* pf;
		pf = fopen(s_current_log_file, "a+");
		if (pf) {
			fwrite(text, 1, len, pf);
			fclose(pf);
		}
		else {
			printf("cannot open %s\n", s_current_log_file);
		}
	}
	free(text);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rdx
movl $0x1, %esi
callq 0x2fcb
movq %rax, %rbx
testq %rax, %rax
je 0x2fbe
movq %rbx, %rdi
callq 0x20e0
testq %rax, %rax
je 0x2fbe
movq %rax, %r14
movq 0x92b0(%rip), %rdi      # 0xc228
leaq 0x4085(%rip), %rsi      # 0x7004
callq 0x2280
testq %rax, %rax
je 0x2fa9
movq %rax, %r15
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x23a0
movq %r15, %rdi
callq 0x2210
jmp 0x2fbe
movq 0x9278(%rip), %rsi      # 0xc228
leaq 0x4050(%rip), %rdi      # 0x7007
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2290
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]dohclient/src/log.c
// Function: log_text
static char *log_text(int mask, int timestamp,
		const char *file, const char *func, int line,
		const char *fmt, va_list args)
{
	int level = log_level_comp(mask);
	char date[32] = {0};
	const char *extra_msg;
	const char *fname;
	char *text, *retval;
	time_t now;

	if (timestamp) {
		int x;
		now = time(NULL);
		strftime(date, sizeof(date), LOG_TIMEFORMAT, localtime(&now));
		x = strlen(date);
		date[x++] = ' ';
		date[x++] = '\0';
	}
	extra_msg = log_priorityname(level);
	fname = get_filename(file);
	text = log_vmprintf(fmt, args);

	retval = log_mprintf("%s[%s] %s:%d %s", date, extra_msg, fname, line, text);

	free(text);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r12
movl %edi, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testl %esi, %esi
je 0x303a
xorl %edi, %edi
callq 0x21e0
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2160
leaq 0x4068(%rip), %rdx      # 0x7079
movq %rsp, %r13
movl $0x20, %esi
movq %r13, %rdi
movq %rax, %rcx
callq 0x2190
movq %r13, %rdi
callq 0x20e0
cltq
movb $0x20, (%rsp,%rax)
incl %eax
cltq
movb $0x0, (%rsp,%rax)
movzbl %bpl, %eax
cmpl $0x8, %eax
ja 0x3052
movl %eax, %eax
leaq 0x8cd4(%rip), %rcx      # 0xbd20
movq (%rcx,%rax,8), %r13
jmp 0x3055
xorl %r13d, %r13d
testq %r12, %r12
je 0x3095
movq %r12, %rdi
callq 0x20e0
leaq (%r12,%rax), %rbp
testq %rax, %rax
jle 0x3081
movzbl (%rbp), %eax
cmpl $0x2f, %eax
je 0x3084
cmpl $0x5c, %eax
je 0x3084
decq %rbp
cmpq %r12, %rbp
ja 0x306b
movb (%rbp), %al
cmpb $0x5c, %al
je 0x3090
movzbl %al, %eax
cmpl $0x2f, %eax
jne 0x3097
incq %rbp
jmp 0x3097
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x31ed
movq %rax, %r14
movq %rsp, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movl %ebx, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x3270
movq %rax, %rbx
movq %r14, %rdi
callq 0x2290
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]dohclient/src/log.c
// Function: log_vprintf_syslog
void log_vprintf_syslog(int mask,
		const char *file, const char *func, int line,
		const char* fmt, va_list args)
{
#ifdef WINDOWS
	logw("log_vprintf_syslog(): not implemented in Windows port");
#else
	char *text = log_text(mask, 0, file, func, line, fmt, args);
	int priority = log_level_comp(mask);
	syslog(priority, "%s", text);
	free(text);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movl %edi, %ebx
xorl %esi, %esi
callq 0x2fcb
movq %rax, %r14
movzbl %bl, %edi
leaq 0x3fa3(%rip), %rsi      # 0x7098
movq %rax, %rdx
xorl %eax, %eax
callq 0x2060
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2290