LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0xa8da
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %edi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0x1090
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0xa8c8
jmp 0xa893
leaq 0x615a(%rip), %rdi      # 0x109f4
leaq 0x6412(%rip), %rsi      # 0x10cb3
movl $0x587, %edx            # imm = 0x587
movb $0x0, %al
callq 0x10c0
leaq 0x6417(%rip), %rdi      # 0x10ccb
movb $0x0, %al
callq 0x10c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xa9d7
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
cmpq 0x18(%rsp), %rax
jae 0xa9cf
jmp 0xa8fe
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
cmpq 0x18(%rsp), %rax
jae 0xa926
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x28(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0xa8fe
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x1180
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xa96c
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa9cd
jmp 0xa96e
leaq 0x607f(%rip), %rdi      # 0x109f4
leaq 0x6337(%rip), %rsi      # 0x10cb3
movl $0x596, %edx            # imm = 0x596
movb $0x0, %al
callq 0x10c0
leaq 0x6077(%rip), %rdi      # 0x10a06
movb $0x0, %al
callq 0x10c0
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xa9d7
jmp 0xa9cf
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: parse_hex4
static inline uint32_t _parse_hex4(const unsigned char *str)
{
    int i = 0;
    uint32_t val = 0;

    for (i = 0; i < 4; ++i) {
        switch (str[i]) {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            val = (val << 4) + (str[i] - '0');
            break;
        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
            val = (val << 4) + 10 + (str[i] - 'a');
            break;
        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            val = (val << 4) + 10 + (str[i] - 'A');
            break;
        default:
            return 0;
        }
    }

    return val;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x4, -0x14(%rsp)
jge 0xba12
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rsp)
addl $-0x30, %eax
subl $0xa, %eax
jb 0xb990
jmp 0xb974
movl -0x1c(%rsp), %eax
addl $-0x41, %eax
subl $0x6, %eax
jb 0xb9d3
jmp 0xb982
movl -0x1c(%rsp), %eax
addl $-0x61, %eax
subl $0x6, %eax
jb 0xb9b0
jmp 0xb9f6
movl -0x18(%rsp), %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movslq -0x14(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rsp)
jmp 0xba00
movl -0x18(%rsp), %eax
shll $0x4, %eax
addl $0xa, %eax
movq -0x10(%rsp), %rcx
movslq -0x14(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
subl $0x61, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rsp)
jmp 0xba00
movl -0x18(%rsp), %eax
shll $0x4, %eax
addl $0xa, %eax
movq -0x10(%rsp), %rcx
movslq -0x14(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
subl $0x41, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rsp)
jmp 0xba00
movl $0x0, -0x4(%rsp)
jmp 0xba1a
jmp 0xba02
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xb94d
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x0, 0x20(%rsp)
jne 0xc81a
movq 0x10(%rsp), %rax
movw 0x4858(%rip), %cx       # 0x11062
movw %cx, (%rax)
movl $0x1, 0x24(%rsp)
jmp 0xc982
cmpl $0x0, 0x20(%rsp)
jge 0xc841
xorl %eax, %eax
subl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb $0x2d, (%rax)
jmp 0xc849
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x5f5e100, 0xc(%rsp)   # imm = 0x5F5E100
jae 0xc87d
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0xc990
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xc969
movl 0xc(%rsp), %eax
imulq $0x55e63b89, %rax, %rax # imm = 0x55E63B89
shrq $0x39, %rax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
imull $0x5f5e100, 0x4(%rsp), %ecx # imm = 0x5F5E100
subl %ecx, %eax
movl %eax, (%rsp)
cmpl $0xa, 0x4(%rsp)
jb 0xc8ea
movl 0x4(%rsp), %eax
movl %eax, %ecx
leaq 0x488b(%rip), %rax      # 0x11140
movzbl (%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x479d(%rip), %rcx      # 0x11070
movw (%rcx,%rdx), %cx
movw %cx, (%rax)
movq 0x10(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x10(%rsp)
jmp 0xc90e
movl $0x0, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x30, %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb %cl, (%rax)
cmpl $0x0, (%rsp)
jne 0xc943
movl 0x8(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x30, %esi
movl $0x8, %edx
callq 0x10f0
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0xc967
movq 0x10(%rsp), %rdi
movl (%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0xcaa0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xc969
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x2710, 0x24(%rsp)     # imm = 0x2710
jae 0xc9d2
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xea40
movl %eax, 0x34(%rsp)
jmp 0xca8b
movl 0x24(%rsp), %eax
imulq $0x68db8bb, %rax, %rax  # imm = 0x68DB8BB
shrq $0x28, %rax
movl %eax, 0xc(%rsp)
movl 0x24(%rsp), %eax
imull $0x2710, 0xc(%rsp), %ecx # imm = 0x2710
subl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xea40
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0xca53
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
movl $0x30, %esi
movl $0x4, %edx
callq 0x10f0
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
jmp 0xca78
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xec00
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xca7a
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x2710, 0x1c(%rsp)     # imm = 0x2710
jae 0xcaf3
movq 0x8(%rsp), %rdi
movl $0x30, %esi
movl $0x4, %edx
callq 0x10f0
movq 0x8(%rsp), %rdi
addq $0x4, %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xec00
jmp 0xcb6e
movl 0x1c(%rsp), %eax
imulq $0x68db8bb, %rax, %rax  # imm = 0x68DB8BB
shrq $0x28, %rax
movl %eax, 0x4(%rsp)
movl 0x1c(%rsp), %eax
imull $0x2710, 0x4(%rsp), %ecx # imm = 0x2710
subl %ecx, %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xec00
cmpl $0x0, (%rsp)
jne 0xcb56
movq 0x8(%rsp), %rdi
addq $0x4, %rdi
movl $0x30, %esi
movl $0x4, %edx
callq 0x10f0
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
jmp 0xcb6c
movq 0x8(%rsp), %rdi
addq $0x4, %rdi
movl (%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xec00
jmp 0xcb6e
movl $0x8, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xcbca
movq 0x18(%rsp), %rax
movw 0x44a5(%rip), %cx       # 0x11062
movw %cx, (%rax)
movl $0x1, 0x34(%rsp)
jmp 0xcc3d
cmpq $0x0, 0x28(%rsp)
jge 0xcbf4
xorl %eax, %eax
subq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb $0x2d, (%rax)
jmp 0xcbfe
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0xcc50
movl %eax, %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $0x2386f26fc10000, %rax # imm = 0x2386F26FC10000
cmpq %rax, 0x20(%rsp)
jae 0xcc9b
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xd450
movl %eax, 0x34(%rsp)
jmp 0xcd65
movq 0x20(%rsp), %rax
movabsq $0x2386f26fc10000, %rcx # imm = 0x2386F26FC10000
xorl %edx, %edx
divq %rcx
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
movabsq $0x2386f26fc10000, %rdx # imm = 0x2386F26FC10000
imulq %rdx, %rcx
subq %rcx, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xea40
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rsp)
jne 0xcd2d
movq 0x10(%rsp), %rdi
movl $0x30, %esi
movl $0x10, %edx
callq 0x10f0
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x10, %ecx
movl %ecx, (%rax)
jmp 0xcd52
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xecc0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xcd54
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, (%rsp)
movb $0x30, (%rax)
movq (%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, (%rsp)
movb $0x78, (%rax)
movq (%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xcde0
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x0, (%rax)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rcx, %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
shrl $0x10, %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, (%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xce29
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xedb0
movl %eax, 0x24(%rsp)
jmp 0xce79
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0xedb0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
callq 0xee60
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
shrq $0x20, %rax
movl %eax, 0xc(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq 0x20(%rsp), %rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb $0x30, (%rax)
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb $0x78, (%rax)
cmpl $0x0, 0xc(%rsp)
jne 0xcf19
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0xcde0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xcf59
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xcde0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0xcf80
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/jnum.c
// Function: fill_t_8_hexs
static inline int fill_t_8_hexs(char *buffer, uint32_t num)
{
    char *s = buffer;

    fill_t_4_hexs(s, num >> 16);
    fill_t_4_hexs(s + 4, num & 0xffff);
    return 8;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
shrl $0x10, %esi
callq 0xee60
movq (%rsp), %rdi
addq $0x4, %rdi
movl 0xc(%rsp), %esi
andl $0xffff, %esi           # imm = 0xFFFF
callq 0xee60
movl $0x8, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x5f5e100, 0x20(%rsp)  # imm = 0x5F5E100
jae 0xd497
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
movq 0x18(%rsp), %rdx
callq 0xc990
movl %eax, 0x34(%rsp)
jmp 0xd555
movq 0x20(%rsp), %rax
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
xorl %edx, %edx
divq %rcx
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
imulq $0x5f5e100, %rcx, %rcx  # imm = 0x5F5E100
subq %rcx, %rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xc990
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0xd51d
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x8, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
movl $0x30, %esi
movl $0x8, %edx
callq 0x10f0
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0xd542
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xcaa0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xd544
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/jnum.c
// Function: jnum_parse_hex
static int jnum_parse_hex(const char *str, jnum_type_t *type, jnum_value_t *value)
{
    const char *s = str;
    char c;
    uint64_t m = 0;

    s += 2;
    while ((s - str) < 18) {
        switch ((c = *s)) {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            c -= '0';
            break;
        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
            c -= 'a' - 10;
            break;
        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            c -= 'A' - 10;
            break;
        default:
            goto end;
        }
        m = (m << 4) + c;
        ++s;
    }

end:
    if (m > 4294967295U /*UINT_MAX*/) {
        *type = JNUM_LHEX;
        value->vlhex = m;
    } else {
        *type = JNUM_HEX;
        value->vhex = (uint32_t)m;
    }

    return (int)(s - str);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
subq %rcx, %rax
cmpq $0x12, %rax
jge 0xe675
movq -0x20(%rsp), %rax
movsbl (%rax), %eax
movl %eax, -0x34(%rsp)
movb %al, %cl
movb %cl, -0x21(%rsp)
addl $-0x30, %eax
subl $0xa, %eax
jb 0xe61f
jmp 0xe603
movl -0x34(%rsp), %eax
addl $-0x41, %eax
subl $0x6, %eax
jb 0xe63b
jmp 0xe611
movl -0x34(%rsp), %eax
addl $-0x61, %eax
subl $0x6, %eax
jb 0xe62d
jmp 0xe649
movsbl -0x21(%rsp), %eax
subl $0x30, %eax
movb %al, -0x21(%rsp)
jmp 0xe64b
movsbl -0x21(%rsp), %eax
subl $0x57, %eax
movb %al, -0x21(%rsp)
jmp 0xe64b
movsbl -0x21(%rsp), %eax
subl $0x37, %eax
movb %al, -0x21(%rsp)
jmp 0xe64b
jmp 0xe677
movq -0x30(%rsp), %rax
shlq $0x4, %rax
movsbq -0x21(%rsp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xe5d0
jmp 0xe677
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x30(%rsp)
jbe 0xe69d
movq -0x10(%rsp), %rax
movl $0x5, (%rax)
movq -0x30(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0xe6b6
movq -0x10(%rsp), %rax
movl $0x3, (%rax)
movq -0x30(%rsp), %rax
movl %eax, %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
subq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
imull $0x147b, -0xc(%rsp), %eax # imm = 0x147B
shrl $0x13, %eax
movl %eax, -0x24(%rsp)
movl -0xc(%rsp), %eax
imull $0x64, -0x24(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x2424(%rip), %rcx      # 0x11070
movw (%rcx,%rdx), %cx
movw %cx, (%rax)
movq -0x20(%rsp), %rax
movl -0x28(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x2407(%rip), %rcx      # 0x11070
movw (%rcx,%rdx), %cx
movw %cx, 0x2(%rax)
cmpl $0x0, -0x28(%rsp)
jne 0xec95
movl -0x24(%rsp), %eax
movl %eax, %ecx
leaq 0x24bb(%rip), %rax      # 0x11140
movzbl (%rax,%rcx), %ecx
addl $0x2, %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0xecad
movl -0x28(%rsp), %eax
movl %eax, %ecx
leaq 0x249e(%rip), %rax      # 0x11140
movzbl (%rax,%rcx), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x4, %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/jnum.c
// Function: fill_t_16_digits
static inline int32_t fill_t_16_digits(char *buffer, uint64_t digits, int32_t *ptz)
{
    char *s = buffer;

    if (digits < 100000000llu) {
        memset(s, '0', 8);
        fill_t_8_digits(s + 8, (uint32_t)digits, ptz);
    } else {
        uint32_t q = (uint32_t)(digits / 100000000);
        uint32_t r = (uint32_t)(digits - (uint64_t)q * 100000000);

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

    return 16;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x5f5e100, 0x18(%rsp)  # imm = 0x5F5E100
jae 0xed1b
movq 0x8(%rsp), %rdi
movl $0x30, %esi
movl $0x8, %edx
callq 0x10f0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rax
movl %eax, %esi
movq 0x10(%rsp), %rdx
callq 0xcaa0
jmp 0xed9b
movq 0x18(%rsp), %rax
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
xorl %edx, %edx
divq %rcx
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
imulq $0x5f5e100, %rcx, %rcx  # imm = 0x5F5E100
subq %rcx, %rax
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xcaa0
cmpl $0x0, (%rsp)
jne 0xed83
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl $0x30, %esi
movl $0x8, %edx
callq 0x10f0
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x8, %ecx
movl %ecx, (%rax)
jmp 0xed99
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl (%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xcaa0
jmp 0xed9b
movl $0x10, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
shrl $0x8, %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %eax
andl $0xff, %eax
movl %eax, (%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xedf9
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xeeb0
movl %eax, 0x24(%rsp)
jmp 0xee49
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0xeeb0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
callq 0xef40
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
shrl $0x8, %esi
callq 0xef40
movq (%rsp), %rdi
addq $0x2, %rdi
movl 0xc(%rsp), %esi
andl $0xff, %esi
callq 0xef40
movl $0x4, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %eax
shrl $0x4, %eax
movl %eax, -0x1c(%rsp)
movl -0xc(%rsp), %eax
andl $0xf, %eax
movl %eax, -0x20(%rsp)
cmpl $0x0, -0x1c(%rsp)
je 0xef03
movl -0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x22c3(%rip), %rax      # 0x111b0
movb (%rax,%rcx), %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movl -0x20(%rsp), %eax
movl %eax, %ecx
leaq 0x22a0(%rip), %rax      # 0x111b0
movb (%rax,%rcx), %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
subq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/jnum.c
// Function: fill_t_2_hexs
static inline int fill_t_2_hexs(char *buffer, uint32_t num)
{
    char *s = buffer;
    *s++ = hex_char_lut[num >> 4];
    *s++ = hex_char_lut[num & 0xf];
    return 2;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %eax
shrl $0x4, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x224b(%rip), %rax      # 0x111b0
movb (%rax,%rcx), %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movl -0xc(%rsp), %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2223(%rip), %rax      # 0x111b0
movb (%rax,%rcx), %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movl $0x2, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/jnum.c
// Function: fill_significand
static inline int32_t fill_significand(char *buffer, uint64_t digits, int32_t *ptz)
{
    char *s = buffer;

    uint32_t q = (uint32_t)(digits / 100000000);
    uint32_t r = (uint32_t)(digits - (uint64_t)q * 100000000);

    uint32_t q1 = FAST_DIV10000(q);
    uint32_t r1 = q - q1 * 10000;

    uint32_t q2 = FAST_DIV100(q1);
    uint32_t r2 = q1 - q2 * 100;

    memcpy(s, &ch_100_lut[q2<<1], 2);
    memcpy(s + 2, &ch_100_lut[r2<<1], 2);
    if (!r2) {
        *ptz = tz_100_lut[q2] + 2;
    } else {
        *ptz = tz_100_lut[r2];
    }

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

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

    return 16;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
xorl %edx, %edx
divq %rcx
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movl 0x14(%rsp), %ecx
imulq $0x5f5e100, %rcx, %rcx  # imm = 0x5F5E100
subq %rcx, %rax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
imulq $0x68db8bb, %rax, %rax  # imm = 0x68DB8BB
shrq $0x28, %rax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
imull $0x2710, 0xc(%rsp), %ecx # imm = 0x2710
subl %ecx, %eax
movl %eax, 0x8(%rsp)
imull $0x147b, 0xc(%rsp), %eax # imm = 0x147B
shrl $0x13, %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
imull $0x64, 0x4(%rsp), %ecx
subl %ecx, %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x1fe1(%rip), %rcx      # 0x11070
movw (%rcx,%rdx), %cx
movw %cx, (%rax)
movq 0x18(%rsp), %rax
movl (%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x1fc5(%rip), %rcx      # 0x11070
movw (%rcx,%rdx), %cx
movw %cx, 0x2(%rax)
cmpl $0x0, (%rsp)
jne 0xf0d6
movl 0x4(%rsp), %eax
movl %eax, %ecx
leaq 0x207a(%rip), %rax      # 0x11140
movzbl (%rax,%rcx), %ecx
addl $0x2, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0xf0ed
movl (%rsp), %eax
movl %eax, %ecx
leaq 0x205e(%rip), %rax      # 0x11140
movzbl (%rax,%rcx), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
cmpl $0x0, 0x8(%rsp)
jne 0xf11a
movq 0x18(%rsp), %rdi
addq $0x4, %rdi
movl $0x30, %esi
movl $0x4, %edx
callq 0x10f0
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
jmp 0xf131
movq 0x18(%rsp), %rdi
addq $0x4, %rdi
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0xec00
cmpl $0x0, 0x10(%rsp)
jne 0xf15e
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movl $0x30, %esi
movl $0x8, %edx
callq 0x10f0
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x8, %ecx
movl %ecx, (%rax)
jmp 0xf175
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movl 0x10(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0xcaa0
movl $0x10, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/jnum.c
// Function: fill_exponent
static inline int32_t fill_exponent(int32_t K, char *buffer)
{
    int32_t i = 0, k = 0;

    if (K < 0) {
        buffer[i++] = '-';
        K = -K;
    } else {
        buffer[i++] = '+';
    }

    if (K < 100) {
        if (K < 10) {
            buffer[i++] = '0' + K;
        } else {
            memcpy(&buffer[i], &ch_100_lut[K<<1], 2);
            i += 2;
        }
    } else {
        k = FAST_DIV100(K);
        K -= k * 100;
        buffer[i++] = '0' + k;
        memcpy(&buffer[i], &ch_100_lut[K<<1], 2);
        i += 2;
    }

    return i;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
cmpl $0x0, -0x4(%rsp)
jge 0xf1c5
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rsp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
xorl %eax, %eax
subl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xf1de
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rsp)
movslq %ecx, %rcx
movb $0x2b, (%rax,%rcx)
cmpl $0x64, -0x4(%rsp)
jge 0xf23e
cmpl $0xa, -0x4(%rsp)
jge 0xf20f
movl -0x4(%rsp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xf23c
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl -0x4(%rsp), %edx
shll %edx
movslq %edx, %rsi
leaq 0x1e47(%rip), %rdx      # 0x11070
movw (%rdx,%rsi), %dx
movw %dx, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rsp)
jmp 0xf2aa
imull $0x147b, -0x4(%rsp), %eax # imm = 0x147B
sarl $0x13, %eax
movl %eax, -0x18(%rsp)
imull $0x64, -0x18(%rsp), %ecx
movl -0x4(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x18(%rsp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl -0x4(%rsp), %edx
shll %edx
movslq %edx, %rsi
leaq 0x1dd9(%rip), %rdx      # 0x11070
movw (%rdx,%rsi), %dx
movw %dx, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: doparams
static int
doparams(struct wire_requestqueue * Q)
{

	/* Send the request. */
	op_done = 0;
	if (proto_kvlds_request_params(Q, callback_params, NULL)) {
		warnp("Error sending PARAMS request");
		goto err0;
	}

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

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, 0x13e12(%rip)     # 0x16628
movq -0x10(%rbp), %rdi
leaq 0x89f(%rip), %rsi       # 0x30c0
xorl %eax, %eax
movl %eax, %edx
callq 0x65c0
cmpl $0x0, %eax
je 0x2868
jmp 0x2831
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2856
leaq 0xd96f(%rip), %rdi      # 0x101b1
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2864
leaq 0xd954(%rip), %rdi      # 0x101b1
movb $0x0, %al
callq 0x6120
jmp 0x2866
jmp 0x28c4
leaq 0x13db9(%rip), %rdi     # 0x16628
callq 0x3f10
cmpl $0x0, %eax
jne 0x2882
cmpl $0x0, 0x13dac(%rip)     # 0x1662c
je 0x28bb
jmp 0x2884
callq 0x20a0
cmpl $0x0, (%rax)
je 0x28a9
leaq 0xd939(%rip), %rdi      # 0x101ce
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x28b7
leaq 0xd91e(%rip), %rdi      # 0x101ce
movb $0x0, %al
callq 0x6120
jmp 0x28b9
jmp 0x28c4
movl $0x0, -0x4(%rbp)
jmp 0x28cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, 0x1350a(%rip)     # 0x16628
movq $0x1, 0x13507(%rip) # 0x16630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x814(%rip), %rcx       # 0x3950
xorl %eax, %eax
movl %eax, %r8d
callq 0x67b0
cmpl $0x0, %eax
je 0x3184
jmp 0x314d
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3172
leaq 0xd086(%rip), %rdi      # 0x101e4
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3180
leaq 0xd06b(%rip), %rdi      # 0x101e4
movb $0x0, %al
callq 0x6120
jmp 0x3182
jmp 0x31e0
leaq 0x1349d(%rip), %rdi     # 0x16628
callq 0x3f10
cmpl $0x0, %eax
jne 0x319e
cmpl $0x0, 0x13490(%rip)     # 0x1662c
je 0x31d7
jmp 0x31a0
callq 0x20a0
cmpl $0x0, (%rax)
je 0x31c5
leaq 0xd04d(%rip), %rdi      # 0x101fe
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x31d3
leaq 0xd032(%rip), %rdi      # 0x101fe
movb $0x0, %al
callq 0x6120
jmp 0x31d5
jmp 0x31e0
movl $0x0, -0x4(%rbp)
jmp 0x31e7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, 0x1341a(%rip)     # 0x16628
movq $0x1, 0x13417(%rip) # 0x16630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x774(%rip), %rdx       # 0x39a0
callq 0x7320
cmpl $0x0, %eax
je 0x3272
jmp 0x3238
callq 0x20a0
cmpl $0x0, (%rax)
je 0x325d
leaq 0xcfc8(%rip), %rdi      # 0x10211
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x326b
leaq 0xcfad(%rip), %rdi      # 0x10211
movb $0x0, %al
callq 0x6120
jmp 0x326d
jmp 0x32f4
leaq 0x133af(%rip), %rdi     # 0x16628
callq 0x3f10
cmpl $0x0, %eax
jne 0x328c
cmpl $0x0, 0x133a2(%rip)     # 0x1662c
je 0x32c5
jmp 0x328e
callq 0x20a0
cmpl $0x0, (%rax)
je 0x32b3
leaq 0xcf8c(%rip), %rdi      # 0x1022b
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x32c1
leaq 0xcf71(%rip), %rdi      # 0x1022b
movb $0x0, %al
callq 0x6120
jmp 0x32c3
jmp 0x32f4
cmpl $0x0, 0x1336c(%rip)     # 0x16638
je 0x32eb
jmp 0x32d0
leaq 0xcf67(%rip), %rdi      # 0x1023e
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x32f4
movl $0x0, -0x4(%rbp)
jmp 0x32fb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, 0x132f7(%rip)     # 0x16628
movq $0x1, 0x132f4(%rip) # 0x16630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x761(%rip), %rcx       # 0x3ab0
xorl %eax, %eax
movl %eax, %r8d
callq 0x6d70
cmpl $0x0, %eax
je 0x339a
jmp 0x3360
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3385
leaq 0xcee8(%rip), %rdi      # 0x10259
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3393
leaq 0xcecd(%rip), %rdi      # 0x10259
movb $0x0, %al
callq 0x6120
jmp 0x3395
jmp 0x344e
leaq 0x13287(%rip), %rdi     # 0x16628
callq 0x3f10
cmpl $0x0, %eax
jne 0x33b4
cmpl $0x0, 0x1327a(%rip)     # 0x1662c
je 0x33ed
jmp 0x33b6
callq 0x20a0
cmpl $0x0, (%rax)
je 0x33db
leaq 0xceac(%rip), %rdi      # 0x10273
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x33e9
leaq 0xce91(%rip), %rdi      # 0x10273
movb $0x0, %al
callq 0x6120
jmp 0x33eb
jmp 0x344e
cmpl $0x0, -0x24(%rbp)
je 0x3419
cmpl $0x0, 0x13242(%rip)     # 0x1663c
je 0x3419
jmp 0x33fe
leaq 0xce81(%rip), %rdi      # 0x10286
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x344e
cmpl $0x0, -0x24(%rbp)
jne 0x3445
cmpl $0x0, 0x13216(%rip)     # 0x1663c
jne 0x3445
jmp 0x342a
leaq 0xce72(%rip), %rdi      # 0x102a3
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x344e
movl $0x0, -0x4(%rbp)
jmp 0x3455
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, 0x131ae(%rip)     # 0x16628
movq $0x1, 0x131ab(%rip) # 0x16630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x4bc(%rip), %rdx       # 0x3950
xorl %eax, %eax
movl %eax, %ecx
callq 0x7090
cmpl $0x0, %eax
je 0x34db
jmp 0x34a4
callq 0x20a0
cmpl $0x0, (%rax)
je 0x34c9
leaq 0xce0f(%rip), %rdi      # 0x102c4
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x34d7
leaq 0xcdf4(%rip), %rdi      # 0x102c4
movb $0x0, %al
callq 0x6120
jmp 0x34d9
jmp 0x3537
leaq 0x13146(%rip), %rdi     # 0x16628
callq 0x3f10
cmpl $0x0, %eax
jne 0x34f5
cmpl $0x0, 0x13139(%rip)     # 0x1662c
je 0x352e
jmp 0x34f7
callq 0x20a0
cmpl $0x0, (%rax)
je 0x351c
leaq 0xcf33(%rip), %rdi      # 0x1043b
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x352a
leaq 0xcf18(%rip), %rdi      # 0x1043b
movb $0x0, %al
callq 0x6120
jmp 0x352c
jmp 0x3537
movl $0x0, -0x4(%rbp)
jmp 0x353e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, 0x130b7(%rip)     # 0x16628
movq $0x1, 0x130b4(%rip) # 0x16630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x521(%rip), %rcx       # 0x3ab0
xorl %eax, %eax
movl %eax, %r8d
callq 0x6f00
cmpl $0x0, %eax
je 0x35da
jmp 0x35a0
callq 0x20a0
cmpl $0x0, (%rax)
je 0x35c5
leaq 0xcd30(%rip), %rdi      # 0x102e1
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x35d3
leaq 0xcd15(%rip), %rdi      # 0x102e1
movb $0x0, %al
callq 0x6120
jmp 0x35d5
jmp 0x368e
leaq 0x13047(%rip), %rdi     # 0x16628
callq 0x3f10
cmpl $0x0, %eax
jne 0x35f4
cmpl $0x0, 0x1303a(%rip)     # 0x1662c
je 0x362d
jmp 0x35f6
callq 0x20a0
cmpl $0x0, (%rax)
je 0x361b
leaq 0xccf7(%rip), %rdi      # 0x102fe
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3629
leaq 0xccdc(%rip), %rdi      # 0x102fe
movb $0x0, %al
callq 0x6120
jmp 0x362b
jmp 0x368e
cmpl $0x0, -0x24(%rbp)
je 0x3659
cmpl $0x0, 0x13002(%rip)     # 0x1663c
je 0x3659
jmp 0x363e
leaq 0xcccf(%rip), %rdi      # 0x10314
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x368e
cmpl $0x0, -0x24(%rbp)
jne 0x3685
cmpl $0x0, 0x12fd6(%rip)     # 0x1663c
jne 0x3685
jmp 0x366a
leaq 0xccc3(%rip), %rdi      # 0x10334
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x368e
movl $0x0, -0x4(%rbp)
jmp 0x3695
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop