LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/curve25519-donna.c
// Function: fmul
static void
fmul(int64_t *output, const int64_t *in, const int64_t *in2)
{
  int64_t t[19];
  fproduct(t, in, in2);
  /* |t[i]| < 14*2^54 */
  freduce_degree(t);
  freduce_coefficients(t);
  /* |t[i]| < 2^26 */
  memcpy(output, t, sizeof(int64_t) * 10);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5eb7
movq %r14, %rdi
callq 0x64a6
movq %r14, %rdi
callq 0x658a
pushq $0xa
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/curve25519-donna.c
// Function: swap_conditional
static void
swap_conditional(int64_t a[19], int64_t b[19], int64_t iswap)
{
  unsigned i;
  const int32_t swap = (int32_t) -iswap;

  for (i = 0; i < 10; ++i) {
    const int32_t x = swap & ( ((int32_t)a[i]) ^ ((int32_t)b[i]) );
    a[i] = ((int32_t)a[i]) ^ x;
    b[i] = ((int32_t)b[i]) ^ x;
  }
}

// Assembly:
negl %edx
xorl %eax, %eax
cmpq $0xa, %rax
je 0x5e7b
movl (%rdi,%rax,8), %ecx
movl (%rsi,%rax,8), %r8d
xorl %ecx, %r8d
andl %edx, %r8d
xorl %r8d, %ecx
movslq %ecx, %rcx
movq %rcx, (%rdi,%rax,8)
xorl (%rsi,%rax,8), %r8d
movslq %r8d, %rcx
movq %rcx, (%rsi,%rax,8)
incq %rax
jmp 0x5e4e
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/curve25519-donna.c
// Function: fsum
static void
fsum(int64_t *output, const int64_t *in)
{
  unsigned i;
  for (i = 0; i < 10; i += 2) {
    output[0+i] = output[0+i] + in[0+i];
    output[1+i] = output[1+i] + in[1+i];
  }
}

// Assembly:
xorl %eax, %eax
cmpq $0x9, %rax
ja 0x5e9c
movq (%rsi,%rax,8), %rcx
addq %rcx, (%rdi,%rax,8)
movq 0x8(%rsi,%rax,8), %rcx
addq %rcx, 0x8(%rdi,%rax,8)
addq $0x2, %rax
jmp 0x5e7e
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/curve25519-donna.c
// Function: freduce_coefficients
static void
freduce_coefficients(int64_t *output)
{
  unsigned i;

  output[10] = 0;

  for (i = 0; i < 10; i += 2) {
    int64_t over = div_by_2_26(output[i]);
    /* The entry condition (that |output[i]| < 280*2^54) means that over is, at
     * most, 280*2^28 in the first iteration of this loop. This is added to the
     * next limb and we can approximate the resulting bound of that limb by
     * 281*2^54. */
    output[i] -= over << 26;
    output[i+1] += over;

    /* For the first iteration, |output[i+1]| < 281*2^54, thus |over| <
     * 281*2^29. When this is added to the next limb, the resulting bound can
     * be approximated as 281*2^54.
     *
     * For subsequent iterations of the loop, 281*2^54 remains a conservative
     * bound and no overflow occurs. */
    over = div_by_2_25(output[i+1]);
    output[i+1] -= over << 25;
    output[i+2] += over;
  }
  /* Now |output[10]| < 281*2^29 and all other coefficients are reduced. */
  output[0] += output[10] << 4;
  output[0] += output[10] << 1;
  output[0] += output[10];

  output[10] = 0;

  /* Now output[1..9] are reduced, and |output[0]| < 2^26 + 19*281*2^29
   * So |over| will be no more than 2^16. */
  {
    int64_t over = div_by_2_26(output[0]);
    output[0] -= over << 26;
    output[1] += over;
  }

  /* Now output[0,2..9] are reduced, and |output[1]| < 2^25 + 2^16 < 2^26. The
   * bound on |output[1]| is sufficient to meet our needs. */
}

// Assembly:
andq $0x0, 0x50(%rdi)
xorl %eax, %eax
cmpq $0x9, %rax
ja 0x65f6
movq (%rdi,%rax,8), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
sarl $0x1f, %edx
shrl $0x6, %edx
addq %rcx, %rdx
movq %rdx, %rsi
sarq $0x1a, %rsi
andq $-0x4000000, %rdx       # imm = 0xFC000000
subq %rdx, %rcx
movq %rcx, (%rdi,%rax,8)
addq 0x8(%rdi,%rax,8), %rsi
movq %rsi, %rcx
shrq $0x20, %rcx
sarl $0x1f, %ecx
shrl $0x7, %ecx
addq %rsi, %rcx
movq %rcx, %rdx
sarq $0x19, %rdx
andq $-0x2000000, %rcx       # imm = 0xFE000000
subq %rcx, %rsi
movq %rsi, 0x8(%rdi,%rax,8)
addq %rdx, 0x10(%rdi,%rax,8)
addq $0x2, %rax
jmp 0x6591
movq 0x50(%rdi), %rax
imulq $0x12, %rax, %rcx
addq (%rdi), %rax
addq %rcx, %rax
andq $0x0, 0x50(%rdi)
movq %rax, %rcx
sarq $0x3f, %rcx
shrl $0x6, %ecx
addq %rax, %rcx
movq %rcx, %rdx
sarq $0x1a, %rdx
andq $-0x4000000, %rcx       # imm = 0xFC000000
subq %rcx, %rax
movq %rax, (%rdi)
addq %rdx, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/sha256.c
// Function: sha256_update
void sha256_update(SHA256_CTX *ctx, const uint8_t data[], size_t len)
{
	uint32_t i;

	for (i = 0; i < len; ++i) {
		ctx->data[ctx->datalen] = data[i];
		ctx->datalen++;
		if (ctx->datalen == 64) {
			sha256_transform(ctx, ctx->data);
			ctx->bitlen += 512;
			ctx->datalen = 0;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl %r12d, %r12d
cmpq %rbx, %r12
jae 0x6b1c
movb (%r14,%r12), %al
movl 0x40(%r15), %ecx
movb %al, (%r15,%rcx)
movl 0x40(%r15), %eax
incl %eax
movl %eax, 0x40(%r15)
cmpl $0x40, %eax
jne 0x6b17
movq %r15, %rdi
movq %r15, %rsi
callq 0x68fc
addq $0x200, 0x48(%r15)      # imm = 0x200
andl $0x0, 0x40(%r15)
incl %r12d
jmp 0x6adc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/mcdecrypt.c
// Function: cleanup
void cleanup(void) {
    randombytes(&g, sizeof g);

    if (map != MAP_FAILED) {
        munmap(map, maplen);
        map = MAP_FAILED;
        maplen = 0;
    }

    if (buf) {
        free(buf);
        buf = 0;
    }
}

// Assembly:
pushq %rax
leaq 0x9e84(%rip), %rdi      # 0xb0c8
movl $0x1037d8, %esi         # imm = 0x1037D8
callq 0x610c
movq 0x9e5b(%rip), %rdi      # 0xb0b0
cmpq $-0x1, %rdi
je 0x1277
movq 0x10d63e(%rip), %rsi    # 0x10e8a0
callq 0x10e0
orq $-0x1, 0x9e41(%rip)     # 0xb0b0
andq $0x0, 0x10d629(%rip)    # 0x10e8a0
movq 0x10d62a(%rip), %rdi    # 0x10e8a8
testq %rdi, %rdi
je 0x1290
callq 0x1030
andq $0x0, 0x10d618(%rip)    # 0x10e8a8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: item_total_get
static inline int _item_total_get(json_object *json)
{
    int cnt = 0;
    json_object *item = NULL;

    switch (json->type_member) {
    case JSON_ARRAY:
    case JSON_OBJECT:
        json_list_for_each_entry(item, &json->value.head, list, json_object) {
            cnt += _item_total_get(item);
        }
        break;
    default:
        break;
    }
    ++cnt;

    return cnt;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x8(%rdi), %eax
andl $0xe, %eax
cmpl $0x8, %eax
jne 0x23e9
movq %rdi, %rbx
addq $0x18, %rbx
xorl %ebp, %ebp
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x23ee
movq %r14, %rdi
callq 0x23ba
addl %eax, %ebp
jmp 0x23d5
pushq $0x1
popq %rbp
jmp 0x23f0
incl %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_new_object
json_object *json_new_object(json_type_t type)
{
    json_object *json = NULL;

    if ((json = (json_object *)json_calloc(1, sizeof(json_object))) == NULL) {
        JsonErr("malloc failed!\n");
        return NULL;
    }

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

    return json;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x2160
movq %rax, %rbx
testq %rax, %rax
je 0x249a
movl %ebp, %eax
andl $0xf, %eax
movl %eax, 0x8(%rbx)
andl $-0x2, %ebp
cmpl $0x8, %ebp
jne 0x24c0
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
jmp 0x24c0
leaq 0x7dff(%rip), %rdi      # 0xa2a0
leaq 0x7e46(%rip), %rsi      # 0xa2ee
movl $0x137, %edx            # imm = 0x137
xorl %eax, %eax
callq 0x2100
leaq 0x82e9(%rip), %rdi      # 0xa7a4
callq 0x2080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_create_item
json_object *json_create_item(json_type_t type, void *value)
{
    json_object *json = NULL;

    if ((json = (json_object *)json_calloc(1, sizeof(json_object))) == NULL) {
        JsonErr("malloc failed!\n");
        return NULL;
    }

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

    return json;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %r15d
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x2160
testq %rax, %rax
je 0x2516
movq %rax, %rbx
movl %r15d, %eax
andl $0xf, %eax
movl %eax, 0x8(%rbx)
decl %r15d
cmpl $0x8, %r15d
ja 0x2583
leaq 0x7afb(%rip), %rax      # 0xa000
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl (%r14), %eax
movl %eax, 0x18(%rbx)
jmp 0x2583
leaq 0x7d83(%rip), %rdi      # 0xa2a0
leaq 0x7ddb(%rip), %rsi      # 0xa2ff
xorl %ebx, %ebx
movl $0x14d, %edx            # imm = 0x14D
xorl %eax, %eax
callq 0x2100
leaq 0x826b(%rip), %rdi      # 0xa7a4
callq 0x2080
jmp 0x2583
movq (%r14), %rax
movq %rax, 0x18(%rbx)
jmp 0x2583
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
jmp 0x2583
movb (%r14), %al
movb %al, 0x18(%rbx)
jmp 0x2583
movsd (%r14), %xmm0
movsd %xmm0, 0x18(%rbx)
jmp 0x2583
movq %rbx, %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
jns 0x2583
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_create_item_array
json_object *json_create_item_array(json_type_t type, void *values, int count)
{
    int i = 0;
    void *value = NULL;
    json_object *json = NULL, *node = NULL;

    if ((json = json_create_array()) == NULL) {
        JsonErr("create array failed!\n");
        return NULL;
    }

    for (i = 0; i < count; ++i) {
        switch (type) {
        case JSON_BOOL:   value = ((bool *)values) + i;         break;
        case JSON_INT:    value = ((int32_t *)values) + i;      break;
        case JSON_HEX:    value = ((uint32_t *)values) + i;     break;
        case JSON_LINT:   value = ((int64_t *)values) + i;      break;
        case JSON_LHEX:   value = ((uint64_t *)values) + i;     break;
        case JSON_DOUBLE: value = ((double *)values) + i;       break;
        case JSON_STRING: value = ((json_string_t *)values) + i;break;
        default:          JsonErr("not support json type.\n");  goto err;
        }

        if ((node = json_create_item(type, value)) == NULL) {
            JsonErr("create item failed!\n");
            goto err;
        }
        json_list_add_tail(&node->list, &json->value.head);
    }

    return json;
err:
    json_del_object(json);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r13
movl %edi, %r14d
callq 0x26b6
testq %rax, %rax
je 0x2639
movq %rax, %rbx
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
movq %r14, (%rsp)
decl %r14d
movq %r13, %r12
subq $0x1, %r15
jb 0x2696
cmpl $0x6, %r14d
ja 0x26a8
leaq 0x7a45(%rip), %rax      # 0xa024
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
leaq (,%rbp,8), %rax
addq %r13, %rax
leaq (,%rbp,4), %rsi
addq %r13, %rsi
jmpq *%rcx
movq %rax, %rsi
jmp 0x2612
movq %r12, %rsi
jmp 0x2612
movq %rbp, %rsi
shlq $0x4, %rsi
addq %r13, %rsi
movq (%rsp), %rdi
callq 0x22c0
testq %rax, %rax
je 0x2663
movq 0x20(%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%rbx)
incq %rbp
incq %r12
jmp 0x25c4
leaq 0x7c60(%rip), %rdi      # 0xa2a0
leaq 0x7cca(%rip), %rsi      # 0xa311
xorl %ebx, %ebx
movl $0x171, %edx            # imm = 0x171
xorl %eax, %eax
callq 0x2100
leaq 0x8088(%rip), %rdi      # 0xa6e4
callq 0x2080
jmp 0x2696
movl $0x182, %edx            # imm = 0x182
leaq 0x80a7(%rip), %r14      # 0xa716
leaq 0x7c2a(%rip), %rdi      # 0xa2a0
leaq 0x7c94(%rip), %rsi      # 0xa311
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x22a0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x17e, %edx            # imm = 0x17E
leaq 0x8076(%rip), %r14      # 0xa72a
jmp 0x266f
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_string_hash_code
uint32_t json_string_hash_code(json_string_t *jstr)
{
    uint32_t i = 0, hash = 0;

    json_string_info_update(jstr);
    if (!jstr->len)
        return 0;

    for (i = 0; i < jstr->len; ++i)
        hash = (hash << 5) - hash + jstr->str[i];
    return hash;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x20a0
movl (%rbx), %ecx
xorl %eax, %eax
cmpq $0x100, %rcx            # imm = 0x100
jae 0x2733
popq %rbx
retq
shrl $0x8, %ecx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x2731
imull $0x1f, %eax, %esi
movq 0x8(%rbx), %rax
movsbl (%rax,%rdx), %eax
addl %esi, %eax
incq %rdx
jmp 0x273a
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_string_strdup
int json_string_strdup(json_string_t *src, json_string_t *dst)
{
    json_string_info_update(src);
    json_string_info_update(dst);
    if (src->len) {
        if (dst->len < src->len) {
            char *new_str = (char *)json_realloc(dst->str, src->len + 1);
            if (new_str) {
                dst->str = new_str;
            } else {
                JsonErr("malloc failed!\n");
                json_free(dst->str);
                dst->str = NULL;
                dst->len = 0;
                return -1;
            }
        }
        dst->escaped = src->escaped;
        dst->len = src->len;
        memcpy(dst->str, src->str, src->len);
        dst->str[src->len] = '\0';
    } else {
        dst->escaped = 0;
        dst->len = 0;
        if (dst->str) {
            json_free(dst->str);
            dst->str = NULL;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20a0
movq %rbx, %rdi
callq 0x20a0
movl (%r14), %ecx
movl (%rbx), %eax
cmpl $0x100, %ecx            # imm = 0x100
jae 0x2793
andl $0xef, %eax
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x27f6
callq 0x2050
andq $0x0, 0x8(%rbx)
jmp 0x27f6
movl %ecx, %esi
shrl $0x8, %esi
movl %eax, %edx
shrl $0x8, %edx
movq 0x8(%rbx), %rdi
cmpl %esi, %edx
jae 0x27be
incq %rsi
callq 0x2230
testq %rax, %rax
je 0x27fd
movq %rax, %rdi
movq %rax, 0x8(%rbx)
movl (%r14), %ecx
movl (%rbx), %eax
andl $0x10, %ecx
andl $-0x11, %eax
orl %ecx, %eax
movl %eax, (%rbx)
movl $0xffffff00, %ecx       # imm = 0xFFFFFF00
andl (%r14), %ecx
movzbl %al, %eax
orl %ecx, %eax
movl %eax, (%rbx)
movq 0x8(%r14), %rsi
movl (%r14), %edx
shrl $0x8, %edx
callq 0x21b0
movq 0x8(%rbx), %rax
movl (%r14), %ecx
shrl $0x8, %ecx
movb $0x0, (%rax,%rcx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7a9c(%rip), %rdi      # 0xa2a0
leaq 0x7b1e(%rip), %rsi      # 0xa329
movl $0x1c4, %edx            # imm = 0x1C4
xorl %eax, %eax
callq 0x2100
leaq 0x7f86(%rip), %rdi      # 0xa7a4
callq 0x2080
movq 0x8(%rbx), %rdi
callq 0x2050
andq $0x0, 0x8(%rbx)
movzbl (%rbx), %eax
movl %eax, (%rbx)
pushq $-0x1
popq %rbp
jmp 0x27f6
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_set_number_value
int json_set_number_value(json_object *json, json_type_t type, void *value)
{
    int ret = 0;

    switch (json->type_member) {
    case JSON_BOOL:
    case JSON_INT:
    case JSON_HEX:
    case JSON_LINT:
    case JSON_LHEX:
    case JSON_DOUBLE:
        break;
    default:
        JsonErr("wrong type!\n");
        return -1;
    }

    switch (type) {
    case JSON_BOOL:   json->value.vnum.vbool = *(bool *)value;      break;
    case JSON_INT:    json->value.vnum.vint  = *(int32_t *)value;   break;
    case JSON_HEX:    json->value.vnum.vhex  = *(uint32_t *)value;  break;
    case JSON_LINT:   json->value.vnum.vlint = *(int64_t *)value;   break;
    case JSON_LHEX:   json->value.vnum.vlhex = *(uint64_t *)value;  break;
    case JSON_DOUBLE: json->value.vnum.vdbl  = *(double *)value;    break;
    default:                                                    return -1;
    }

    if (json->type_member != type) {
        ret = json->type_member;
        json->type_member = type;
    }

    return ret;
}

// Assembly:
movl 0x8(%rdi), %ecx
movl %ecx, %r8d
andl $0xf, %r8d
leal -0x1(%r8), %eax
cmpl $0x6, %eax
jae 0x2b46
leal -0x1(%rsi), %eax
cmpl $0x5, %eax
ja 0x2ba1
leaq 0x75ea(%rip), %r9       # 0xa120
movslq (%r9,%rax,4), %rax
addq %r9, %rax
jmpq *%rax
movl (%rdx), %eax
movl %eax, 0x18(%rdi)
jmp 0x2b8e
pushq %rax
leaq 0x7752(%rip), %rdi      # 0xa2a0
leaq 0x7773(%rip), %rsi      # 0xa2c8
movl $0x203, %edx            # imm = 0x203
xorl %eax, %eax
callq 0x2100
leaq 0x7b70(%rip), %rdi      # 0xa6d8
callq 0x2080
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
movq (%rdx), %rax
movq %rax, 0x18(%rdi)
jmp 0x2b8e
movb (%rdx), %al
movb %al, 0x18(%rdi)
jmp 0x2b8e
movsd (%rdx), %xmm0
movsd %xmm0, 0x18(%rdi)
xorl %eax, %eax
cmpl %esi, %r8d
je 0x2ba0
andl $-0x10, %ecx
orl %esi, %ecx
movl %ecx, 0x8(%rdi)
movl %r8d, %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_get_array_size
int json_get_array_size(json_object *json)
{
    int count = 0;
    json_object *pos = NULL;

    if (json->type_member == JSON_ARRAY) {
        json_list_for_each_entry(pos, &json->value.head, list, json_object) {
            ++count;
        }
    }

    return count;
}

// Assembly:
movl 0x8(%rdi), %ecx
andl $0xf, %ecx
xorl %eax, %eax
cmpl $0x8, %ecx
jne 0x2bc6
addq $0x18, %rdi
pushq $-0x1
popq %rax
movq %rdi, %rcx
movq (%rcx), %rcx
incl %eax
cmpq %rdi, %rcx
jne 0x2bbc
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_get_object_size
int json_get_object_size(json_object *json)
{
    int count = 0;
    json_object *pos = NULL;

    if (json->type_member == JSON_OBJECT) {
        json_list_for_each_entry(pos, &json->value.head, list, json_object) {
            ++count;
        }
    }

    return count;
}

// Assembly:
movl 0x8(%rdi), %ecx
andl $0xf, %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
jne 0x2be8
addq $0x18, %rdi
pushq $-0x1
popq %rax
movq %rdi, %rcx
movq (%rcx), %rcx
incl %eax
cmpq %rdi, %rcx
jne 0x2bde
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_get_array_item
json_object *json_get_array_item(json_object *json, int seq, json_object **prev)
{
    int count = 0;
    json_object *p = NULL, *pos = NULL, *n = NULL;

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

    return NULL;
}

// Assembly:
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x2c15
addq $0x18, %rdi
incl %esi
movq %rdi, %rax
movq %rax, %rcx
movq (%rax), %rax
cmpq %rdi, %rax
je 0x2c15
decl %esi
jne 0x2bfd
testq %rdx, %rdx
je 0x2c17
movq %rcx, (%rdx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_get_object_item
json_object *json_get_object_item(json_object *json, const char *key, json_object **prev)
{
    json_object *p = NULL, *pos = NULL, *n = NULL;

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

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x2ca0
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
testq %rsi, %rsi
je 0x2c7a
cmpb $0x0, (%r12)
je 0x2c7a
movq 0x18(%r15), %rbp
addq $0x18, %r15
movq %r15, %rcx
cmpq %r15, %rbp
je 0x2ca0
movq %rbp, %r14
movq %rcx, %r13
movq (%rbp), %rbp
movq 0x10(%r14), %rsi
movq %r14, %rcx
testq %rsi, %rsi
je 0x2c4e
movq %r12, %rdi
callq 0x2170
movq %r14, %rcx
testl %eax, %eax
jne 0x2c4e
jmp 0x2c96
addq $0x18, %r15
movq %r15, %r14
movq %r14, %r13
movq (%r14), %r14
cmpq %r15, %r14
je 0x2ca0
cmpl $0xff, 0x8(%r14)
ja 0x2c81
testq %rbx, %rbx
je 0x2ca3
movq %r13, (%rbx)
jmp 0x2ca3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_free_items
void json_free_items(json_items_t *items)
{
    if (items->items)
        json_free(items->items);
    items->items = NULL;
    items->conflicted = 0;
    items->total = 0;
    items->count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x2050
andq $0x0, 0x10(%rbx)
andb $-0x2, (%rbx)
andq $0x0, 0x4(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_add_item_to_array
int json_add_item_to_array(json_object *array, json_object *item)
{
    if (array->type_member == JSON_ARRAY) {
        json_list_add_tail(&item->list, &array->value.head);
        return 0;
    }
    return -1;
}

// Assembly:
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x3045
movq 0x20(%rdi), %rax
movq (%rax), %rcx
movq %rcx, (%rsi)
movq %rsi, (%rax)
movq %rsi, 0x20(%rdi)
xorl %eax, %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_add_item_to_object
int json_add_item_to_object(json_object *object, json_object *item)
{
    if (object->type_member == JSON_OBJECT) {
        json_list_add_tail(&item->list, &object->value.head);
        return 0;
    }
    return -1;
}

// Assembly:
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x3068
movq 0x20(%rdi), %rax
movq (%rax), %rcx
movq %rcx, (%rsi)
movq %rsi, (%rax)
movq %rsi, 0x20(%rdi)
xorl %eax, %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_detach_item_from_array
json_object *json_detach_item_from_array(json_object *json, int seq)
{
    json_object *item = NULL, *prev = NULL;

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

    return item;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
callq 0x2190
testq %rax, %rax
je 0x30a3
movq 0x8(%rsp), %rcx
leaq 0x18(%rbx), %rsi
movq (%rax), %rdx
cmpq %rsi, %rdx
jne 0x309c
movq %rcx, 0x20(%rbx)
movq %rdx, (%rcx)
andq $0x0, (%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_detach_item_from_object
json_object *json_detach_item_from_object(json_object *json, const char *key)
{
    json_object *item = NULL, *prev = NULL;

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

    return item;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
callq 0x2210
testq %rax, %rax
je 0x30e0
movq 0x8(%rsp), %rcx
leaq 0x18(%rbx), %rsi
movq (%rax), %rdx
cmpq %rsi, %rdx
jne 0x30d9
movq %rcx, 0x20(%rbx)
movq %rdx, (%rcx)
andq $0x0, (%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_replace_item_in_array
int json_replace_item_in_array(json_object *array, int seq, json_object *new_item)
{
    json_object *item = NULL, *prev = NULL;

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

        return 0;
    }

    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x3187
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
callq 0x2190
testq %rax, %rax
je 0x318c
movq 0x8(%rsp), %rcx
leaq 0x18(%r14), %r15
movq (%rax), %rdx
cmpq %r15, %rdx
jne 0x3162
movq %rcx, 0x20(%r14)
movq %rdx, (%rcx)
andq $0x0, (%rax)
movq %rax, %rdi
callq 0x22a0
movq 0x8(%rsp), %rax
movq (%rax), %rcx
cmpq %r15, %rcx
jne 0x3182
movq %rbx, 0x20(%r14)
movq %rcx, (%rbx)
jmp 0x31a0
pushq $-0x1
popq %rax
jmp 0x31a5
movq 0x20(%r14), %rax
addq $0x20, %r14
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %r14, %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_replace_item_in_object
int json_replace_item_in_object(json_object *object, json_object *new_item)
{
    json_object *item = NULL, *prev = NULL;

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

        return 0;
    }

    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x321c
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2210
testq %rax, %rax
je 0x3221
movq 0x8(%rsp), %rcx
leaq 0x18(%r14), %r15
movq (%rax), %rdx
cmpq %r15, %rdx
jne 0x31f7
movq %rcx, 0x20(%r14)
movq %rdx, (%rcx)
andq $0x0, (%rax)
movq %rax, %rdi
callq 0x22a0
movq 0x8(%rsp), %rax
movq (%rax), %rcx
cmpq %r15, %rcx
jne 0x3217
movq %rbx, 0x20(%r14)
movq %rcx, (%rbx)
jmp 0x3235
pushq $-0x1
popq %rax
jmp 0x323a
movq 0x20(%r14), %rax
addq $0x20, %r14
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %r14, %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_copy_item_to_array
int json_copy_item_to_array(json_object *array, json_object *item)
{
    json_object *node = NULL;

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

    return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
pushq $-0x1
popq %rbx
cmpl $0x8, %eax
jne 0x33e8
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2290
testq %rax, %rax
je 0x33c2
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
jmp 0x33e8
leaq 0x6ed7(%rip), %rdi      # 0xa2a0
leaq 0x6f7c(%rip), %rsi      # 0xa34c
movl $0x384, %edx            # imm = 0x384
xorl %eax, %eax
callq 0x2100
leaq 0x7316(%rip), %rdi      # 0xa6f9
callq 0x2080
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_copy_item_to_object
int json_copy_item_to_object(json_object *object, json_object *item)
{
    json_object *node = NULL;

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

    return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
pushq $-0x1
popq %rbx
cmpl $0x9, %eax
jne 0x344f
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2290
testq %rax, %rax
je 0x3429
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
jmp 0x344f
leaq 0x6e70(%rip), %rdi      # 0xa2a0
leaq 0x6f2e(%rip), %rsi      # 0xa365
movl $0x394, %edx            # imm = 0x394
xorl %eax, %eax
callq 0x2100
leaq 0x72af(%rip), %rdi      # 0xa6f9
callq 0x2080
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_add_new_item_to_array
json_object *json_add_new_item_to_array(json_object *array, json_type_t type, void *value)
{
    json_object *item = NULL;

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

    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x3495
cmpl $0x9, %esi
ja 0x3499
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0x22c0
testq %rax, %rax
je 0x34be
movq %rax, %rbx
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
jmp 0x34e6
xorl %ebx, %ebx
jmp 0x34e6
leaq 0x6e00(%rip), %rdi      # 0xa2a0
leaq 0x6ed8(%rip), %rsi      # 0xa37f
xorl %ebx, %ebx
movl $0x3b5, %edx            # imm = 0x3B5
xorl %eax, %eax
callq 0x2100
leaq 0x726e(%rip), %rdi      # 0xa72a
jmp 0x34e1
leaq 0x6ddb(%rip), %rdi      # 0xa2a0
leaq 0x6eb3(%rip), %rsi      # 0xa37f
xorl %ebx, %ebx
movl $0x3af, %edx            # imm = 0x3AF
xorl %eax, %eax
callq 0x2100
leaq 0x7235(%rip), %rdi      # 0xa716
callq 0x2080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_add_new_item_to_object
json_object *json_add_new_item_to_object(json_object *object, json_type_t type, json_string_t *jkey, void *value)
{
    json_object *item = NULL;

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

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x35c5
cmpl $0x9, %esi
ja 0x3548
movq %rdx, %r15
movq %rdi, %r14
movl %esi, %edi
movq %rcx, %rsi
callq 0x22c0
testq %rax, %rax
je 0x356d
movq %rax, %rbx
movq %rax, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x21d0
testl %eax, %eax
js 0x3597
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
jmp 0x35c7
leaq 0x6d51(%rip), %rdi      # 0xa2a0
leaq 0x6e45(%rip), %rsi      # 0xa39b
xorl %ebx, %ebx
movl $0x3d9, %edx            # imm = 0x3D9
xorl %eax, %eax
callq 0x2100
leaq 0x71bf(%rip), %rdi      # 0xa72a
jmp 0x3590
leaq 0x6d2c(%rip), %rdi      # 0xa2a0
leaq 0x6e20(%rip), %rsi      # 0xa39b
xorl %ebx, %ebx
movl $0x3ce, %edx            # imm = 0x3CE
xorl %eax, %eax
callq 0x2100
leaq 0x7186(%rip), %rdi      # 0xa716
callq 0x2080
jmp 0x35c7
leaq 0x6d02(%rip), %rdi      # 0xa2a0
leaq 0x6df6(%rip), %rsi      # 0xa39b
movl $0x3d2, %edx            # imm = 0x3D2
xorl %eax, %eax
callq 0x2100
leaq 0x714e(%rip), %rdi      # 0xa706
callq 0x2080
movq %rbx, %rdi
callq 0x22a0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: json_mem_refresh
static void _json_mem_refresh(json_mem_mgr_t *mgr)
{
    json_mem_node_t *p = NULL, *pos = NULL, *n = NULL;
    int i = 0;
    json_list_for_each_entry_safe(p, pos, n, &mgr->head, list, json_mem_node_t) {
        if (++i == 1) {
            pos->cur = pos->ptr;
            mgr->cur_node = pos;
        } else {
            json_list_del(&pos->list, &p->list, &mgr->head);
            json_free(pos->ptr);
            json_free(pos);
            pos = p;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r12
xorl %ebp, %ebp
movq %rdi, %r15
incl %ebp
movq %r12, %r14
cmpq %rbx, %r12
je 0x3702
movq (%r14), %r12
cmpl $0x1, %ebp
je 0x36f1
cmpq %rbx, %r12
jne 0x36d7
movq %r15, 0x8(%rbx)
movq %r12, (%r15)
andq $0x0, (%r14)
movq 0x10(%r14), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
jmp 0x36bc
movq 0x10(%r14), %rax
movq %rax, 0x18(%r14)
movq %r14, 0x18(%rbx)
movq %r14, %r15
jmp 0x36bc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_new_object
json_object *pjson_new_object(json_type_t type, json_mem_t *mem)
{
    json_object *json = NULL;

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

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

    return json;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
addq $0x8, %rsi
pushq $0x28
popq %rdi
callq 0x3797
movq %rax, %rbx
testq %rax, %rax
je 0x3767
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movl %ebp, %eax
andl $0xf, %eax
movl %eax, 0x8(%rbx)
andl $-0x2, %ebp
cmpl $0x8, %ebp
jne 0x378d
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
jmp 0x378d
leaq 0x6b32(%rip), %rdi      # 0xa2a0
leaq 0x6b78(%rip), %rsi      # 0xa2ed
movl $0x453, %edx            # imm = 0x453
xorl %eax, %eax
callq 0x2100
leaq 0x701c(%rip), %rdi      # 0xa7a4
callq 0x2080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_create_item
json_object *pjson_create_item(json_type_t type, void *value, json_mem_t *mem)
{
    json_object *json = NULL;

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

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

    return json;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r12d
leaq 0x8(%rdx), %rsi
pushq $0x28
popq %rdi
callq 0x3797
testq %rax, %rax
je 0x38e4
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %r12d, %eax
andl $0xf, %eax
movl %eax, 0x8(%rbx)
decl %r12d
cmpl $0x8, %r12d
ja 0x3958
leaq 0x688d(%rip), %rax      # 0xa160
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl (%r14), %eax
movl %eax, 0x18(%rbx)
jmp 0x3958
leaq 0x69b5(%rip), %rdi      # 0xa2a0
leaq 0x6a0c(%rip), %rsi      # 0xa2fe
xorl %ebx, %ebx
movl $0x46a, %edx            # imm = 0x46A
xorl %eax, %eax
callq 0x2100
leaq 0x6e9d(%rip), %rdi      # 0xa7a4
callq 0x2080
jmp 0x3958
movq (%r14), %rax
movq %rax, 0x18(%rbx)
jmp 0x3958
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
jmp 0x3958
movb (%r14), %al
movb %al, 0x18(%rbx)
jmp 0x3958
movsd (%r14), %xmm0
movsd %xmm0, 0x18(%rbx)
jmp 0x3958
movq %rbx, %rsi
addq $0x18, %rsi
addq $0x48, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x2220
testl %eax, %eax
jns 0x3958
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_create_item_array
json_object *pjson_create_item_array(json_type_t item_type, void *values, int count, json_mem_t *mem)
{
    int i = 0;
    void *value = NULL;
    json_object *json = NULL, *node = NULL;

    if ((json = pjson_create_array(mem)) == NULL) {
        JsonErr("create array failed!\n");
        return NULL;
    }

    for (i = 0; i < count; ++i) {
        switch (item_type) {
        case JSON_BOOL:   value = ((bool *)values) + i;         break;
        case JSON_INT:    value = ((int32_t *)values) + i;      break;
        case JSON_HEX:    value = ((uint32_t *)values) + i;     break;
        case JSON_LINT:   value = ((int64_t *)values) + i;      break;
        case JSON_LHEX:   value = ((uint64_t *)values) + i;     break;
        case JSON_DOUBLE: value = ((double *)values) + i;       break;
        case JSON_STRING: value = ((json_string_t *)values) + i;break;
        default: JsonErr("not support json type.\n");     return NULL;
        }

        if ((node = pjson_create_item(item_type, value, mem)) == NULL) {
            JsonErr("create item failed!\n");
            return NULL;
        }
        json_list_add_tail(&node->list, &json->value.head);
    }

    return json;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movq %rsi, %r15
movl %edi, %r13d
movq %rcx, 0x10(%rsp)
movq %rcx, %rdi
callq 0x3a72
testq %rax, %rax
je 0x3a19
movq %rax, %rbx
xorl %r14d, %r14d
testl %r12d, %r12d
cmovlel %r14d, %r12d
movq %r13, 0x8(%rsp)
leal -0x1(%r13), %ebp
movq %r15, %r13
subq $0x1, %r12
jb 0x3a52
cmpl $0x6, %ebp
ja 0x3a64
leaq 0x67bd(%rip), %rax      # 0xa184
movslq (%rax,%rbp,4), %rcx
addq %rax, %rcx
leaq (%r15,%r14,8), %rax
leaq (%r15,%r14,4), %rsi
jmpq *%rcx
movq %rax, %rsi
jmp 0x39ec
movq %r13, %rsi
jmp 0x39ec
movq %r14, %rsi
shlq $0x4, %rsi
addq %r15, %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x21c0
testq %rax, %rax
je 0x3a27
movq 0x20(%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%rbx)
incq %r14
incq %r13
jmp 0x39ad
leaq 0x6cc4(%rip), %r14      # 0xa6e4
movl $0x48f, %edx            # imm = 0x48F
jmp 0x3a33
movl $0x4a0, %edx            # imm = 0x4A0
leaq 0x6ce3(%rip), %r14      # 0xa716
leaq 0x6866(%rip), %rdi      # 0xa2a0
leaq 0x68cf(%rip), %rsi      # 0xa310
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
callq 0x2080
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x49c, %edx            # imm = 0x49C
leaq 0x6cba(%rip), %r14      # 0xa72a
jmp 0x3a33
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_string_strdup
int pjson_string_strdup(json_string_t *src, json_string_t *dst, json_mem_mgr_t *mgr)
{
    json_string_info_update(src);
    json_string_info_update(dst);
    if (src->len) {
        if (dst->len < src->len) {
            if ((dst->str = (char *)pjson_memory_alloc(src->len + 1, mgr)) == NULL) {
                JsonErr("malloc failed!\n");
                dst->len = 0;
                return -1;
            }
        }
        dst->escaped = src->escaped;
        dst->len = src->len;
        memcpy(dst->str, src->str, src->len);
        dst->str[src->len] = '\0';
    } else {
        dst->escaped = 0;
        dst->len = 0;
        dst->str = NULL;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20a0
movq %rbx, %rdi
callq 0x20a0
movl (%r14), %ecx
movl (%rbx), %eax
cmpl $0x100, %ecx            # imm = 0x100
jae 0x3ab3
andl $0xef, %eax
movl %eax, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x3b19
movl %ecx, %edi
shrl $0x8, %edi
movl %eax, %edx
shrl $0x8, %edx
cmpl %edi, %edx
jae 0x3adf
incq %rdi
movq %r15, %rsi
callq 0x3797
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x3b21
movq %rax, %rdi
movl (%r14), %ecx
movl (%rbx), %eax
jmp 0x3ae3
movq 0x8(%rbx), %rdi
andl $0x10, %ecx
andl $-0x11, %eax
orl %ecx, %eax
movl %eax, (%rbx)
movl $0xffffff00, %ecx       # imm = 0xFFFFFF00
andl (%r14), %ecx
movzbl %al, %eax
orl %ecx, %eax
movl %eax, (%rbx)
movq 0x8(%r14), %rsi
movl (%r14), %edx
shrl $0x8, %edx
callq 0x21b0
movq 0x8(%rbx), %rax
movl (%r14), %ecx
shrl $0x8, %ecx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6778(%rip), %rdi      # 0xa2a0
leaq 0x67f9(%rip), %rsi      # 0xa328
movl $0x4b0, %edx            # imm = 0x4B0
xorl %eax, %eax
callq 0x2100
leaq 0x6c62(%rip), %rdi      # 0xa7a4
callq 0x2080
movzbl (%rbx), %eax
movl %eax, (%rbx)
pushq $-0x1
popq %rax
jmp 0x3b1b
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_copy_item_to_array
int pjson_copy_item_to_array(json_object *array, json_object *item, json_mem_t *mem)
{
    json_object *node = NULL;

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

    return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
pushq $-0x1
popq %rbx
cmpl $0x8, %eax
jne 0x3e1d
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x21a0
testq %rax, %rax
je 0x3df7
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
jmp 0x3e1d
leaq 0x64a2(%rip), %rdi      # 0xa2a0
leaq 0x6546(%rip), %rsi      # 0xa34b
movl $0x512, %edx            # imm = 0x512
xorl %eax, %eax
callq 0x2100
leaq 0x68e1(%rip), %rdi      # 0xa6f9
callq 0x2080
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_copy_item_to_object
int pjson_copy_item_to_object(json_object *object, json_object *item, json_mem_t *mem)
{
    json_object *node = NULL;

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

    return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
pushq $-0x1
popq %rbx
cmpl $0x9, %eax
jne 0x3e87
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x21a0
testq %rax, %rax
je 0x3e61
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
jmp 0x3e87
leaq 0x6438(%rip), %rdi      # 0xa2a0
leaq 0x64f5(%rip), %rsi      # 0xa364
movl $0x522, %edx            # imm = 0x522
xorl %eax, %eax
callq 0x2100
leaq 0x6877(%rip), %rdi      # 0xa6f9
callq 0x2080
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_add_new_item_to_array
json_object *pjson_add_new_item_to_array(json_object *array, json_type_t type, void *value, json_mem_t *mem)
{
    json_object *item = NULL;

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

    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x3ed0
cmpl $0x9, %esi
ja 0x3ed4
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x21c0
testq %rax, %rax
je 0x3ef9
movq %rax, %rbx
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
jmp 0x3f21
xorl %ebx, %ebx
jmp 0x3f21
leaq 0x63c5(%rip), %rdi      # 0xa2a0
leaq 0x649c(%rip), %rsi      # 0xa37e
xorl %ebx, %ebx
movl $0x543, %edx            # imm = 0x543
xorl %eax, %eax
callq 0x2100
leaq 0x6833(%rip), %rdi      # 0xa72a
jmp 0x3f1c
leaq 0x63a0(%rip), %rdi      # 0xa2a0
leaq 0x6477(%rip), %rsi      # 0xa37e
xorl %ebx, %ebx
movl $0x53d, %edx            # imm = 0x53D
xorl %eax, %eax
callq 0x2100
leaq 0x67fa(%rip), %rdi      # 0xa716
callq 0x2080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq