LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/blocked.c
// Function: processUnblockedClients
void processUnblockedClients(void) {
    listNode *ln;
    redisClient *c;

    while (listLength(server.unblocked_clients)) {
        ln = listFirst(server.unblocked_clients);
        redisAssert(ln != NULL);
        c = ln->value;
        listDelNode(server.unblocked_clients,ln);
        c->flags &= ~REDIS_UNBLOCKED;
        c->btype = REDIS_BLOCKED_NONE;

        /* Process remaining data in the input buffer. */
        if (c->querybuf && sdslen(c->querybuf) > 0) {
            server.current_client = c;
            processInputBuffer(c);
            server.current_client = NULL;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x91a69(%rip), %rax     # 0x1138f8
movq 0x738(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x81f78
leaq 0x91a50(%rip), %rax     # 0x1138f8
movq 0x738(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x81ebf
jmp 0x81ee1
leaq 0x611b3(%rip), %rdi     # 0xe3079
leaq 0x68287(%rip), %rsi     # 0xea154
movl $0x74, %edx
callq 0x63ca0
movl $0x1, %edi
callq 0x1f3b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x91a04(%rip), %rax     # 0x1138f8
movq 0x738(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x20170
movq -0x10(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x118(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x81f73
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x81d50
cmpq $0x0, %rax
jbe 0x81f73
movq -0x10(%rbp), %rcx
leaq 0x919a7(%rip), %rax     # 0x1138f8
movq %rcx, 0x1d0(%rax)
movq -0x10(%rbp), %rdi
callq 0x37a50
leaq 0x91990(%rip), %rax     # 0x1138f8
movq $0x0, 0x1d0(%rax)
jmp 0x81e88
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/blocked.c
// Function: unblockClient
void unblockClient(redisClient *c) {
    if (c->btype == REDIS_BLOCKED_LIST) {
        unblockClientWaitingData(c);
    } else if (c->btype == REDIS_BLOCKED_WAIT) {
        unblockClientWaitingReplicas(c);
    } else {
        redisPanic("Unknown btype in unblockClient().");
    }
    /* Clear the flags, and put the client in the unblocked list so that
     * we'll process new commands in its query buffer ASAP. */
    c->flags &= ~REDIS_BLOCKED;
    c->flags |= REDIS_UNBLOCKED;
    c->btype = REDIS_BLOCKED_NONE;
    server.bpop_blocked_clients--;
    listAddNodeTail(server.unblocked_clients,c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x118(%rax)
jne 0x81fa4
movq -0x8(%rbp), %rdi
callq 0x4a2b0
jmp 0x81fe0
movq -0x8(%rbp), %rax
cmpl $0x2, 0x118(%rax)
jne 0x81fbc
movq -0x8(%rbp), %rdi
callq 0x42800
jmp 0x81fde
leaq 0x6819b(%rip), %rdi     # 0xea15e
leaq 0x6818a(%rip), %rsi     # 0xea154
movl $0x8c, %edx
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
jmp 0x81fe0
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x118(%rax)
leaq 0x918da(%rip), %rax     # 0x1138f8
movl 0x730(%rax), %ecx
addl $-0x1, %ecx
leaq 0x918ca(%rip), %rax     # 0x1138f8
movl %ecx, 0x730(%rax)
leaq 0x918bd(%rip), %rax     # 0x1138f8
movq 0x738(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x1ff90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/blocked.c
// Function: replyToBlockedClientTimedOut
void replyToBlockedClientTimedOut(redisClient *c) {
    if (c->btype == REDIS_BLOCKED_LIST) {
        addReply(c,shared.nullmultibulk);
    } else if (c->btype == REDIS_BLOCKED_WAIT) {
        addReplyLongLong(c,replicationCountAcksByOffset(c->bpop.reploffset));
    } else {
        redisPanic("Unknown btype in replyToBlockedClientTimedOut().");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x118(%rax)
jne 0x8208f
movq -0x8(%rbp), %rdi
leaq 0x920cc(%rip), %rax     # 0x114150
movq 0x58(%rax), %rsi
callq 0x35a70
jmp 0x820e6
movq -0x8(%rbp), %rax
cmpl $0x2, 0x118(%rax)
jne 0x820c2
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rdi
callq 0x42670
movq -0x10(%rbp), %rdi
movslq %eax, %rsi
callq 0x36480
jmp 0x820e4
leaq 0x680b9(%rip), %rdi     # 0xea182
leaq 0x68084(%rip), %rsi     # 0xea154
movl $0xa0, %edx
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
jmp 0x820e6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/hyperloglog.c
// Function: isHLLObjectOrReply
int isHLLObjectOrReply(redisClient *c, robj *o) {
    struct hllhdr *hdr;

    /* Key exists, check type */
    if (checkType(c,o,REDIS_STRING))
        return REDIS_ERR; /* Error already sent. */

    if (stringObjectLen(o) < sizeof(*hdr)) goto invalid;
    hdr = o->ptr;

    /* Magic should be "HYLL". */
    if (hdr->magic[0] != 'H' || hdr->magic[1] != 'Y' ||
        hdr->magic[2] != 'L' || hdr->magic[3] != 'L') goto invalid;

    if (hdr->encoding > HLL_MAX_ENCODING) goto invalid;

    /* Dense representation string length should match exactly. */
    if (hdr->encoding == HLL_DENSE &&
        stringObjectLen(o) != HLL_DENSE_SIZE) goto invalid;

    /* All tests passed. */
    return REDIS_OK;

invalid:
    addReplySds(c,
        sdsnew("-WRONGTYPE Key is not a valid "
               "HyperLogLog string value.\r\n"));
    return REDIS_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3abb0
cmpl $0x0, %eax
je 0x840b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x84161
movq -0x18(%rbp), %rdi
callq 0x3b2c0
cmpq $0x10, %rax
jae 0x840c1
jmp 0x8413a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x48, %eax
jne 0x84100
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x59, %eax
jne 0x84100
movq -0x20(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x4c, %eax
jne 0x84100
movq -0x20(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x4c, %eax
je 0x84102
jmp 0x8413a
movq -0x20(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x1, %eax
jle 0x84111
jmp 0x8413a
movq -0x20(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x84131
movq -0x18(%rbp), %rdi
callq 0x3b2c0
cmpq $0x3010, %rax           # imm = 0x3010
je 0x84131
jmp 0x8413a
movl $0x0, -0x4(%rbp)
jmp 0x84161
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x66166(%rip), %rdi     # 0xea2af
callq 0x2c0e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x35c00
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: luaopen_cjson
int luaopen_cjson(lua_State *l)
{
    luaL_Reg reg[] = {
        { "encode", json_encode },
        { "decode", json_decode },
        { "encode_sparse_array", json_cfg_encode_sparse_array },
        { "encode_max_depth", json_cfg_encode_max_depth },
        { "encode_number_precision", json_cfg_encode_number_precision },
        { "encode_keep_buffer", json_cfg_encode_keep_buffer },
        { "refuse_invalid_numbers", json_cfg_refuse_invalid_numbers },
        { NULL, NULL }
    };

    /* Use json_fetch_config as a pointer.
     * It's faster than using a config string, and more unique */
    lua_pushlightuserdata(l, &json_config_key);
    json_create_config(l);
    lua_settable(l, LUA_REGISTRYINDEX);

    luaL_register(l, "cjson", reg);

    /* Set cjson.null */
    lua_pushlightuserdata(l, NULL);
    lua_setfield(l, -2, "null");

    /* Set cjson.version */
    lua_pushliteral(l, VERSION);
    lua_setfield(l, -2, "version");

    /* Return cjson table */
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x90(%rbp), %rdi
leaq 0x65a33(%rip), %rsi     # 0x10d670
movl $0x80, %edx
callq 0x1fbf0
movq -0x8(%rbp), %rdi
leaq 0x8084e(%rip), %rsi     # 0x1284a0
callq 0x8c8e0
movq -0x8(%rbp), %rdi
callq 0xa8220
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x8cdc0
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
leaq 0x3fce9(%rip), %rsi     # 0xe7969
callq 0x9fd50
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8c8e0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x38435(%rip), %rdx     # 0xe00d7
callq 0x8ce20
movq -0x8(%rbp), %rdi
leaq 0x44854(%rip), %rsi     # 0xec506
movl $0x5, %edx
callq 0x8c510
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x38bff(%rip), %rdx     # 0xe08cb
callq 0x8ce20
movl $0x1, %eax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b6c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x1d(%rbp)
je 0xa7d1f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x447fb(%rip), %rdx     # 0xec50c
callq 0x9f400
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
movq -0x8(%rbp), %rdi
callq 0xa8500
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x528(%rax)
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
callq 0xa8570
cmpl $0x0, %eax
je 0xa7d64
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
callq 0xa8590
jmp 0xa7d76
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
xorl %esi, %esi
callq 0xb0ad0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x500, %rdx            # imm = 0x500
callq 0xa85b0
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
leaq -0x1c(%rbp), %rsi
callq 0xa8710
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x8c510
movq -0x10(%rbp), %rax
cmpl $0x0, 0x544(%rax)
jne 0xa7dd4
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
callq 0xb0c30
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xa8eb0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x9f830
movq %rax, -0x10(%rbp)
cmpq $0x2, -0x18(%rbp)
jb 0xa7e3c
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa7e2a
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0xa7e3c
movq -0x8(%rbp), %rdi
leaq 0x44890(%rip), %rsi     # 0xec6c5
movb $0x0, %al
callq 0x9f500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
callq 0xa8f00
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xa8eb0
movq -0x8(%rbp), %rdi
callq 0xa8500
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b6c0
movl %eax, %ecx
movl %ecx, -0x18(%rbp)
subl $0x1, %eax
je 0xa7f4c
jmp 0xa7ea0
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xa7f02
jmp 0xa7eaa
movl -0x18(%rbp), %eax
subl $0x3, %eax
jne 0xa7fa1
jmp 0xa7eb8
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x9fb80
movl %eax, -0x14(%rbp)
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
jge 0xa7ef2
movq -0x8(%rbp), %rdi
movl $0x3, %esi
leaq 0x44a09(%rip), %rdx     # 0xec8ed
callq 0x9f400
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x534(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x9fb80
movl %eax, -0x14(%rbp)
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x1a(%rbp)
jge 0xa7f3c
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x449bf(%rip), %rdx     # 0xec8ed
callq 0x9f400
cmpl $0x0, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x530(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8bc20
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x1b(%rbp)
je 0xa7f84
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x4498d(%rip), %rdx     # 0xec903
callq 0x9f400
cmpl $0x0, %eax
setne %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8c080
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x52c(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x52c(%rax), %esi
callq 0x8c890
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x530(%rax), %rsi
callq 0x8c4c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x534(%rax), %rsi
callq 0x8c4c0
movl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xa8eb0
movq -0x8(%rbp), %rdi
callq 0xa8500
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b6c0
cmpl $0x0, %eax
je 0xa806f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x9fb80
movl %eax, -0x14(%rbp)
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
jg 0xa805f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x448c3(%rip), %rdx     # 0xec914
callq 0x9f400
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x538(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x538(%rax), %rsi
callq 0x8c4c0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xa8eb0
movq -0x8(%rbp), %rdi
callq 0xa8500
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b6c0
cmpl $0x0, %eax
je 0xa8118
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x9fb80
movl %eax, -0x14(%rbp)
movl $0x1, %eax
cmpl -0x14(%rbp), %eax
jg 0xa80eb
movb $0x1, %al
cmpl $0xe, -0x14(%rbp)
movb %al, -0x15(%rbp)
jle 0xa8109
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x44833(%rip), %rdx     # 0xec92e
callq 0x9f400
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa9da0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x548(%rax), %rsi
callq 0x8c4c0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xa8eb0
movq -0x8(%rbp), %rdi
callq 0xa8500
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b6c0
cmpl $0x0, %eax
je 0xa819f
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x9fa00
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8c080
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x544(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x544(%rax), %esi
callq 0x8c890
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xa8eb0
movq -0x8(%rbp), %rdi
callq 0xa8500
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x53c, %rdx            # imm = 0x53C
movq -0x10(%rbp), %rcx
addq $0x540, %rcx            # imm = 0x540
leaq 0x6b658(%rip), %rsi     # 0x113860
callq 0xa9de0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7ff89(%rip), %rsi     # 0x1284a0
callq 0x8c8e0
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x8c980
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8c2e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa8555
movq -0x8(%rbp), %rdi
leaq 0x43fd2(%rip), %rsi     # 0xec520
movb $0x0, %al
callq 0x9f500
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8b6f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8bf90
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x53c(%rax)
je 0xa88b7
movsd -0x28(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0x385ec(%rip), %xmm2    # 0xe0e40
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x385ba(%rip), %xmm1    # 0xe0e30
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
jne 0xa88a0
movsd -0x28(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0xa88a0
jmp 0xa88b7
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x43d7a(%rip), %rcx     # 0xec62c
callq 0xa8cd0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq $0x520, %rdx            # imm = 0x520
movsd -0x28(%rbp), %xmm0
movl $0x20, %esi
movb $0x1, %al
callq 0xb0f50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_append_array
static void json_append_array(lua_State *l, json_config_t *cfg, strbuf_t *json,
                              int array_length)
{
    int comma, i;

    json_encode_descend(l, cfg);

    strbuf_append_char(json, '[');

    comma = 0;
    for (i = 1; i <= array_length; i++) {
        if (comma)
            strbuf_append_char(json, ',');
        else
            comma = 1;

        lua_rawgeti(l, -1, i);
        json_append_data(l, cfg, json);
        lua_pop(l, 1);
    }

    strbuf_append_char(json, ']');

    cfg->current_depth--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa8de0
movq -0x18(%rbp), %rdi
movl $0x5b, %esi
callq 0xa8e60
movl $0x0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0xa8b40
cmpl $0x0, -0x20(%rbp)
je 0xa8afe
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0xa8e60
jmp 0xa8b05
movl $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8cae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa85b0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8b6f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa8ae0
movq -0x18(%rbp), %rdi
movl $0x5d, %esi
callq 0xa8e60
movq -0x10(%rbp), %rax
movl 0x528(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x528(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_append_object
static void json_append_object(lua_State *l, json_config_t *cfg,
                               strbuf_t *json)
{
    int comma, keytype;

    json_encode_descend(l, cfg);

    /* Object */
    strbuf_append_char(json, '{');

    lua_pushnil(l);
    /* table, startkey */
    comma = 0;
    while (lua_next(l, -2) != 0) {
        if (comma)
            strbuf_append_char(json, ',');
        else
            comma = 1;

        /* table, key, value */
        keytype = lua_type(l, -2);
        if (keytype == LUA_TNUMBER) {
            strbuf_append_char(json, '"');
            json_append_number(l, json, -2, cfg);
            strbuf_append_mem(json, "\":", 2);
        } else if (keytype == LUA_TSTRING) {
            json_append_string(l, json, -2);
            strbuf_append_char(json, ':');
        } else {
            json_encode_exception(l, cfg, -2,
                                  "table key must be a number or string");
            /* never returns */
        }

        /* table, key, value */
        json_append_data(l, cfg, json);
        lua_pop(l, 1);
        /* table, key */
    }

    strbuf_append_char(json, '}');

    cfg->current_depth--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa8de0
movq -0x18(%rbp), %rdi
movl $0x7b, %esi
callq 0xa8e60
movq -0x8(%rbp), %rdi
callq 0x8c440
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8d810
cmpl $0x0, %eax
je 0xa8c9c
cmpl $0x0, -0x1c(%rbp)
je 0xa8bdc
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0xa8e60
jmp 0xa8be3
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8bc20
movl %eax, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jne 0xa8c35
movq -0x18(%rbp), %rdi
movl $0x22, %esi
callq 0xa8e60
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0xa8810
movq -0x18(%rbp), %rdi
leaq 0x43a5c(%rip), %rsi     # 0xec685
movl $0x2, %edx
callq 0xa88e0
jmp 0xa8c78
cmpl $0x4, -0x20(%rbp)
jne 0xa8c5d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0xa8740
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0xa8e60
jmp 0xa8c76
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
leaq 0x43a17(%rip), %rcx     # 0xec688
callq 0xa8cd0
jmp 0xa8c78
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa85b0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8b6f0
jmp 0xa8baf
movq -0x18(%rbp), %rdi
movl $0x7d, %esi
callq 0xa8e60
movq -0x10(%rbp), %rax
movl 0x528(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x528(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x544(%rax)
jne 0xa8d04
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
callq 0xb0c30
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8bc20
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x8bc70
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
leaq 0x43970(%rip), %rsi     # 0xec6ad
movb $0x0, %al
callq 0x9f500
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x528(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x528(%rax)
movq -0x10(%rbp), %rax
movl 0x528(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x538(%rcx), %eax
jle 0xa8e52
movq -0x10(%rbp), %rax
cmpl $0x0, 0x544(%rax)
jne 0xa8e36
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
callq 0xb0c30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x528(%rax), %edx
leaq 0x43811(%rip), %rsi     # 0xec65c
movb $0x0, %al
callq 0x9f500
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: lua_json_decode
static void lua_json_decode(lua_State *l, const char *json_text, int json_len)
{
    json_parse_t json;
    json_token_t token;

    json.cfg = json_fetch_config(l);
    json.data = json_text;
    json.index = 0;

    /* Ensure the temporary buffer can hold the entire string.
     * This means we no longer need to do length checks since the decoded
     * string must be smaller than the entire json string */
    json.tmp = strbuf_new(json_len);

    json_next_token(&json, &token);
    json_process_value(l, &json, &token);

    /* Ensure there is no more input left */
    json_next_token(&json, &token);

    if (token.type != T_END)
        json_throw_parse_error(l, &json, "the end", &token);

    strbuf_free(json.tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa8500
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0xb0ba0
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa8fa0
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xa9230
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa8fa0
cmpl $0xa, -0x50(%rbp)
je 0xa8f84
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq 0x43791(%rip), %rdx     # 0xec70c
leaq -0x50(%rbp), %rcx
callq 0xa9300
movq -0x28(%rbp), %rdi
callq 0xb0c30
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0xa95b6
movl $0x1, -0x4(%rbp)
jmp 0xa96b1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0xa95d3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0xa9631
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
orl $0x20, %eax
cmpl $0x78, %eax
je 0xa9619
movl $0x30, %eax
cmpl -0x18(%rbp), %eax
jg 0xa9625
cmpl $0x39, -0x18(%rbp)
jg 0xa9625
movl $0x1, -0x4(%rbp)
jmp 0xa96b1
movl $0x0, -0x4(%rbp)
jmp 0xa96b1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0xa964e
movl $0x0, -0x4(%rbp)
jmp 0xa96b1
jmp 0xa9650
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
leaq 0x37858(%rip), %rsi     # 0xe0ebd
movl $0x3, %edx
callq 0x1f870
cmpl $0x0, %eax
jne 0xa967d
movl $0x1, -0x4(%rbp)
jmp 0xa96b1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
leaq 0x37d3e(%rip), %rsi     # 0xe13d0
movl $0x3, %edx
callq 0x1f870
cmpl $0x0, %eax
jne 0xa96aa
movl $0x1, -0x4(%rbp)
jmp 0xa96b1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x1fc60
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xa9734
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x42ff5(%rip), %rdx     # 0xec722
callq 0xa9380
jmp 0xa974d
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_parse_object_context
static void json_parse_object_context(lua_State *l, json_parse_t *json)
{
    json_token_t token;

    /* 3 slots required:
     * .., table, key, value */
    json_decode_checkstack(l, json, 3);

    lua_newtable(l);

    json_next_token(json, &token);

    /* Handle empty objects */
    if (token.type == T_OBJ_END) {
        return;
    }

    while (1) {
        if (token.type != T_STRING)
            json_throw_parse_error(l, json, "object key string", &token);

        /* Push key */
        lua_pushlstring(l, token.value.string, token.string_len);

        json_next_token(json, &token);
        if (token.type != T_COLON)
            json_throw_parse_error(l, json, "colon", &token);

        /* Fetch value */
        json_next_token(json, &token);
        json_process_value(l, json, &token);

        /* Set key = value */
        lua_rawset(l, -3);

        json_next_token(json, &token);

        if (token.type == T_OBJ_END)
            return;

        if (token.type != T_COMMA)
            json_throw_parse_error(l, json, "comma or object end", &token);

        json_next_token(json, &token);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0xa9d50
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8cb60
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8fa0
cmpl $0x1, -0x28(%rbp)
jne 0xa9bb7
jmp 0xa9c84
jmp 0xa9bb9
cmpl $0x4, -0x28(%rbp)
je 0xa9bd7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x42c13(%rip), %rdx     # 0xec7e1
leaq -0x28(%rbp), %rcx
callq 0xa9300
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x8c510
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8fa0
cmpl $0x8, -0x28(%rbp)
je 0xa9c13
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x42be9(%rip), %rdx     # 0xec7f3
leaq -0x28(%rbp), %rcx
callq 0xa9300
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8fa0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xa9230
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x8cec0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8fa0
cmpl $0x1, -0x28(%rbp)
jne 0xa9c54
jmp 0xa9c84
cmpl $0x9, -0x28(%rbp)
je 0xa9c72
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x42b90(%rip), %rdx     # 0xec7f9
leaq -0x28(%rbp), %rcx
callq 0xa9300
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8fa0
jmp 0xa9bb9
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_parse_array_context
static void json_parse_array_context(lua_State *l, json_parse_t *json)
{
    json_token_t token;
    int i;

    /* 2 slots required:
     * .., table, value */
    json_decode_checkstack(l, json, 2);

    lua_newtable(l);

    json_next_token(json, &token);

    /* Handle empty arrays */
    if (token.type == T_ARR_END)
        return;

    for (i = 1; ; i++) {
        json_process_value(l, json, &token);
        lua_rawseti(l, -2, i);            /* arr[i] = value */

        json_next_token(json, &token);

        if (token.type == T_ARR_END)
            return;

        if (token.type != T_COMMA)
            json_throw_parse_error(l, json, "comma or array end", &token);

        json_next_token(json, &token);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0xa9d50
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8cb60
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8fa0
cmpl $0x3, -0x28(%rbp)
jne 0xa9cd4
jmp 0xa9d48
movl $0x1, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xa9230
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8cf90
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8fa0
cmpl $0x3, -0x28(%rbp)
jne 0xa9d12
jmp 0xa9d48
cmpl $0x9, -0x28(%rbp)
je 0xa9d30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x42b06(%rip), %rdx     # 0xec82d
leaq -0x28(%rbp), %rcx
callq 0xa9300
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8fa0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa9cdb
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_decode_checkstack
static void json_decode_checkstack(lua_State *l, json_parse_t *json, int n)
{
    if (lua_checkstack(l, n))
        return;

    strbuf_free(json->tmp);
    luaL_error(l, "Too many nested data structures");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8b450
cmpl $0x0, %eax
je 0xa9d76
jmp 0xa9d95
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb0c30
movq -0x8(%rbp), %rdi
leaq 0x42a7f(%rip), %rsi     # 0xec80d
movb $0x0, %al
callq 0x9f500
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_enum_option
static void json_enum_option(lua_State *l, const char **options,
                             int *opt1, int *opt2)
{
    int setting;

    if (lua_gettop(l)) {
        if (lua_isboolean(l, 1))
            setting = lua_toboolean(l, 1) * 3;
        else
            setting = luaL_checkoption(l, 1, NULL, options);

        *opt1 = setting & 1 ? 1 : 0;
        *opt2 = setting & 2 ? 1 : 0;
    } else {
        setting = *opt1 | (*opt2 << 1);
    }

    if (setting)
        lua_pushstring(l, options[setting]);
    else
        lua_pushboolean(l, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b6c0
cmpl $0x0, %eax
je 0xa9e7c
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8bc20
cmpl $0x1, %eax
jne 0xa9e2f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8c080
imull $0x3, %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0xa9e48
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9f6d0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
andl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %edx
andl $0x2, %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0xa9e8f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
shll %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xa9eac
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x8c590
jmp 0xa9eb7
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8c890
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x1f530
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xaac6a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xaacba
movl $0x0, -0x18(%rbp)
imull $0xa, -0x18(%rbp), %eax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x18(%rbp)
callq 0x1f530
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xaac71
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cmsgpack.c
// Function: mp_buf_append
void mp_buf_append(mp_buf *buf, const unsigned char *s, size_t len) {
    if (buf->free < len) {
        size_t newlen = buf->len+len;

        buf->b = realloc(buf->b,newlen*2);
        buf->free = newlen;
    }
    memcpy(buf->b+buf->len,s,len);
    buf->len += len;
    buf->free -= len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0xaae4b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
shlq %rsi
callq 0x1fad0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1fbf0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cmsgpack.c
// Function: memrevifle
static void memrevifle(void *ptr, size_t len) {
    unsigned char *p = ptr, *e = p+len-1, aux;
    int test = 1;
    unsigned char *testp = (unsigned char*) &test;

    if (testp[0] == 0) return; /* Big endian, nothign to do. */
    len /= 2;
    while(len--) {
        aux = *p;
        *p = *e;
        *e = aux;
        p++;
        e--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xabb31
jmp 0xabb89
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0xabb89
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xabb3c
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3bdcf(%rip), %rsi     # 0xe7976
leaq 0x61b82(%rip), %rdx     # 0x10d730
callq 0x9fd50
movq -0x8(%rbp), %rdi
leaq 0x4124e(%rip), %rsi     # 0xece0c
movl $0x12, %edx
callq 0x8c510
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x3fe3f(%rip), %rdx     # 0xeba17
callq 0x8ce20
movq -0x8(%rbp), %rdi
leaq 0x41237(%rip), %rsi     # 0xece1f
movl $0x28, %edx
callq 0x8c510
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x41246(%rip), %rdx     # 0xece48
callq 0x8ce20
movq -0x8(%rbp), %rdi
leaq 0x41241(%rip), %rsi     # 0xece53
movl $0x24, %edx
callq 0x8c510
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4124c(%rip), %rdx     # 0xece78
callq 0x8ce20
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)