LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/utf16.c
// Function: write_utf16
static int write_utf16(charset_spec const *charset, long int input_chr,
		       charset_state *state,
		       void (*emit)(void *ctx, long int output),
		       void *emitctx)
{
    struct utf16 const *utf = (struct utf16 *)charset->data;

    /*
     * state->s0 == 0 means we have not output anything yet (and so
     * must output a BOM before we do anything else). state->s0 ==
     * 1 means we are off and running.
     */

    if (input_chr < 0)
	return TRUE;		       /* no cleanup required */

    if ((input_chr >= 0xD800 && input_chr < 0xE000) ||
	input_chr >= 0x110000) {
	/*
	 * We can't output surrogates, or anything above 0x10FFFF.
	 */
	return FALSE;
    }

    if (!state->s0) {
	state->s0 = 1;
	emithl(emit, emitctx, utf->s0, 0xFEFF);
    }

    if (input_chr < 0x10000) {
	emithl(emit, emitctx, utf->s0, input_chr);
    } else {
	input_chr -= 0x10000;
	/* now input_chr is between 0 and 0xFFFFF inclusive */
	emithl(emit, emitctx, utf->s0, 0xD800 | ((input_chr >> 10) & 0x3FF));
	emithl(emit, emitctx, utf->s0, 0xDC00 | (input_chr & 0x3FF));
    }
    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0xb9bb
movl $0x1, -0x4(%rbp)
jmp 0xba9c
cmpq $0xd800, -0x18(%rbp)    # imm = 0xD800
jl 0xb9cf
cmpq $0xe000, -0x18(%rbp)    # imm = 0xE000
jl 0xb9d9
cmpq $0x110000, -0x18(%rbp)  # imm = 0x110000
jl 0xb9e5
movl $0x0, -0x4(%rbp)
jmp 0xba9c
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xba13
movq -0x20(%rbp), %rax
movq $0x1, (%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
movslq (%rax), %rdx
movl $0xfeff, %ecx           # imm = 0xFEFF
callq 0xbab0
cmpq $0x10000, -0x18(%rbp)   # imm = 0x10000
jge 0xba37
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
movslq (%rax), %rdx
movq -0x18(%rbp), %rcx
callq 0xbab0
jmp 0xba95
movq -0x18(%rbp), %rax
subq $0x10000, %rax          # imm = 0x10000
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
movslq (%rax), %rdx
movq -0x18(%rbp), %rcx
sarq $0xa, %rcx
andq $0x3ff, %rcx            # imm = 0x3FF
orq $0xd800, %rcx           # imm = 0xD800
callq 0xbab0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
movslq (%rax), %rdx
movq -0x18(%rbp), %rcx
andq $0x3ff, %rcx            # imm = 0x3FF
orq $0xdc00, %rcx           # imm = 0xDC00
callq 0xbab0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/utf16.c
// Function: emithl
static void emithl(void (*emit)(void *ctx, long int output), void *emitctx,
		   unsigned long s0, long int hw)
{
    int h = (hw >> 8) & 0xFF, l = hw & 0xFF;

    if (s0 & 0x20000) {
	/* Big-endian takes priority over little, if both are allowed. */
	emit(emitctx, h);
	emit(emitctx, l);
    } else {
	emit(emitctx, l);
	emit(emitctx, h);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
sarq $0x8, %rax
andq $0xff, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
andq $0xff, %rax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
andq $0x20000, %rax          # imm = 0x20000
cmpq $0x0, %rax
je 0xbb14
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq *%rax
jmp 0xbb30
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/xenc.c
// Function: charset_to_xenc
const char *charset_to_xenc(int charset)
{
    int i;

    for (i = 0; i < (int)lenof(xencs); i++)
	if (charset == xencs[i].charset)
	    return xencs[i].name;

    return NULL;		       /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x24, -0x10(%rbp)
jge 0xc896
movl -0xc(%rbp), %eax
movslq -0x10(%rbp), %rdx
leaq 0x9ee7e(%rip), %rcx     # 0xab6e0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jne 0xc889
movslq -0x10(%rbp), %rcx
leaq 0x9ee67(%rip), %rax     # 0xab6e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc89e
jmp 0xc88b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc84e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/xenc.c
// Function: charset_from_xenc
int charset_from_xenc(const char *name)
{
    int i;

    for (i = 0; i < (int)lenof(xencs); i++) {
	const char *p, *q;
	p = name;
	q = xencs[i].name;
	while (*p || *q) {
		if (tolower((unsigned char)*p) != tolower((unsigned char)*q))
		break;
	    p++; q++;
	}
	if (!*p && !*q)
	    return xencs[i].charset;
    }

    return CS_NONE;		       /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x24, -0x14(%rbp)
jge 0xc994
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x9ee00(%rip), %rax     # 0xab6e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0xc90f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xc918
jmp 0xc958
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x6080
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %edi
callq 0x6080
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
je 0xc93e
jmp 0xc958
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xc8ee
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xc984
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xc984
movslq -0x14(%rbp), %rcx
leaq 0x9ed6b(%rip), %rax     # 0xab6e0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xc99b
jmp 0xc986
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc8c3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/emacsenc.c
// Function: charset_to_emacsenc
const char *charset_to_emacsenc(int charset)
{
    int i;

    for (i = 0; i < (int)lenof(emacsencs); i++)
	if (charset == emacsencs[i].charset)
	    return emacsencs[i].name;

    return NULL;		       /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4d, -0x10(%rbp)
jge 0xca06
movl -0xc(%rbp), %eax
movslq -0x10(%rbp), %rdx
leaq 0x9ef4e(%rip), %rcx     # 0xab920
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jne 0xc9f9
movslq -0x10(%rbp), %rcx
leaq 0x9ef37(%rip), %rax     # 0xab920
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xca0e
jmp 0xc9fb
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc9be
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/emacsenc.c
// Function: charset_from_emacsenc
int charset_from_emacsenc(const char *name)
{
    int i;

    for (i = 0; i < (int)lenof(emacsencs); i++) {
	const char *p, *q;
	p = name;
	q = emacsencs[i].name;
	while (*p || *q) {
		if (tolower((unsigned char)*p) != tolower((unsigned char)*q))
		break;
	    p++; q++;
	}
	if (!*p && !*q)
	    return emacsencs[i].charset;
    }

    return CS_NONE;		       /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4d, -0x14(%rbp)
jge 0xcb04
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x9eed0(%rip), %rax     # 0xab920
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0xca7f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xca88
jmp 0xcac8
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x6080
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %edi
callq 0x6080
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
je 0xcaae
jmp 0xcac8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xca5e
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xcaf4
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xcaf4
movslq -0x14(%rbp), %rcx
leaq 0x9ee3b(%rip), %rax     # 0xab920
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xcb0b
jmp 0xcaf6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xca33
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json_test.c
// Function: copy_data_to_file
int copy_data_to_file(char *data, size_t size, const char *dst)
{
    int ret = -1;
    FILE *wfp = NULL;

    if (!data || !dst)
        return -1;
    if ((wfp = fopen(dst, "wb+")) == NULL)
        return -1;
    if (size == fwrite(data, 1, size, wfp))
        ret = 0;
    _fclose_fp(wfp);
    if (ret < 0 && access(dst, F_OK) == 0)
        unlink(dst);

    return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1324
cmpq $0x0, 0x18(%rsp)
jne 0x1331
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x13d4
movq 0x18(%rsp), %rdi
leaq 0xed07(%rip), %rsi      # 0x10044
callq 0x11c0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x1357
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x13d4
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x11e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jne 0x138d
movl $0x0, 0x14(%rsp)
jmp 0x138f
cmpq $0x0, 0x8(%rsp)
je 0x13a1
movq 0x8(%rsp), %rdi
callq 0x10a0
movq $0x0, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x13cc
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x11b0
cmpl $0x0, %eax
jne 0x13cc
movq 0x18(%rsp), %rdi
callq 0x1040
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json_test.c
// Function: read_file_to_data
int read_file_to_data(const char *src, char **data, size_t *size)
{
    FILE *rfp = NULL;
    size_t total = 0;

    if (!src || !data)
        return -1;

    if (!size)
        size = &total;
    *data = NULL, *size = 0;

    if ((rfp = fopen(src, "rb")) == NULL)
        return -1;
    fseek(rfp, 0, SEEK_END);
    *size = ftell(rfp);
    fseek(rfp, 0, SEEK_SET);
    if (*size == 0)
        goto err;

    if ((*data = (char *)_fmalloc(*size + 1)) == NULL)
        goto err;
    if (*size != fread(*data, 1, *size, rfp))
        goto err;

    (*data)[*size] = 0;
    _fclose_fp(rfp);
    return 0;
err:
    _fclose_fp(rfp);
    _free_ptr(*data);
    *size = 0;
    return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1415
cmpq $0x0, 0x20(%rsp)
jne 0x1422
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x15a7
cmpq $0x0, 0x18(%rsp)
jne 0x1434
leaq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x28(%rsp), %rdi
leaq 0xebf0(%rip), %rsi      # 0x10048
callq 0x11c0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x1475
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x15a7
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1170
movq 0x10(%rsp), %rdi
callq 0x1140
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1170
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x14bd
jmp 0x1550
movq 0x18(%rsp), %rax
movq (%rax), %rdi
addq $0x1, %rdi
callq 0x1160
movq 0x20(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x14de
jmp 0x1550
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x1070
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
je 0x1517
jmp 0x1550
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, 0x10(%rsp)
je 0x153d
movq 0x10(%rsp), %rdi
callq 0x10a0
movq $0x0, 0x10(%rsp)
movl $0x0, 0x34(%rsp)
jmp 0x15a7
jmp 0x1552
cmpq $0x0, 0x10(%rsp)
je 0x1564
movq 0x10(%rsp), %rdi
callq 0x10a0
movq $0x0, 0x10(%rsp)
jmp 0x156f
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1587
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json_test.c
// Function: read_file_data_free
int read_file_data_free(char **data, size_t *size)
{
    if (data)
        _free_ptr(*data);
    if (size)
        *size = 0;
    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x15ee
jmp 0x15c8
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x15e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
jmp 0x15ee
cmpq $0x0, 0x8(%rsp)
je 0x1602
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_sax_print_format_start
static inline json_sax_print_hd json_sax_print_format_start(int item_total, json_print_ptr_t *ptr)
{
    json_print_choice_t choice;

    memset(&choice, 0, sizeof(choice));
    choice.format_flag = true;
    choice.item_total = item_total;
    choice.ptr = ptr;
    return json_sax_print_start(&choice);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10f0
movb $0x1, 0x24(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x5f90
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_sax_fprint_format_start
static inline json_sax_print_hd json_sax_fprint_format_start(int item_total, const char *path, json_print_ptr_t *ptr)
{
    json_print_choice_t choice;

    memset(&choice, 0, sizeof(choice));
    choice.format_flag = true;
    choice.item_total = item_total;
    choice.path = path;
    choice.ptr = ptr;
    return json_sax_print_start(&choice);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10f0
movb $0x1, 0x1c(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rsp, %rdi
callq 0x5f90
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_parse_str
static inline json_object *json_parse_str(char *str, size_t str_len)
{
    json_parse_choice_t choice;

    memset(&choice, 0, sizeof(choice));
    choice.str = str;
    choice.str_len = str_len;
    return json_parse_common(&choice);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10f0
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsp, %rdi
callq 0x6200
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_fast_parse_str
static inline json_object *json_fast_parse_str(char *str, size_t str_len, json_mem_t *mem)
{
    json_parse_choice_t choice;

    memset(&choice, 0, sizeof(choice));
    choice.str = str;
    choice.mem = mem;
    choice.str_len = str_len;
    return json_parse_common(&choice);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10f0
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x6200
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_fast_parse_file
static inline json_object *json_fast_parse_file(const char *path, json_mem_t *mem)
{
    json_parse_choice_t choice;

    memset(&choice, 0, sizeof(choice));
    choice.path = path;
    choice.mem = mem;
    return json_parse_common(&choice);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10f0
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rsp, %rdi
callq 0x6200
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_sax_parse_str
static inline int json_sax_parse_str(char *str, size_t str_len, json_sax_cb_t cb)
{
    json_sax_parse_choice_t choice;

    memset(&choice, 0, sizeof(choice));
    choice.str = str;
    choice.cb = cb;
    choice.str_len = str_len;
    return json_sax_parse_common(&choice);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10f0
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x9310
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_sax_parse_file
static inline int json_sax_parse_file(const char *path, json_sax_cb_t cb)
{
    json_sax_parse_choice_t choice;

    memset(&choice, 0, sizeof(choice));
    choice.path = path;
    choice.cb = cb;
    return json_sax_parse_common(&choice);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10f0
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rsp, %rdi
callq 0x9310
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_print_format
static inline char *json_print_format(json_object *json, int item_total, size_t *length, json_print_ptr_t *ptr)
{
    json_print_choice_t choice;
    char *str = NULL;

    memset(&choice, 0, sizeof(choice));
    choice.format_flag = true;
    choice.item_total = item_total;
    choice.ptr = ptr;
    str = json_print_common(json, &choice);
    if (length)
        *length = choice.str_len;
    return str;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq $0x0, (%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10f0
movb $0x1, 0x24(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3090
movq %rax, (%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x28bf
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_fprint_format
static inline char *json_fprint_format(json_object *json, int item_total, const char *path, json_print_ptr_t *ptr)
{
    json_print_choice_t choice;

    memset(&choice, 0, sizeof(choice));
    choice.format_flag = true;
    choice.item_total = item_total;
    choice.path = path;
    choice.ptr = ptr;
    return json_print_common(json, &choice);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10f0
movb $0x1, 0x24(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3090
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/./json.h
// Function: json_print_unformat
static inline char *json_print_unformat(json_object *json, int item_total, size_t *length, json_print_ptr_t *ptr)
{
    json_print_choice_t choice;
    char *str = NULL;

    memset(&choice, 0, sizeof(choice));
    choice.format_flag = false;
    choice.item_total = item_total;
    choice.ptr = ptr;
    str = json_print_common(json, &choice);
    if (length)
        *length = choice.str_len;
    return str;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq $0x0, (%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10f0
movb $0x0, 0x24(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3090
movq %rax, (%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x299f
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json_test.c
// Function: usage_print
static void usage_print(const char *func)
{
#define ANY_JSON_NAME "x.json"
    printf("Usage: %s <%s> <num>\n", func, ANY_JSON_NAME);
    printf("\t%s %s 1 ==> test json_parse_str()\n", func, ANY_JSON_NAME);
    printf("\t%s %s 2 ==> test json_fast_parse_str()\n", func, ANY_JSON_NAME);
    printf("\t%s %s 3 ==> test json_reuse_parse_str()\n", func, ANY_JSON_NAME);
    printf("\t%s %s 4 ==> test json_parse_file()\n", func, ANY_JSON_NAME);
    printf("\t%s %s 5 ==> test json_fast_parse_file()\n", func, ANY_JSON_NAME);
#if JSON_SAX_APIS_SUPPORT
    printf("\t%s %s 6 ==> test json_sax_parse_str()\n", func, ANY_JSON_NAME);
    printf("\t%s %s 7 ==> test json_sax_parse_file()\n", func, ANY_JSON_NAME);
    printf("Usage: %s 0 ==> test json_sax_print_xxxx()\n", func);
#endif
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rsi
leaq 0xd806(%rip), %rdi      # 0x10226
leaq 0xd815(%rip), %rdx      # 0x1023c
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rsi
leaq 0xd80a(%rip), %rdi      # 0x10243
leaq 0xd7fc(%rip), %rdx      # 0x1023c
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rsi
leaq 0xd815(%rip), %rdi      # 0x10267
leaq 0xd7e3(%rip), %rdx      # 0x1023c
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rsi
leaq 0xd825(%rip), %rdi      # 0x10290
leaq 0xd7ca(%rip), %rdx      # 0x1023c
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rsi
leaq 0xd836(%rip), %rdi      # 0x102ba
leaq 0xd7b1(%rip), %rdx      # 0x1023c
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rsi
leaq 0xd842(%rip), %rdi      # 0x102df
leaq 0xd798(%rip), %rdx      # 0x1023c
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rsi
leaq 0xd853(%rip), %rdi      # 0x10309
leaq 0xd77f(%rip), %rdx      # 0x1023c
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rsi
leaq 0xd862(%rip), %rdi      # 0x10331
leaq 0xd766(%rip), %rdx      # 0x1023c
movb $0x0, %al
callq 0x10c0
movq (%rsp), %rsi
leaq 0xd872(%rip), %rdi      # 0x1035a
movb $0x0, %al
callq 0x10c0
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_del_object
void json_del_object(json_object *json)
{
    json_object *p = NULL, *pos = NULL, *n = NULL;

    if (!json)
        return;

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

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

    json_free(json);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2b51
jmp 0x2c4a
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2b6b
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
movl %eax, 0x4(%rsp)
subl $0x7, %eax
je 0x2b92
jmp 0x2b81
movl 0x4(%rsp), %eax
addl $-0x8, %eax
subl $0x2, %eax
jb 0x2bb1
jmp 0x2c3e
movq 0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2bac
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
jmp 0x2c40
movq 0x20(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x2c3c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x18, %rdx
callq 0x2c50
movq 0x10(%rsp), %rdi
callq 0x2b20
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2bda
jmp 0x2c40
jmp 0x2c40
movq 0x20(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_list_del
static inline void json_list_del(struct json_list *list, struct json_list *prev, struct json_list_head *head)
{
    if (list->next == (struct json_list *)head) {
        head->prev = prev;
    }
    prev->next = list->next;
    list->next = NULL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x2c7c
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_string_info_update
void json_string_info_update(json_string_t *jstr)
{
    const char *str = jstr->str;
    int i = 0;
    int escaped = 0;

    if (jstr->len)
        return;

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

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

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
shrl $0x8, %eax
cmpl $0x0, %eax
je 0x2d47
jmp 0x2dec
cmpq $0x0, -0x10(%rsp)
je 0x2db6
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2db4
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rsp)
addl $-0x8, %eax
subl $0x6, %eax
jb 0x2d99
jmp 0x2d83
movl -0x1c(%rsp), %eax
subl $0x22, %eax
je 0x2d99
jmp 0x2d8e
movl -0x1c(%rsp), %eax
subl $0x5c, %eax
jne 0x2da3
jmp 0x2d99
movl $0x1, -0x18(%rsp)
jmp 0x2da5
jmp 0x2da5
jmp 0x2da7
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x2d57
jmp 0x2db6
movl -0x18(%rsp), %edx
movq -0x8(%rsp), %rax
movl (%rax), %ecx
andl $0x1, %edx
shll $0x4, %edx
andl $-0x11, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movl -0x14(%rsp), %edx
movq -0x8(%rsp), %rax
movl (%rax), %ecx
andl $0xffffff, %edx         # imm = 0xFFFFFF
shll $0x8, %edx
andl $0xff, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_mem_free
static void _json_mem_free(json_mem_mgr_t *mgr)
{
    json_mem_node_t *p = NULL, *pos = NULL, *n = NULL;
    json_list_for_each_entry_safe(p, pos, n, &mgr->head, list, json_mem_node_t) {
        json_list_del(&pos->list, &p->list, &mgr->head);
        json_free(pos->ptr);
        json_free(pos);
        pos = p;
    }
    mgr->cur_node = &s_invalid_json_mem_node;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq %rcx, %rax
je 0x2f30
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2c50
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2ec8
movq 0x20(%rsp), %rax
leaq 0x13404(%rip), %rcx     # 0x16340
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_memory_statistics
int pjson_memory_statistics(json_mem_mgr_t *mgr)
{
    json_mem_node_t *pos = NULL;
    int size = 0;

    json_list_for_each_entry(pos, &mgr->head, list, json_mem_node_t) {
        size += (int)(pos->size);
    }
    return size;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x2fa2
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x2f73
movl -0x14(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: pjson_memory_alloc
static inline void *pjson_memory_alloc(size_t size, json_mem_mgr_t *mgr)
{
    void *p = NULL;

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

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
addq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x3050
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x18(%rsp), %rax
jb 0x3017
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x3020
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa6d0
cmpq $0x0, %rax
jne 0x303f
movq $0x0, 0x20(%rsp)
jmp 0x3082
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_print_common
char *json_print_common(json_object *json, json_print_choice_t *choice)
{
    json_print_t print_val = {0};

    if (!json)
        return NULL;

    print_val.item_total = choice->item_total ? choice->item_total : JSON_PRINT_NUM_INIT_DEF;
    if (_print_val_init(&print_val, choice) < 0)
        return NULL;

    if (_json_print_value(&print_val, json) < 0) {
        JsonErr("print failed!\n");
        goto err;
    }
    if (_print_val_release(&print_val, false, &choice->str_len, choice->ptr) < 0)
        goto err;

    return choice->path ? (char *)"ok" : print_val.ptr;
err:
    _print_val_release(&print_val, true, NULL, NULL);
    return NULL;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x10f0
cmpq $0x0, 0x68(%rsp)
jne 0x30c5
movq $0x0, 0x70(%rsp)
jmp 0x31c3
movq 0x60(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x30de
movq 0x60(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x30e9
movl $0x400, %eax            # imm = 0x400
movl %eax, 0x14(%rsp)
jmp 0x30e9
movl 0x14(%rsp), %eax
movl %eax, 0x50(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x31d0
cmpl $0x0, %eax
jge 0x3113
movq $0x0, 0x70(%rsp)
jmp 0x31c3
movq 0x68(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3450
cmpl $0x0, %eax
jge 0x3153
jmp 0x3129
leaq 0xd8c4(%rip), %rdi      # 0x109f4
leaq 0xda53(%rip), %rsi      # 0x10b8a
movl $0x742, %edx            # imm = 0x742
movb $0x0, %al
callq 0x10c0
leaq 0xda52(%rip), %rdi      # 0x10b9c
movb $0x0, %al
callq 0x10c0
jmp 0x31a4
movq 0x60(%rsp), %rdx
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rcx
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x46e0
cmpl $0x0, %eax
jge 0x3174
jmp 0x31a4
movq 0x60(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x318e
leaq 0xda24(%rip), %rax      # 0x10bab
movq %rax, 0x8(%rsp)
jmp 0x3198
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x31c3
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x46e0
movq $0x0, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: print_addi_format
static inline int _print_addi_format(json_print_t *print_ptr, size_t depth)
{
    _PRINT_PTR_REALLOC((depth + 2));
    *print_ptr->cur++ = '\n';
    memset(print_ptr->cur, '\t', depth);
    print_ptr->cur += depth;

    return 0;
err:
    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rdx
movq 0x8(%rdx), %rdx
subq %rdx, %rax
subq %rax, %rcx
movq 0x10(%rsp), %rdx
addq $0x2, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0xf(%rsp)
jae 0x5b16
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x2, %rsi
callq *%rax
cmpl $0x0, %eax
setl %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5b2d
jmp 0x5b7a
jmp 0x5b2f
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movb $0xa, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
movl $0x9, %esi
callq 0x10f0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x24(%rsp)
jmp 0x5b82
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x1, %edi
movl $0x60, %esi
callq 0x1130
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x5ff4
jmp 0x5fbe
leaq 0xaa2f(%rip), %rdi      # 0x109f4
leaq 0xac48(%rip), %rsi      # 0x10c14
movl $0x816, %edx            # imm = 0x816
movb $0x0, %al
callq 0x10c0
leaq 0xaa27(%rip), %rdi      # 0x10a06
movb $0x0, %al
callq 0x10c0
movq $0x0, 0x20(%rsp)
jmp 0x60e0
movq 0x18(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x600d
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x6018
movl $0x400, %eax            # imm = 0x400
movl %eax, 0xc(%rsp)
jmp 0x6018
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x48(%rax)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq 0x18(%rsp), %rsi
callq 0x31d0
cmpl $0x0, %eax
jge 0x6054
movq 0x10(%rsp), %rdi
callq 0x1030
movq $0x0, 0x20(%rsp)
jmp 0x60e0
movq 0x10(%rsp), %rax
movl $0x10, (%rax)
movq 0x10(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x1160
movq 0x10(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x60d6
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x46e0
movq 0x10(%rsp), %rdi
callq 0x1030
leaq 0xa94a(%rip), %rdi      # 0x109f4
leaq 0xab63(%rip), %rsi      # 0x10c14
movl $0x823, %edx            # imm = 0x823
movb $0x0, %al
callq 0x10c0
leaq 0xa942(%rip), %rdi      # 0x10a06
movb $0x0, %al
callq 0x10c0
movq $0x0, 0x20(%rsp)
jmp 0x60e0
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x612c
movq $0x0, 0x30(%rsp)
jmp 0x61f6
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6146
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rax
testb $0x1, 0x5c(%rax)
je 0x6180
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x46e0
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x30(%rsp)
jmp 0x61f6
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x6198
leaq 0xaa19(%rip), %rax      # 0x10bab
movq %rax, (%rsp)
jmp 0x61a5
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
xorl %esi, %esi
callq 0x46e0
cmpl $0x0, %eax
jge 0x61e2
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x30(%rsp)
jmp 0x61f6
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movl $0x40, %edx
leaq 0x8(%rsp), %rcx
callq 0xabb0
cmpl $0x0, %eax
je 0x66bd
jmp 0x6669
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
addl $0xdf, %eax
andl $0xff, %eax
cmpl $0xdf, %eax
jle 0x669d
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6669
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x66bb
jmp 0x66bd
jmp 0x664a
movslq 0x4(%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: skip_blank_rapid
static inline void _skip_blank_rapid(json_parse_t *parse_ptr)
{
    unsigned char *str, *bak;

#if JSON_PARSE_SKIP_COMMENT
next:
#endif
    str = (unsigned char *)(parse_ptr->str + parse_ptr->offset);
    bak = str;
    while (IS_BLANK(*str))
        ++str;
    _UPDATE_PARSE_OFFSET(str - bak);

#if JSON_PARSE_SKIP_COMMENT
    if (unlikely(*str == '/')) {
        int cnt = 0;
        if (!_skip_comment_rapid(parse_ptr, &cnt)) {
            _UPDATE_PARSE_OFFSET(cnt);
            goto next;
        }
        _UPDATE_PARSE_OFFSET(cnt);
    }
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rsp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
addl $0xdf, %eax
andl $0xff, %eax
cmpl $0xdf, %eax
jle 0x72af
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x7286
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
subq %rax, %rcx
movq -0x8(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_mem_new
static void *_json_mem_new(size_t size, json_mem_mgr_t *mgr)
{
    json_mem_node_t *node = NULL;

    if ((node = (json_mem_node_t *)json_malloc(sizeof(json_mem_node_t))) == NULL) {
        JsonErr("malloc failed!\n");
        return NULL;
    }
    node->size = size;
    if ((node->ptr = (char *)json_malloc(node->size)) == NULL) {
        JsonErr("malloc failed! %d\n", (int)node->size);
        json_free(node);
        return NULL;
    }
    node->cur = node->ptr;
    json_list_add_head(&node->list, &mgr->head);

    return node;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x20, %edi
callq 0x1160
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xa734
jmp 0xa6fe
leaq 0x62ef(%rip), %rdi      # 0x109f4
leaq 0x6576(%rip), %rsi      # 0x10c82
movl $0x40f, %edx            # imm = 0x40F
movb $0x0, %al
callq 0x10c0
leaq 0x62e7(%rip), %rdi      # 0x10a06
movb $0x0, %al
callq 0x10c0
movq $0x0, 0x20(%rsp)
jmp 0xa7d4
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1160
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xa7a9
jmp 0xa761
leaq 0x628c(%rip), %rdi      # 0x109f4
leaq 0x6513(%rip), %rsi      # 0x10c82
movl $0x414, %edx            # imm = 0x414
movb $0x0, %al
callq 0x10c0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
leaq 0x6503(%rip), %rdi      # 0x10c90
movb $0x0, %al
callq 0x10c0
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x20(%rsp)
jmp 0xa7d4
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa7e0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lengjingzju[P]json/json.c
// Function: json_list_add_head
static inline void json_list_add_head(struct json_list *list, struct json_list_head *head)
{
    if (head->next == (struct json_list *)head) {
        head->prev = list;
    }
    list->next = head->next;
    head->next = list;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
cmpq -0x10(%rsp), %rax
jne 0xa807
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
nop