LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/hiredis/net.c
// Function: redisContextWaitReady
static int redisContextWaitReady(redisContext *c, int fd, const struct timeval *timeout) {
    struct pollfd   wfd[1];
    long msec;

    msec          = -1;
    wfd[0].fd     = fd;
    wfd[0].events = POLLOUT;

    /* Only use timeout when not NULL. */
    if (timeout != NULL) {
        if (timeout->tv_usec > 1000000 || timeout->tv_sec > __MAX_MSEC) {
            close(fd);
            return REDIS_ERR;
        }

        msec = (timeout->tv_sec * 1000) + ((timeout->tv_usec + 999) / 1000);

        if (msec < 0 || msec > INT_MAX) {
            msec = INT_MAX;
        }
    }

    if (errno == EINPROGRESS) {
        int res;

        if ((res = poll(wfd, 1, msec)) == -1) {
            __redisSetErrorFromErrno(c, REDIS_ERR_IO, "poll(2)");
            close(fd);
            return REDIS_ERR;
        } else if (res == 0) {
            errno = ETIMEDOUT;
            __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
            close(fd);
            return REDIS_ERR;
        }

        if (redisCheckSocketError(c, fd) != REDIS_OK)
            return REDIS_ERR;

        return REDIS_OK;
    }

    __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
    close(fd);
    return REDIS_ERR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, (%rsp)
movw $0x4, 0x4(%rsp)
testq %rdx, %rdx
je 0x63af5
movq 0x8(%rdx), %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
jg 0x63b3f
movq (%rdx), %rcx
movabsq $0x20c49ba5e353f7, %rdx # imm = 0x20C49BA5E353F7
cmpq %rdx, %rcx
jge 0x63b3f
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
addq $0x3e7, %rax            # imm = 0x3E7
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
imulq %rdx
movq %rdx, %r15
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r15
addq %rax, %r15
addq %rcx, %r15
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r15
cmovaeq %rax, %r15
jmp 0x63afb
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
callq 0x1f810
cmpl $0x73, (%rax)
jne 0x63b35
movq %rax, %r12
movq %rsp, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x1f600
testl %eax, %eax
je 0x63b2d
cmpl $-0x1, %eax
jne 0x63b57
leaq 0x3cb53(%rip), %rsi     # 0xa067b
movq %r14, %rdi
jmp 0x63b3a
movl $0x6e, (%r12)
movq %r14, %rdi
xorl %esi, %esi
callq 0x63708
movl %ebx, %edi
callq 0x1f170
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movl %ebx, %esi
callq 0x63690
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x63b4b
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_encode
static int json_encode(lua_State *l)
{
    json_config_t *cfg;
    char *json;
    int len;

    /* Can't use json_verify_arg_count() since we need to ensure
     * there is only 1 argument */
    luaL_argcheck(l, lua_gettop(l) == 1, 1, "expected 1 argument");

    cfg = json_fetch_config(l);
    cfg->current_depth = 0;

    /* Reset the persistent buffer if it exists.
     * Otherwise allocate a new buffer. */
    if (strbuf_allocated(&cfg->encode_buf))
        strbuf_reset(&cfg->encode_buf);
    else
        strbuf_init(&cfg->encode_buf, 0);

    json_append_data(l, cfg, &cfg->encode_buf);
    json = strbuf_string(&cfg->encode_buf, &len);

    lua_pushlstring(l, json, len);

    if (!cfg->encode_keep_buffer)
        strbuf_free(&cfg->encode_buf);

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x65ae0
cmpl $0x1, %eax
je 0x76e2b
leaq 0x2b466(%rip), %rdx     # 0xa2284
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70e34
movq %rbx, %rdi
callq 0x772d8
movq %rax, %r15
movl $0x0, 0x528(%rax)
leaq 0x500(%rax), %r14
cmpq $0x0, 0x500(%rax)
je 0x76e5e
movl $0x0, 0x50c(%r15)
jmp 0x76e68
movq %r14, %rdi
xorl %esi, %esi
callq 0x7c060
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x77336
movslq 0x50c(%r15), %rdx
movq 0x500(%r15), %rsi
movq %rbx, %rdi
callq 0x6625e
cmpl $0x0, 0x544(%r15)
jne 0x76e9e
movq %r14, %rdi
callq 0x7c105
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_decode
static int json_decode(lua_State *l)
{
    const char *json;
    size_t len;

    json_verify_arg_count(l, 1);

    json = luaL_checklstring(l, 1, &len);

    /* Detect Unicode other than UTF-8 (see RFC 4627, Sec 3)
     *
     * CJSON can support any simple data type, hence only the first
     * character is guaranteed to be ASCII (at worst: '"'). This is
     * still enough to detect whether the wrong encoding is in use. */
    if (len >= 2 && (!json[0] || !json[1]))
        luaL_error(l, "JSON parser does not support UTF-16 or UTF-32");

    lua_json_decode(l, json, len);

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x77a0f
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x71138
movq %rax, %r14
movq (%r15), %r15
cmpq $0x2, %r15
jb 0x76f05
cmpb $0x0, (%r14)
je 0x76eef
cmpb $0x0, 0x1(%r14)
jne 0x76f05
leaq 0x2b54d(%rip), %rsi     # 0xa2443
movq %rbx, %rdi
xorl %eax, %eax
callq 0x70eeb
movq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0x772d8
leaq 0x10(%rsp), %r12
movq %rax, 0x18(%r12)
movq %r14, (%r12)
movl $0x0, 0x8(%r12)
movl %r15d, %edi
callq 0x7c0a7
movq %rax, 0x10(%r12)
leaq 0x30(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x77a43
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x77e43
movq %r12, %rdi
movq %r14, %rsi
callq 0x77a43
cmpl $0xa, (%r14)
je 0x76f79
movq 0x20(%rsp), %rsi
leaq 0x2b51e(%rip), %rdx     # 0xa248a
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x780aa
movq 0x20(%rsp), %rdi
callq 0x7c105
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_cfg_encode_sparse_array
static int json_cfg_encode_sparse_array(lua_State *l)
{
    json_config_t *cfg;
    int val;

    json_verify_arg_count(l, 3);
    cfg = json_fetch_config(l);

    switch (lua_gettop(l)) {
    case 3:
        val = luaL_checkinteger(l, 3);
        luaL_argcheck(l, val >= 0, 3, "expected integer >= 0");
        cfg->encode_sparse_safe = val;
    case 2:
        val = luaL_checkinteger(l, 2);
        luaL_argcheck(l, val >= 0, 2, "expected integer >= 0");
        cfg->encode_sparse_ratio = val;
    case 1:
        luaL_argcheck(l, lua_isboolean(l, 1), 1, "expected boolean");
        cfg->encode_sparse_convert = lua_toboolean(l, 1);
    }

    lua_pushboolean(l, cfg->encode_sparse_convert);
    lua_pushinteger(l, cfg->encode_sparse_ratio);
    lua_pushinteger(l, cfg->encode_sparse_safe);

    return 3;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x3, %esi
callq 0x77a0f
movq %rbx, %rdi
callq 0x772d8
movq %rax, %r14
movq %rbx, %rdi
callq 0x65ae0
cmpl $0x1, %eax
je 0x7702c
cmpl $0x2, %eax
je 0x76ffc
cmpl $0x3, %eax
jne 0x7706a
movq %rbx, %rdi
movl $0x3, %esi
callq 0x71388
movq %rax, %r15
testl %r15d, %r15d
jns 0x76ff5
leaq 0x2b61c(%rip), %rdx     # 0xa2604
movq %rbx, %rdi
movl $0x3, %esi
callq 0x70e34
movl %r15d, 0x534(%r14)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x71388
movq %rax, %r15
testl %r15d, %r15d
jns 0x77025
leaq 0x2b5ec(%rip), %rdx     # 0xa2604
movq %rbx, %rdi
movl $0x2, %esi
callq 0x70e34
movl %r15d, 0x530(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x65e4e
cmpl $0x1, %eax
je 0x77052
leaq 0x2b5d5(%rip), %rdx     # 0xa261a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70e34
movq %rbx, %rdi
movl $0x1, %esi
callq 0x66066
movl %eax, %esi
movl %eax, 0x52c(%r14)
jmp 0x77071
movl 0x52c(%r14), %esi
movq %rbx, %rdi
callq 0x66481
movslq 0x530(%r14), %rsi
movq %rbx, %rdi
callq 0x66244
movslq 0x534(%r14), %rsi
movq %rbx, %rdi
callq 0x66244
movl $0x3, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_cfg_encode_max_depth
static int json_cfg_encode_max_depth(lua_State *l)
{
    json_config_t *cfg;
    int depth;

    json_verify_arg_count(l, 1);
    cfg = json_fetch_config(l);

    if (lua_gettop(l)) {
        depth = luaL_checkinteger(l, 1);
        luaL_argcheck(l, depth > 0, 1, "expected positive integer");
        cfg->encode_max_depth = depth;
    }

    lua_pushinteger(l, cfg->encode_max_depth);

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x77a0f
movq %rbx, %rdi
callq 0x772d8
movq %rax, %r14
movq %rbx, %rdi
callq 0x65ae0
testl %eax, %eax
je 0x770fd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x71388
movq %rax, %r15
testl %r15d, %r15d
jg 0x770f4
leaq 0x2b544(%rip), %rdx     # 0xa262b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70e34
movl %r15d, 0x538(%r14)
jmp 0x77104
movl 0x538(%r14), %r15d
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x66244
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_cfg_encode_number_precision
static int json_cfg_encode_number_precision(lua_State *l)
{
    json_config_t *cfg;
    int precision;

    json_verify_arg_count(l, 1);
    cfg = json_fetch_config(l);

    if (lua_gettop(l)) {
        precision = luaL_checkinteger(l, 1);
        luaL_argcheck(l, 1 <= precision && precision <= 14, 1,
                      "expected integer between 1 and 14");
        json_set_number_precision(cfg, precision);
    }

    lua_pushinteger(l, cfg->encode_number_precision);

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x77a0f
movq %rbx, %rdi
callq 0x772d8
movq %rax, %r14
movq %rbx, %rdi
callq 0x65ae0
testl %eax, %eax
je 0x77190
movq %rbx, %rdi
movl $0x1, %esi
callq 0x71388
movq %rax, %r15
decl %eax
cmpl $0xe, %eax
jb 0x7716e
leaq 0x2b4e4(%rip), %rdx     # 0xa2645
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70e34
movl %r15d, 0x548(%r14)
movq %r14, %rdi
addq $0x520, %rdi            # imm = 0x520
leaq 0x2b4e1(%rip), %rsi     # 0xa2667
movl %r15d, %edx
xorl %eax, %eax
callq 0x1f570
movslq 0x548(%r14), %rsi
movq %rbx, %rdi
callq 0x66244
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_cfg_encode_keep_buffer
static int json_cfg_encode_keep_buffer(lua_State *l)
{
    json_config_t *cfg;

    json_verify_arg_count(l, 1);
    cfg = json_fetch_config(l);

    if (lua_gettop(l)) {
        luaL_checktype(l, 1, LUA_TBOOLEAN);
        cfg->encode_keep_buffer = lua_toboolean(l, 1);
    }

    lua_pushboolean(l, cfg->encode_keep_buffer);

    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x77a0f
movq %rbx, %rdi
callq 0x772d8
movq %rax, %r14
movq %rbx, %rdi
callq 0x65ae0
testl %eax, %eax
je 0x771fc
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x71293
movq %rbx, %rdi
movl $0x1, %esi
callq 0x66066
movl %eax, %esi
movl %eax, 0x544(%r14)
jmp 0x77203
movl 0x544(%r14), %esi
movq %rbx, %rdi
callq 0x66481
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_cfg_refuse_invalid_numbers
static int json_cfg_refuse_invalid_numbers(lua_State *l)
{
    static const char *options_enc_dec[] = { "none", "encode", "decode",
                                             "both", NULL };
    json_config_t *cfg;

    json_verify_arg_count(l, 1);
    cfg = json_fetch_config(l);

    json_enum_option(l, options_enc_dec,
                     &cfg->encode_refuse_badnum,
                     &cfg->decode_refuse_badnum);

    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x77a0f
movq %rbx, %rdi
callq 0x772d8
movq %rax, %r14
movq %rbx, %rdi
callq 0x65ae0
testl %eax, %eax
je 0x77264
movq %rbx, %rdi
movl $0x1, %esi
callq 0x65e4e
cmpl $0x1, %eax
jne 0x77276
movq %rbx, %rdi
movl $0x1, %esi
callq 0x66066
leal (%rax,%rax,2), %eax
jmp 0x7728c
movl 0x540(%r14), %eax
addl %eax, %eax
orl 0x53c(%r14), %eax
jmp 0x772a6
leaq 0x52c93(%rip), %rcx     # 0xc9f10
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x7104e
movl %eax, %ecx
andl $0x1, %ecx
movl %ecx, 0x53c(%r14)
movl %eax, %ecx
shrl %ecx
andl $0x1, %ecx
movl %ecx, 0x540(%r14)
testl %eax, %eax
je 0x772c1
cltq
leaq 0x52c5d(%rip), %rcx     # 0xc9f10
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x662b5
jmp 0x772cb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x66481
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_fetch_config
static json_config_t *json_fetch_config(lua_State *l)
{
    json_config_t *cfg;

    lua_pushlightuserdata(l, &json_config_key);
    lua_gettable(l, LUA_REGISTRYINDEX);
    cfg = lua_touserdata(l, -1);
    if (!cfg)
        luaL_error(l, "BUG: Unable to fetch CJSON configuration");

    lua_pop(l, 1);

    return cfg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6786a(%rip), %rsi     # 0xdeb50
callq 0x6649b
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x664d3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6617f
movq %rax, %r14
testq %rax, %rax
jne 0x7731e
leaq 0x2af84(%rip), %rsi     # 0xa2298
movq %rbx, %rdi
xorl %eax, %eax
callq 0x70eeb
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x65aed
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_append_number
static void json_append_number(lua_State *l, strbuf_t *json, int index,
                               json_config_t *cfg)
{
    double num = lua_tonumber(l, index);

    if (cfg->encode_refuse_badnum && (isinf(num) || isnan(num)))
        json_encode_exception(l, cfg, index, "must not be NaN or Inf");

    /* Lowest double printed with %.14g is 21 characters long:
     * -1.7976931348623e+308
     *
     * Use 32 to include the \0, and a few extra just in case..
     */
    strbuf_append_fmt(json, 32, cfg->number_fmt, num);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %esi
callq 0x66008
cmpl $0x0, 0x53c(%rbx)
movq %xmm0, %rax
setne %cl
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rdx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rdx, %rax
setg %al
andb %cl, %al
cmpb $0x1, %al
jne 0x77943
leaq 0x2aa81(%rip), %rcx     # 0xa23ad
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %xmm0, (%rsp)
callq 0x77966
movq (%rsp), %xmm0
addq $0x520, %rbx            # imm = 0x520
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7c280
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_encode_exception
static void json_encode_exception(lua_State *l, json_config_t *cfg, int lindex,
                                  const char *reason)
{
    if (!cfg->encode_keep_buffer)
        strbuf_free(&cfg->encode_buf);
    luaL_error(l, "Cannot serialise %s: %s",
                  lua_typename(l, lua_type(l, lindex)), reason);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
cmpl $0x0, 0x544(%rsi)
jne 0x7798a
addq $0x500, %rsi            # imm = 0x500
movq %rsi, %rdi
callq 0x7c105
movq %r14, %rdi
movl %ebp, %esi
callq 0x65e4e
movq %r14, %rdi
movl %eax, %esi
callq 0x65e6c
leaq 0x2aa86(%rip), %rsi     # 0xa242b
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x70eeb
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_encode_descend
static void json_encode_descend(lua_State *l, json_config_t *cfg)
{
    cfg->current_depth++;

    if (cfg->current_depth > cfg->encode_max_depth) {
        if (!cfg->encode_keep_buffer)
            strbuf_free(&cfg->encode_buf);
        luaL_error(l, "Cannot serialise, excessive nesting (%d)",
                   cfg->current_depth);
    }
}

// Assembly:
movl 0x528(%rsi), %eax
leal 0x1(%rax), %edx
movl %edx, 0x528(%rsi)
cmpl 0x538(%rsi), %eax
jge 0x779d1
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x544(%rsi)
jne 0x779f7
leaq 0x500(%r14), %rdi
callq 0x7c105
movl 0x528(%r14), %edx
leaq 0x2a9df(%rip), %rsi     # 0xa23dd
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x70eeb
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_is_invalid_number
static int json_is_invalid_number(json_parse_t *json)
{
    int i = json->index;

    /* Reject numbers starting with + */
    if (json->data[i] == '+')
        return 1;

    /* Skip minus sign if it exists */
    if (json->data[i] == '-')
        i++;

    /* Reject numbers starting with 0x, or leading zeros */
    if (json->data[i] == '0') {
        int ch2 = json->data[i + 1];

        if ((ch2 | 0x20) == 'x' ||          /* Hex */
            ('0' <= ch2 && ch2 <= '9'))     /* Leading zero */
            return 1;

        return 0;
    } else if (json->data[i] <= '9') {
        return 0;                           /* Ordinary number */
    }


    /* Reject inf/nan */
    if (!strncasecmp(&json->data[i], "inf", 3))
        return 1;
    if (!strncasecmp(&json->data[i], "nan", 3))
        return 1;

    /* Pass all other numbers which may still be invalid, but
     * strtod() will catch them. */
    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movslq %esi, %rcx
movzbl (%rdi,%rcx), %eax
movb $0x1, %bpl
cmpl $0x2b, %eax
je 0x7817c
movq %rdi, %rbx
cmpl $0x2d, %eax
jne 0x78120
movslq %esi, %rcx
movb 0x1(%rbx,%rcx), %al
incq %rcx
addq %rcx, %rbx
cmpb $0x30, %al
jne 0x78142
movb 0x1(%rbx), %al
movl %eax, %ecx
andb $-0x21, %cl
cmpb $0x58, %cl
sete %cl
addb $-0x30, %al
cmpb $0xa, %al
setb %bpl
orb %cl, %bpl
jmp 0x7817c
cmpb $0x3a, %al
jge 0x7814a
xorl %ebp, %ebp
jmp 0x7817c
leaq 0x1eca2(%rip), %rsi     # 0x96df3
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1f860
testl %eax, %eax
je 0x7817c
leaq 0x1f1af(%rip), %rsi     # 0x97318
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1f860
testl %eax, %eax
sete %bpl
movzbl %bpl, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_next_number_token
static void json_next_number_token(json_parse_t *json, json_token_t *token)
{
    const char *startptr;
    char *endptr;

    token->type = T_NUMBER;
    startptr = &json->data[json->index];
    token->value.number = strtod(&json->data[json->index], &endptr);
    if (startptr == endptr)
        json_set_token_error(token, json, "invalid number");
    else
        json->index += endptr - startptr;   /* Skip the processed number */

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x5, (%rsi)
movslq 0x8(%rdi), %r15
addq (%rdi), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1fc40
movsd %xmm0, 0x8(%r14)
movq (%r12), %rax
cmpq %rax, %r15
je 0x781c7
subl %r15d, %eax
addl %eax, 0x8(%rbx)
jmp 0x781e0
movl 0x8(%rbx), %eax
movl $0xc, (%r14)
movl %eax, 0x4(%r14)
leaq 0x2a2c4(%rip), %rax     # 0xa24a0
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_struct.c
// Function: getnum
static int getnum (const char **fmt, int df) {
  if (!isdigit(**fmt))  /* no number? */
    return df;  /* return default value */
  else {
    int a = 0;
    do {
      a = a*10 + *((*fmt)++) - '0';
    } while (isdigit(**fmt));
    return a;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x1f550
movq (%rax), %rdx
movq (%rbx), %rcx
movsbq (%rcx), %rsi
testb $0x8, 0x1(%rdx,%rsi,2)
je 0x78d3a
incq %rcx
xorl %r14d, %r14d
leal (%r14,%r14,4), %edx
movq %rcx, (%rbx)
movsbl -0x1(%rcx), %esi
leal (%rsi,%rdx,2), %r14d
addl $-0x30, %r14d
movq (%rax), %rdx
movsbq (%rcx), %rsi
incq %rcx
testb $0x8, 0x1(%rdx,%rsi,2)
jne 0x78d16
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cmsgpack.c
// Function: luaopen_cmsgpack
LUALIB_API int luaopen_cmsgpack (lua_State *L) {
    luaL_register(L, "cmsgpack", thislib);

    lua_pushliteral(L, LUACMSGPACK_VERSION);
    lua_setfield(L, -2, "_VERSION");
    lua_pushliteral(L, LUACMSGPACK_COPYRIGHT);
    lua_setfield(L, -2, "_COPYRIGHT");
    lua_pushliteral(L, LUACMSGPACK_DESCRIPTION);
    lua_setfield(L, -2, "_DESCRIPTION"); 
    return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x246c8(%rip), %rsi     # 0x9d92e
leaq 0x4b433(%rip), %rdx     # 0xc46a0
callq 0x714d1
leaq 0x29653(%rip), %rsi     # 0xa28cc
movl $0x12, %edx
movq %rbx, %rdi
callq 0x6625e
leaq 0x2862a(%rip), %rdx     # 0xa18b7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x666cf
leaq 0x2963e(%rip), %rsi     # 0xa28df
movl $0x28, %edx
movq %rbx, %rdi
callq 0x6625e
leaq 0x29653(%rip), %rdx     # 0xa2908
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x666cf
leaq 0x2964a(%rip), %rsi     # 0xa2913
movl $0x24, %edx
movq %rbx, %rdi
callq 0x6625e
leaq 0x2965b(%rip), %rdx     # 0xa2938
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x666cf
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cmsgpack.c
// Function: mp_pack
static int mp_pack(lua_State *L) {
    mp_buf *buf = mp_buf_new();

    mp_encode_lua_type(L,buf,0);
    lua_pushlstring(L,(char*)buf->b,buf->len);
    mp_buf_free(buf);
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x1f950
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x79414
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x6625e
movq (%r14), %rdi
callq 0x1f4d0
movq %r14, %rdi
callq 0x1f4d0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cmsgpack.c
// Function: mp_unpack
static int mp_unpack(lua_State *L) {
    size_t len;
    const unsigned char *s;
    mp_cur *c;

    if (!lua_isstring(L,-1)) {
        lua_pushstring(L,"MessagePack decoding needs a string as input.");
        lua_error(L);
    }

    s = (const unsigned char*) lua_tolstring(L,-1,&len);
    c = mp_cur_new(s,len);
    mp_decode_to_lua_type(L,c);
    
    if (c->err == MP_CUR_ERROR_EOF) {
        mp_cur_free(c);
        lua_pushstring(L,"Missing bytes in input.");
        lua_error(L);
    } else if (c->err == MP_CUR_ERROR_BADFMT) {
        mp_cur_free(c);
        lua_pushstring(L,"Bad data format in input.");
        lua_error(L);
    } else if (c->left != 0) {
        mp_cur_free(c);
        lua_pushstring(L,"Extra bytes in input.");
        lua_error(L);
    }
    mp_cur_free(c);
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x65ed8
testl %eax, %eax
jne 0x79373
leaq 0x295e2(%rip), %rsi     # 0xa2945
movq %rbx, %rdi
callq 0x662b5
movq %rbx, %rdi
callq 0x66bbd
movq %rsp, %r14
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x6608c
movq %rax, %r15
movq (%r14), %r12
movl $0x18, %edi
callq 0x1f350
movq %rax, %r14
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x78e1d
movl 0x10(%r14), %eax
cmpl $0x1, %eax
je 0x793c9
cmpl $0x2, %eax
jne 0x793d2
leaq 0x295c4(%rip), %r15     # 0xa298b
jmp 0x793e0
leaq 0x295a3(%rip), %r15     # 0xa2973
jmp 0x793e0
cmpq $0x0, 0x8(%r14)
je 0x793fb
leaq 0x295c5(%rip), %r15     # 0xa29a5
movq %r14, %rdi
callq 0x1f4d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x662b5
movq %rbx, %rdi
callq 0x66bbd
movq %r14, %rdi
callq 0x1f4d0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: arenas_extend
arena_t *
arenas_extend(unsigned ind)
{
	arena_t *ret;

	ret = (arena_t *)base_alloc(sizeof(arena_t));
	if (ret != NULL && arena_new(ret, ind) == false) {
		arenas[ind] = ret;
		return (ret);
	}
	/* Only reached if there is an OOM error. */

	/*
	 * OOM here is quite inconvenient to propagate, since dealing with it
	 * would require a check for failure in the fast path.  Instead, punt
	 * by using arenas[0].  In practice, this is an extremely unlikely
	 * failure.
	 */
	malloc_write("<jemalloc>: Error initializing arena\n");
	if (opt_abort)
		abort();

	return (arenas[0]);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x11c0, %edi           # imm = 0x11C0
callq 0x85494
testq %rax, %rax
je 0x7c49d
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
callq 0x82cf3
testb %al, %al
je 0x7c4be
leaq 0x26b08(%rip), %rdi     # 0xa2fac
callq 0x915d4
cmpb $0x1, 0x626aa(%rip)     # 0xdeb5a
je 0x7c4d5
movq 0x626bf(%rip), %rax     # 0xdeb78
movq (%rax), %rbx
jmp 0x7c4cb
movq 0x626b3(%rip), %rax     # 0xdeb78
movl %ebp, %ecx
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: choose_arena_hard
arena_t *
choose_arena_hard(void)
{
	arena_t *ret;

	if (narenas_auto > 1) {
		unsigned i, choose, first_null;

		choose = 0;
		first_null = narenas_auto;
		malloc_mutex_lock(&arenas_lock);
		assert(arenas[0] != NULL);
		for (i = 1; i < narenas_auto; i++) {
			if (arenas[i] != NULL) {
				/*
				 * Choose the first arena that has the lowest
				 * number of threads assigned to it.
				 */
				if (arenas[i]->nthreads <
				    arenas[choose]->nthreads)
					choose = i;
			} else if (first_null == narenas_auto) {
				/*
				 * Record the index of the first uninitialized
				 * arena, in case all extant arenas are in use.
				 *
				 * NB: It is possible for there to be
				 * discontinuities in terms of initialized
				 * versus uninitialized arenas, due to the
				 * "thread.arena" mallctl.
				 */
				first_null = i;
			}
		}

		if (arenas[choose]->nthreads == 0
		    || first_null == narenas_auto) {
			/*
			 * Use an unloaded arena, or the least loaded arena if
			 * all arenas are already initialized.
			 */
			ret = arenas[choose];
		} else {
			/* Initialize a new arena. */
			ret = arenas_extend(first_null);
		}
		ret->nthreads++;
		malloc_mutex_unlock(&arenas_lock);
	} else {
		ret = arenas[0];
		malloc_mutex_lock(&arenas_lock);
		ret->nthreads++;
		malloc_mutex_unlock(&arenas_lock);
	}

	arenas_tsd_set(&ret);

	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x6269c(%rip), %ebx     # 0xdeb80
cmpl $0x2, %ebx
jb 0x7c55e
leaq 0x62698(%rip), %rdi     # 0xdeb88
callq 0x1faa0
movl 0x62685(%rip), %eax     # 0xdeb80
xorl %edx, %edx
movq 0x62674(%rip), %rcx     # 0xdeb78
cmpq $0x2, %rax
jb 0x7c53f
movl $0x1, %esi
movq (%rcx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x7c530
movl 0x4(%rdi), %r8d
movl %edx, %edi
movq (%rcx,%rdi,8), %r9
movl %esi, %edi
cmpl 0x4(%r9), %r8d
jb 0x7c52c
movl %edx, %edi
movl %edi, %edx
jmp 0x7c535
cmpl %eax, %ebx
cmovel %esi, %ebx
incq %rsi
cmpq %rsi, %rax
jne 0x7c50f
movl %edx, %edx
movq (%rcx,%rdx,8), %r14
movl 0x4(%r14), %ecx
testl %ecx, %ecx
je 0x7c578
cmpl %eax, %ebx
je 0x7c578
movl %ebx, %edi
callq 0x7c478
movq %rax, %r14
movl 0x4(%rax), %ecx
jmp 0x7c578
movq 0x62613(%rip), %rax     # 0xdeb78
movq (%rax), %r14
leaq 0x62619(%rip), %rdi     # 0xdeb88
callq 0x1faa0
movl 0x4(%r14), %ecx
incl %ecx
movl %ecx, 0x4(%r14)
leaq 0x62603(%rip), %rdi     # 0xdeb88
callq 0x1fbb0
movq %fs:0x0, %rax
leaq -0x30(%rax), %rsi
movq %r14, %fs:-0x30
movl 0x6260b(%rip), %edi     # 0xdebb4
callq 0x1f1c0
testl %eax, %eax
je 0x7c5c7
leaq 0x26a19(%rip), %rdi     # 0xa2fd2
callq 0x915d4
cmpb $0x1, 0x62595(%rip)     # 0xdeb5a
je 0x7c5d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: arenas_cleanup
void
arenas_cleanup(void *arg)
{
	arena_t *arena = *(arena_t **)arg;

	malloc_mutex_lock(&arenas_lock);
	arena->nthreads--;
	malloc_mutex_unlock(&arenas_lock);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
leaq 0x625a3(%rip), %rbx     # 0xdeb88
movq %rbx, %rdi
callq 0x1faa0
decl 0x4(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1fbb0
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_posix_memalign
int
je_posix_memalign(void **memptr, size_t alignment, size_t size)
{
	int ret = imemalign(memptr, alignment, size, sizeof(void *));
	JEMALLOC_VALGRIND_MALLOC(ret == 0, *memptr, isalloc(*memptr,
	    config_prof), false);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movl $0x8, %ecx
callq 0x7d65e
movl %eax, %ebx
testl %eax, %eax
sete %al
andb 0x6164f(%rip), %al      # 0xdeb6a
cmpb $0x1, %al
jne 0x7d652
movq $0x1301, 0x10(%rsp)     # imm = 0x1301
movq (%r14), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x62345(%rip), %r15     # 0xdf880
movq (%r15), %rcx
notq %rcx
movq %rcx, %rax
andq %rdi, %rax
movq %rdi, %rdx
subq %rax, %rdx
je 0x7d57e
shrq $0xc, %rdx
leaq 0x623ce(%rip), %rsi     # 0xdf928
subq (%rsi), %rdx
leaq (%rdx,%rdx,2), %rdx
movq 0x40(%rax,%rdx,8), %rax
movl %eax, %edx
shrl $0x4, %edx
movl $0xff, %esi
andl %esi, %edx
cmpl %esi, %edx
jne 0x7d58b
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7d59a
callq 0x8be94
movq (%r15), %rcx
notq %rcx
jmp 0x7d59a
imulq $0x68, %rdx, %rax
leaq 0x6166a(%rip), %rdx     # 0xdec00
movq (%rdx,%rax), %rax
movq %rax, 0x20(%rsp)
movq (%r14), %rdi
andq %rdi, %rcx
movq %rdi, %rax
subq %rcx, %rax
je 0x7d5dc
shrq $0xc, %rax
leaq 0x62370(%rip), %rdx     # 0xdf928
subq (%rdx), %rax
leaq (%rax,%rax,2), %rax
movq 0x40(%rcx,%rax,8), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7d5e3
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7d5f2
callq 0x8be94
jmp 0x7d5f2
imulq $0x68, %rcx, %rax
leaq 0x61612(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
cmpq $0xe00, %rax            # imm = 0xE00
ja 0x7d61e
decq %rax
shrq $0x3, %rax
leaq 0x25bb8(%rip), %rcx     # 0xa31c0
movzbl (%rcx,%rax), %eax
imulq $0x68, %rax, %rax
leaq 0x615e9(%rip), %rcx     # 0xdec00
movq 0x8(%rcx,%rax), %rcx
jmp 0x7d620
xorl %ecx, %ecx
leaq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_aligned_alloc
void *
je_aligned_alloc(size_t alignment, size_t size)
{
	void *ret;
	int err;

	if ((err = imemalign(&ret, alignment, size, 1)) != 0) {
		ret = NULL;
		set_errno(err);
	}
	JEMALLOC_VALGRIND_MALLOC(err == 0, ret, isalloc(ret, config_prof),
	    false);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rdi
movl $0x1, %ecx
callq 0x7d65e
testl %eax, %eax
je 0x7d837
movl %eax, %ebx
callq 0x1f810
movl %ebx, (%rax)
xorl %ebx, %ebx
jmp 0x7d97c
cmpb $0x0, 0x6132c(%rip)     # 0xdeb6a
je 0x7d899
movq $0x1301, 0x10(%rsp)     # imm = 0x1301
movq (%rsp), %rbx
movq %rbx, 0x18(%rsp)
leaq 0x62027(%rip), %r14     # 0xdf880
movq (%r14), %rcx
notq %rcx
andq %rbx, %rcx
movq %rbx, %rax
subq %rcx, %rax
je 0x7d8a2
shrq $0xc, %rax
leaq 0x620b3(%rip), %rdx     # 0xdf928
subq (%rdx), %rax
leaq (%rax,%rax,2), %rax
movq 0x40(%rcx,%rax,8), %rax
movl %eax, %edx
shrl $0x4, %edx
movl $0xff, %esi
andl %esi, %edx
cmpl %esi, %edx
jne 0x7d8b5
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7d8c4
movq (%rsp), %rbx
jmp 0x7d97c
movq %rbx, %rdi
callq 0x8be94
movq (%r14), %rcx
notq %rcx
andq %rbx, %rcx
jmp 0x7d8c4
imulq $0x68, %rdx, %rax
leaq 0x61340(%rip), %rdx     # 0xdec00
movq (%rdx,%rax), %rax
movq %rax, 0x20(%rsp)
cmpq %rcx, %rbx
je 0x7d903
movq %rbx, %rax
subq %rcx, %rax
shrq $0xc, %rax
leaq 0x62049(%rip), %rdx     # 0xdf928
subq (%rdx), %rax
leaq (%rax,%rax,2), %rax
movq 0x40(%rcx,%rax,8), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7d90d
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7d91c
movq %rbx, %rdi
callq 0x8be94
jmp 0x7d91c
imulq $0x68, %rcx, %rax
leaq 0x612e8(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
cmpq $0xe00, %rax            # imm = 0xE00
ja 0x7d948
decq %rax
shrq $0x3, %rax
leaq 0x2588e(%rip), %rcx     # 0xa31c0
movzbl (%rcx,%rax), %eax
imulq $0x68, %rax, %rax
leaq 0x612bf(%rip), %rcx     # 0xdec00
movq 0x8(%rcx,%rax), %rcx
jmp 0x7d94a
xorl %ecx, %ecx
leaq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_free
void
je_free(void *ptr)
{

	UTRACE(ptr, 0, 0);
	if (ptr != NULL) {
		size_t usize;
		size_t rzsize JEMALLOC_CC_SILENCE_INIT(0);

		assert(malloc_initialized || IS_INITIALIZER);

		if (config_prof && opt_prof) {
			usize = isalloc(ptr, config_prof);
			prof_free(ptr, usize);
		} else if (config_stats || config_valgrind)
			usize = isalloc(ptr, config_prof);
		if (config_stats)
			thread_allocated_tsd_get()->deallocated += usize;
		if (config_valgrind && opt_valgrind)
			rzsize = p2rz(ptr);
		iqalloc(ptr);
		JEMALLOC_VALGRIND_FREE(ptr, rzsize);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x7e2f3
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x6171e(%rip), %r14     # 0xdf880
movq (%r14), %rax
notq %rax
andq %rdi, %rax
cmpq %rdi, %rax
je 0x7e1a5
movq %rbx, %rcx
subq %rax, %rcx
shrq $0xc, %rcx
leaq 0x617a7(%rip), %rdx     # 0xdf928
subq (%rdx), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x40(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7e1af
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7e1be
movq %rbx, %rdi
callq 0x8be94
jmp 0x7e1be
imulq $0x68, %rcx, %rax
leaq 0x60a46(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
addq %rax, %fs:-0x20
cmpb $0x1, 0x6099c(%rip)     # 0xdeb6a
jne 0x7e25c
movq (%r14), %rax
notq %rax
andq %rbx, %rax
cmpq %rbx, %rax
je 0x7e217
movq %rbx, %rcx
subq %rax, %rcx
shrq $0xc, %rcx
leaq 0x61735(%rip), %rdx     # 0xdf928
subq (%rdx), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x40(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7e221
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7e230
movq %rbx, %rdi
callq 0x8be94
jmp 0x7e230
imulq $0x68, %rcx, %rax
leaq 0x609d4(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
cmpq $0xe00, %rax            # imm = 0xE00
ja 0x7e25c
decq %rax
shrq $0x3, %rax
leaq 0x24f7a(%rip), %rcx     # 0xa31c0
movzbl (%rcx,%rax), %eax
imulq $0x68, %rax, %rax
leaq 0x609ab(%rip), %rcx     # 0xdec00
movq 0x8(%rcx,%rax), %r15
jmp 0x7e25f
xorl %r15d, %r15d
cmpq $0x0, 0x608f9(%rip)     # 0xdeb60
je 0x7e273
movq %rbx, %rdi
callq 0x8da50
jmp 0x7e2a0
movq (%r14), %rsi
notq %rsi
andq %rbx, %rsi
cmpq %rbx, %rsi
je 0x7e293
movq (%rsi), %rdi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x7f86f
jmp 0x7e2a0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8bdfd
cmpb $0x1, 0x608c3(%rip)     # 0xdeb6a
jne 0x7e2ea
leaq 0x10(%rsp), %rax
movq $0x1302, (%rax)         # imm = 0x1302
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_memalign
void *
je_memalign(size_t alignment, size_t size)
{
	void *ret JEMALLOC_CC_SILENCE_INIT(NULL);
	imemalign(&ret, alignment, size, 1);
	JEMALLOC_VALGRIND_MALLOC(ret != NULL, ret, size, false);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7d65e
movq (%rbx), %rax
movq %rax, %rbx
testq %rax, %rax
setne %cl
andb 0x6083b(%rip), %cl      # 0xdeb6a
cmpb $0x1, %cl
jne 0x7e406
movq $0x1301, 0x10(%rsp)     # imm = 0x1301
movq %rbx, 0x18(%rsp)
movq %r14, 0x20(%rsp)
leaq 0x6152e(%rip), %rcx     # 0xdf880
movq (%rcx), %rcx
notq %rcx
andq %rax, %rcx
subq %rcx, %rax
je 0x7e38f
shrq $0xc, %rax
leaq 0x615bd(%rip), %rdx     # 0xdf928
subq (%rdx), %rax
leaq (%rax,%rax,2), %rax
movq 0x40(%rcx,%rax,8), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7e399
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7e3a8
movq %rbx, %rdi
callq 0x8be94
jmp 0x7e3a8
imulq $0x68, %rcx, %rax
leaq 0x6085c(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
cmpq $0xe00, %rax            # imm = 0xE00
ja 0x7e3d4
decq %rax
shrq $0x3, %rax
leaq 0x24e02(%rip), %rcx     # 0xa31c0
movzbl (%rcx,%rax), %eax
imulq $0x68, %rax, %rax
leaq 0x60833(%rip), %rcx     # 0xdec00
movq 0x8(%rcx,%rax), %rcx
jmp 0x7e3d6
xorl %ecx, %ecx
leaq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, (%rsp)
movq (%rsp), %rax
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_valloc
void *
je_valloc(size_t size)
{
	void *ret JEMALLOC_CC_SILENCE_INIT(NULL);
	imemalign(&ret, PAGE, size, 1);
	JEMALLOC_VALGRIND_MALLOC(ret != NULL, ret, size, false);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7d65e
movq (%rbx), %rax
movq %rax, %rbx
testq %rax, %rax
setne %cl
andb 0x6071c(%rip), %cl      # 0xdeb6a
cmpb $0x1, %cl
jne 0x7e525
movq $0x1301, 0x10(%rsp)     # imm = 0x1301
movq %rbx, 0x18(%rsp)
movq %r14, 0x20(%rsp)
leaq 0x6140f(%rip), %rcx     # 0xdf880
movq (%rcx), %rcx
notq %rcx
andq %rax, %rcx
subq %rcx, %rax
je 0x7e4ae
shrq $0xc, %rax
leaq 0x6149e(%rip), %rdx     # 0xdf928
subq (%rdx), %rax
leaq (%rax,%rax,2), %rax
movq 0x40(%rcx,%rax,8), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7e4b8
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7e4c7
movq %rbx, %rdi
callq 0x8be94
jmp 0x7e4c7
imulq $0x68, %rcx, %rax
leaq 0x6073d(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
cmpq $0xe00, %rax            # imm = 0xE00
ja 0x7e4f3
decq %rax
shrq $0x3, %rax
leaq 0x24ce3(%rip), %rcx     # 0xa31c0
movzbl (%rcx,%rax), %eax
imulq $0x68, %rax, %rax
leaq 0x60714(%rip), %rcx     # 0xdec00
movq 0x8(%rcx,%rax), %rcx
jmp 0x7e4f5
xorl %ecx, %ecx
leaq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, (%rsp)
movq (%rsp), %rax
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_malloc_usable_size
size_t
je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr)
{
	size_t ret;

	assert(malloc_initialized || IS_INITIALIZER);

	if (config_ivsalloc)
		ret = ivsalloc(ptr, config_prof);
	else
		ret = (ptr != NULL) ? isalloc(ptr, config_prof) : 0;

	return (ret);
}

// Assembly:
testq %rdi, %rdi
je 0x7e57f
leaq 0x61344(%rip), %rax     # 0xdf880
movq (%rax), %rax
notq %rax
andq %rdi, %rax
cmpq %rdi, %rax
je 0x8be94
subq %rax, %rdi
shrq $0xc, %rdi
leaq 0x613cc(%rip), %rcx     # 0xdf928
subq (%rcx), %rdi
leaq (%rdi,%rdi,2), %rcx
movq 0x40(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7e582
andq $-0x1000, %rax          # imm = 0xF000
retq
xorl %eax, %eax
retq
imulq $0x68, %rcx, %rax
leaq 0x60673(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_sallocm
int
je_sallocm(const void *ptr, size_t *rsize, int flags)
{
	size_t sz;

	assert(malloc_initialized || IS_INITIALIZER);

	if (config_ivsalloc)
		sz = ivsalloc(ptr, config_prof);
	else {
		assert(ptr != NULL);
		sz = isalloc(ptr, config_prof);
	}
	assert(rsize != NULL);
	*rsize = sz;

	return (ALLOCM_SUCCESS);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x605d8(%rip), %rax     # 0xdf880
movq (%rax), %rax
notq %rax
andq %rdi, %rax
cmpq %rdi, %rax
je 0x7f2e8
subq %rax, %rdi
shrq $0xc, %rdi
leaq 0x60664(%rip), %rcx     # 0xdf928
subq (%rcx), %rdi
leaq (%rdi,%rdi,2), %rcx
movq 0x40(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7f2ef
andq $-0x1000, %rax          # imm = 0xF000
jmp 0x7f2fe
callq 0x8be94
jmp 0x7f2fe
imulq $0x68, %rcx, %rax
leaq 0x5f906(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_nallocm
int
je_nallocm(size_t *rsize, size_t size, int flags)
{
	size_t usize;
	size_t alignment = (ZU(1) << (flags & ALLOCM_LG_ALIGN_MASK)
	    & (SIZE_T_MAX-1));

	assert(size != 0);

	if (malloc_init())
		return (ALLOCM_ERR_OOM);

	usize = (alignment == 0) ? s2u(size) : sa2u(size, alignment);
	if (usize == 0)
		return (ALLOCM_ERR_OOM);

	if (rsize != NULL)
		*rsize = usize;
	return (ALLOCM_SUCCESS);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ecx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %r12d
shlq %cl, %r12
movl $0x1, %ebx
callq 0x7c7b5
testb %al, %al
jne 0x7f629
andq $-0x2, %r12
je 0x7f564
leaq (%r15,%r12), %rcx
decq %rcx
movq %r12, %rax
negq %rax
andq %rcx, %rax
cmpq %r15, %rax
jb 0x7f629
leaq 0x60405(%rip), %rcx     # 0xdf930
movq (%rcx), %rcx
cmpq %rcx, %rax
seta %dl
cmpq $0x1001, %r12           # imm = 0x1001
setae %sil
orb %dl, %sil
jne 0x7f5b5
cmpq $0xe00, %rax            # imm = 0xE00
ja 0x7f60e
decq %rax
shrq $0x3, %rax
leaq 0x23c62(%rip), %rcx     # 0xa31c0
movzbl (%rcx,%rax), %eax
jmp 0x7f580
cmpq $0xe00, %r15            # imm = 0xE00
ja 0x7f594
decq %r15
shrq $0x3, %r15
leaq 0x23c45(%rip), %rax     # 0xa31c0
movzbl (%rax,%r15), %eax
imulq $0x68, %rax, %rax
leaq 0x5f675(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rax
jmp 0x7f61a
leaq 0x60395(%rip), %rax     # 0xdf930
cmpq %r15, (%rax)
jae 0x7f5fb
leaq 0x602d9(%rip), %rax     # 0xdf880
movq (%rax), %rax
addq %rax, %r15
notq %rax
andq %r15, %rax
jmp 0x7f61a
leaq 0xfff(%r15), %rax
andq $-0x1000, %rax          # imm = 0xF000
cmpq %r15, %rax
jb 0x7f629
addq $0xfff, %r12            # imm = 0xFFF
andq $-0x1000, %r12          # imm = 0xF000
addq %rax, %r12
jb 0x7f629
addq $-0x1000, %r12          # imm = 0xF000
cmpq %rcx, %r12
jbe 0x7f61a
leaq 0x60293(%rip), %rcx     # 0xdf880
movq (%rcx), %rcx
addq %rcx, %rax
notq %rcx
andq %rcx, %rax
jmp 0x7f61a
addq $0xfff, %r15            # imm = 0xFFF
andq $-0x1000, %r15          # imm = 0xF000
movq %r15, %rax
jmp 0x7f61a
addq $0xfff, %rax            # imm = 0xFFF
andq $-0x1000, %rax          # imm = 0xF000
testq %rax, %rax
je 0x7f629
xorl %ebx, %ebx
testq %r14, %r14
je 0x7f629
movq %rax, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: a0alloc
static void *
a0alloc(size_t size, bool zero)
{

	if (malloc_init())
		return (NULL);

	if (size == 0)
		size = 1;

	if (size <= arena_maxclass)
		return (arena_malloc(arenas[0], size, zero, false));
	else
		return (huge_malloc(size, zero));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
callq 0x7c7b5
testb %al, %al
je 0x7f778
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x1, %r15
movq %r15, %r14
adcq $0x0, %r14
leaq 0x601a6(%rip), %rax     # 0xdf930
cmpq (%rax), %r14
jbe 0x7f79f
movzbl %bl, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8b91c
movq 0x5f3d2(%rip), %rax     # 0xdeb78
movq (%rax), %rdi
cmpq $0xe00, %r15            # imm = 0xE00
ja 0x7f7dd
testq %rdi, %rdi
jne 0x7f7cd
movq %fs:-0x30, %rdi
testq %rdi, %rdi
jne 0x7f7cd
callq 0x7c4da
movq %rax, %rdi
movzbl %bl, %edx
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x80c45
testq %rdi, %rdi
jne 0x7f7f8
movq %fs:-0x30, %rdi
testq %rdi, %rdi
jne 0x7f7f8
callq 0x7c4da
movq %rax, %rdi
movzbl %bl, %edx
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x80ebe
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: a0free
void
a0free(void *ptr)
{
	arena_chunk_t *chunk;

	if (ptr == NULL)
		return;

	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
	if (chunk != ptr)
		arena_dalloc(chunk->arena, chunk, ptr, false);
	else
		huge_dalloc(ptr, true);
}

// Assembly:
testq %rdi, %rdi
je 0x7f861
movq %rdi, %rdx
leaq 0x6005b(%rip), %rax     # 0xdf880
movq (%rax), %rsi
notq %rsi
andq %rdi, %rsi
cmpq %rdi, %rsi
je 0x7f862
movq %rdx, %rcx
subq %rsi, %rcx
shrq $0xc, %rcx
leaq 0x600e4(%rip), %rax     # 0xdf928
movq %rcx, %r8
subq (%rax), %r8
movq (%rsi), %rdi
leaq (%r8,%r8,2), %rax
testb $0x2, 0x40(%rsi,%rax,8)
je 0x817a1
jmp 0x81c48
retq
movq %rdx, %rdi
movl $0x1, %esi
jmp 0x8bdfd