LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x69196(%rip), %r14     # 0xc9fa8
movq 0x738(%r14), %rdi
cmpq $0x0, 0x28(%rdi)
je 0x60e6d
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x60e75
movq 0x10(%rsi), %rbx
callq 0x20544
andb $0x7f, 0x90(%rbx)
movl $0x0, 0x118(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x60e12
cmpl $0x0, -0x8(%rax)
je 0x60e12
movq %rbx, 0x1d0(%r14)
movq %rbx, %rdi
callq 0x2ece8
movq $0x0, 0x1d0(%r14)
jmp 0x60e12
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x38131(%rip), %rdi     # 0x98fad
leaq 0x3f15d(%rip), %rsi     # 0x9ffe0
movl $0x74, %edx
callq 0x4d037
movl $0x1, %edi
callq 0x1f3b0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x118(%rdi), %eax
cmpl $0x2, %eax
je 0x60eb5
cmpl $0x1, %eax
jne 0x60efa
movq %rbx, %rdi
callq 0x3af0c
jmp 0x60ebd
movq %rbx, %rdi
callq 0x358cf
movl $0xffffff6f, %eax       # imm = 0xFFFFFF6F
andl 0x90(%rbx), %eax
orl $0x80, %eax
movl %eax, 0x90(%rbx)
movl $0x0, 0x118(%rbx)
leaq 0x690c4(%rip), %rax     # 0xc9fa8
decl 0x730(%rax)
movq 0x738(%rax), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x2045f
leaq 0x3f0e9(%rip), %rdi     # 0x9ffea
leaq 0x3f0d8(%rip), %rsi     # 0x9ffe0
movl $0x8c, %edx
callq 0x4d0e5
movl $0x1, %edi
callq 0x1f3b0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x118(%rdi), %eax
cmpl $0x2, %eax
je 0x60f44
cmpl $0x1, %eax
jne 0x60f5c
leaq 0x698c9(%rip), %rax     # 0xca800
movq 0x58(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x2d6f0
movq 0x140(%rbx), %rdi
callq 0x357a0
movslq %eax, %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x2dea3
leaq 0x3f0ab(%rip), %rdi     # 0xa000e
leaq 0x3f076(%rip), %rsi     # 0x9ffe0
movl $0xa0, %edx
callq 0x4d0e5
movl $0x1, %edi
callq 0x1f3b0
nop
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/src/hyperloglog.c
// Function: MurmurHash64A
uint64_t MurmurHash64A (const void * key, int len, unsigned int seed) {
    const uint64_t m = 0xc6a4a7935bd1e995;
    const int r = 47;
    uint64_t h = seed ^ (len * m);
    const uint8_t *data = (const uint8_t *)key;
    const uint8_t *end = data + (len-(len&7));

    while(data != end) {
        uint64_t k;

#if (BYTE_ORDER == LITTLE_ENDIAN)
        k = *((uint64_t*)data);
#else
        k = (uint64_t) data[0];
        k |= (uint64_t) data[1] << 8;
        k |= (uint64_t) data[2] << 16;
        k |= (uint64_t) data[3] << 24;
        k |= (uint64_t) data[4] << 32;
        k |= (uint64_t) data[5] << 40;
        k |= (uint64_t) data[6] << 48;
        k |= (uint64_t) data[7] << 56;
#endif

        k *= m;
        k ^= k >> r;
        k *= m;
        h ^= k;
        h *= m;
        data += 8;
    }

    switch(len & 7) {
    case 7: h ^= (uint64_t)data[6] << 48;
    case 6: h ^= (uint64_t)data[5] << 40;
    case 5: h ^= (uint64_t)data[4] << 32;
    case 4: h ^= (uint64_t)data[3] << 24;
    case 3: h ^= (uint64_t)data[2] << 16;
    case 2: h ^= (uint64_t)data[1] << 8;
    case 1: h ^= (uint64_t)data[0];
            h *= m;
    };

    h ^= h >> r;
    h *= m;
    h ^= h >> r;
    return h;
}

// Assembly:
movabsq $-0x395b586ca42e166b, %rax # imm = 0xC6A4A7935BD1E995
movl %edx, %edx
movslq %esi, %rcx
movq %rcx, %rsi
imulq %rax, %rsi
xorq %rdx, %rsi
movl %ecx, %edx
andl $0x7, %edx
andl $-0x8, %ecx
je 0x60fd1
movslq %ecx, %r8
movq (%rdi), %r9
imulq %rax, %r9
movq %r9, %rcx
shrq $0x2f, %rcx
xorq %r9, %rcx
imulq %rax, %rcx
xorq %rsi, %rcx
imulq %rax, %rcx
addq $0x8, %rdi
movq %rcx, %rsi
addq $-0x8, %r8
jne 0x60fa6
jmp 0x60fd4
movq %rsi, %rcx
movl %edx, %edx
leaq 0x3f067(%rip), %rsi     # 0xa0044
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movzbl 0x6(%rdi), %edx
shlq $0x30, %rdx
xorq %rdx, %rcx
movzbl 0x5(%rdi), %edx
shlq $0x28, %rdx
xorq %rdx, %rcx
movzbl 0x4(%rdi), %edx
shlq $0x20, %rdx
xorq %rdx, %rcx
movzbl 0x3(%rdi), %edx
shll $0x18, %edx
xorq %rdx, %rcx
movzbl 0x2(%rdi), %edx
shll $0x10, %edx
xorq %rdx, %rcx
movzbl 0x1(%rdi), %edx
shll $0x8, %edx
xorq %rdx, %rcx
movzbl (%rdi), %edx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rcx
movq %rcx, %rdx
shrq $0x2f, %rdx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rax
shrq $0x2f, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/src/hyperloglog.c
// Function: hllDenseAdd
int hllDenseAdd(uint8_t *registers, unsigned char *ele, size_t elesize) {
    uint8_t oldcount, count;
    long index;

    /* Update the register if this element produced a longer run of zeroes. */
    count = hllPatLen(ele,elesize,&index);
    HLL_DENSE_GET_REGISTER(oldcount,registers,index);
    if (count > oldcount) {
        HLL_DENSE_SET_REGISTER(registers,index,count);
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x6104b
movq (%r14), %rcx
addq %rcx, %rcx
leaq (%rcx,%rcx,2), %rdx
leaq (%rcx,%rcx,2), %rdi
addq $0x7, %rdi
testq %rdx, %rdx
cmovnsq %rdx, %rdi
sarq $0x3, %rdi
andl $0x6, %edx
movl $0x8, %esi
movzbl (%rbx,%rdi), %r9d
movq %r9, %r11
movl %edx, %ecx
shrq %cl, %r11
subq %rdx, %rsi
movzbl 0x1(%rbx,%rdi), %r8d
movl %r8d, %r10d
movl %esi, %ecx
shll %cl, %r10d
orl %r10d, %r11d
andl $0x3f, %r11d
movzbl %al, %r10d
xorl %eax, %eax
cmpl %r11d, %r10d
jbe 0x6112b
movb $0x3f, %al
movl %edx, %ecx
shlb %cl, %al
movl %r10d, %r10d
notb %al
movq %r10, %r11
shlq %cl, %r11
andb %r9b, %al
orb %al, %r11b
movb %r11b, (%rbx,%rdi)
movl $0xffffffc0, %eax       # imm = 0xFFFFFFC0
movl %esi, %ecx
sarl %cl, %eax
shrq %cl, %r10
andb %r8b, %al
orb %al, %r10b
movb %r10b, 0x1(%rbx,%rdi)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/src/hyperloglog.c
// Function: hllSparseSum
double hllSparseSum(uint8_t *sparse, int sparselen, double *PE, int *ezp, int *invalid) {
    double E = 0;
    int ez = 0, idx = 0, runlen, regval;
    uint8_t *end = sparse+sparselen, *p = sparse;

    while(p < end) {
        if (HLL_SPARSE_IS_ZERO(p)) {
            runlen = HLL_SPARSE_ZERO_LEN(p);
            idx += runlen;
            ez += runlen;
            /* Increment E at the end of the loop. */
            p++;
        } else if (HLL_SPARSE_IS_XZERO(p)) {
            runlen = HLL_SPARSE_XZERO_LEN(p);
            idx += runlen;
            ez += runlen;
            /* Increment E at the end of the loop. */
            p += 2;
        } else {
            runlen = HLL_SPARSE_VAL_LEN(p);
            regval = HLL_SPARSE_VAL_VALUE(p);
            idx += runlen;
            E += PE[regval]*runlen;
            p++;
        }
    }
    if (idx != HLL_REGISTERS && invalid) *invalid = 1;
    E += ez; /* Add 2^0 'ez' times. */
    *ezp = ez;
    return E;
}

// Assembly:
testl %esi, %esi
jle 0x61a0c
pushq %rbx
movslq %esi, %rsi
addq %rdi, %rsi
xorl %eax, %eax
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
movzbl (%rdi), %r11d
movl %r11d, %r10d
andl $-0x40, %r10d
cmpl $0x40, %r10d
je 0x619aa
testl %r10d, %r10d
jne 0x619cd
leal 0x1(%r11), %r10d
addl %r11d, %eax
incl %eax
jmp 0x619ee
andl $0x3f, %r11d
shll $0x8, %r11d
movzbl 0x1(%rdi), %r10d
leal (%r11,%r10), %ebx
addl %r11d, %r10d
incl %r10d
addl %ebx, %eax
incl %eax
movl $0x2, %r11d
jmp 0x619f4
movl %r11d, %r10d
andl $0x3, %r10d
incl %r10d
andl $0x7c, %r11d
xorps %xmm1, %xmm1
cvtsi2sd %r10d, %xmm1
mulsd 0x8(%rdx,%r11,2), %xmm1
addsd %xmm1, %xmm0
movl $0x1, %r11d
addl %r10d, %r9d
addq %r11, %rdi
cmpq %rsi, %rdi
jb 0x61989
cmpl $0x4000, %r9d           # imm = 0x4000
setne %dl
popq %rbx
jmp 0x61a14
xorpd %xmm0, %xmm0
xorl %eax, %eax
movb $0x1, %dl
testq %r8, %r8
je 0x61a24
testb %dl, %dl
je 0x61a24
movl $0x1, (%r8)
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movl %eax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/src/hyperloglog.c
// Function: hllRawSum
double hllRawSum(uint8_t *registers, double *PE, int *ezp) {
    double E = 0;
    int j, ez = 0;
    uint64_t *word = (uint64_t*) registers;
    uint8_t *bytes;

    for (j = 0; j < HLL_REGISTERS/8; j++) {
        if (*word == 0) {
            ez += 8;
        } else {
            bytes = (uint8_t*) word;
            if (bytes[0]) E += PE[bytes[0]]; else ez++;
            if (bytes[1]) E += PE[bytes[1]]; else ez++;
            if (bytes[2]) E += PE[bytes[2]]; else ez++;
            if (bytes[3]) E += PE[bytes[3]]; else ez++;
            if (bytes[4]) E += PE[bytes[4]]; else ez++;
            if (bytes[5]) E += PE[bytes[5]]; else ez++;
            if (bytes[6]) E += PE[bytes[6]]; else ez++;
            if (bytes[7]) E += PE[bytes[7]]; else ez++;
        }
        word++;
    }
    E += ez; /* 2^(-reg[j]) is 1 when m is 0, add it 'ez' times for every
                zero register in the HLL. */
    *ezp = ez;
    return E;
}

// Assembly:
xorl %eax, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq $0x0, (%rdi,%rax,8)
je 0x61a53
movzbl (%rdi,%rax,8), %r8d
testq %r8, %r8
je 0x61a5b
addsd (%rsi,%r8,8), %xmm0
jmp 0x61a5d
addl $0x8, %ecx
jmp 0x61af0
incl %ecx
movzbl 0x1(%rdi,%rax,8), %r8d
testq %r8, %r8
je 0x61a70
addsd (%rsi,%r8,8), %xmm0
jmp 0x61a72
incl %ecx
movzbl 0x2(%rdi,%rax,8), %r8d
testq %r8, %r8
je 0x61a85
addsd (%rsi,%r8,8), %xmm0
jmp 0x61a87
incl %ecx
movzbl 0x3(%rdi,%rax,8), %r8d
testq %r8, %r8
je 0x61a9a
addsd (%rsi,%r8,8), %xmm0
jmp 0x61a9c
incl %ecx
movzbl 0x4(%rdi,%rax,8), %r8d
testq %r8, %r8
je 0x61aaf
addsd (%rsi,%r8,8), %xmm0
jmp 0x61ab1
incl %ecx
movzbl 0x5(%rdi,%rax,8), %r8d
testq %r8, %r8
je 0x61ac4
addsd (%rsi,%r8,8), %xmm0
jmp 0x61ac6
incl %ecx
movzbl 0x6(%rdi,%rax,8), %r8d
testq %r8, %r8
je 0x61ad9
addsd (%rsi,%r8,8), %xmm0
jmp 0x61adb
incl %ecx
movzbl 0x7(%rdi,%rax,8), %r8d
testq %r8, %r8
je 0x61aee
addsd (%rsi,%r8,8), %xmm0
jmp 0x61af0
incl %ecx
incq %rax
cmpl $0x800, %eax            # imm = 0x800
jne 0x61a3a
cvtsi2sd %ecx, %xmm1
addsd %xmm1, %xmm0
movl %ecx, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/src/hyperloglog.c
// Function: hllAdd
int hllAdd(robj *o, unsigned char *ele, size_t elesize) {
    struct hllhdr *hdr = o->ptr;
    switch(hdr->encoding) {
    case HLL_DENSE: return hllDenseAdd(hdr->registers,ele,elesize);
    case HLL_SPARSE: return hllSparseAdd(o,ele,elesize);
    default: return -1; /* Invalid representation. */
    }
}

// Assembly:
movq %rdi, %rax
movq 0x8(%rdi), %rdi
movzbl 0x4(%rdi), %ecx
cmpl $0x1, %ecx
je 0x61ce8
testl %ecx, %ecx
jne 0x61cf0
addq $0x10, %rdi
jmp 0x61087
movq %rax, %rdi
jmp 0x6151e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/src/hyperloglog.c
// Function: hllMerge
int hllMerge(uint8_t *max, robj *hll) {
    struct hllhdr *hdr = hll->ptr;
    int i;

    if (hdr->encoding == HLL_DENSE) {
        uint8_t val;

        for (i = 0; i < HLL_REGISTERS; i++) {
            HLL_DENSE_GET_REGISTER(val,hdr->registers,i);
            if (val > max[i]) max[i] = val;
        }
    } else {
        uint8_t *p = hll->ptr, *end = p + sdslen(hll->ptr);
        long runlen, regval;

        p += HLL_HDR_SIZE;
        i = 0;
        while(p < end) {
            if (HLL_SPARSE_IS_ZERO(p)) {
                runlen = HLL_SPARSE_ZERO_LEN(p);
                i += runlen;
                p++;
            } else if (HLL_SPARSE_IS_XZERO(p)) {
                runlen = HLL_SPARSE_XZERO_LEN(p);
                i += runlen;
                p += 2;
            } else {
                runlen = HLL_SPARSE_VAL_LEN(p);
                regval = HLL_SPARSE_VAL_VALUE(p);
                while(runlen--) {
                    if (regval > max[i]) max[i] = regval;
                    i++;
                }
                p++;
            }
        }
        if (i != HLL_REGISTERS) return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
movq 0x8(%rsi), %rdx
cmpb $0x0, 0x4(%rdx)
je 0x61daa
movslq -0x8(%rdx), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x11, %rcx
jl 0x61de6
addq %rdx, %rcx
addq $0x10, %rdx
xorl %esi, %esi
movzbl (%rdx), %r8d
movl %r8d, %r9d
andl $-0x40, %r9d
cmpl $0x40, %r9d
je 0x61d3f
testl %r9d, %r9d
jne 0x61d5c
addl %r8d, %esi
incl %esi
jmp 0x61d92
andl $0x3f, %r8d
shll $0x8, %r8d
movzbl 0x1(%rdx), %r9d
addl %r8d, %esi
addl %r9d, %esi
incl %esi
movl $0x2, %r8d
jmp 0x61d98
movl %r8d, %r9d
andl $0x3, %r9d
shrl $0x2, %r8d
andl $0x1f, %r8d
leal 0x1(%r8), %r10d
movslq %esi, %r11
addq %rdi, %r11
incq %r9
xorl %ebx, %ebx
movzbl (%r11,%rbx), %ebp
cmpl %ebp, %r8d
jb 0x61d88
movb %r10b, (%r11,%rbx)
incq %rbx
cmpq %rbx, %r9
jne 0x61d7a
addl %ebx, %esi
movl $0x1, %r8d
addq %r8, %rdx
cmpq %rcx, %rdx
jb 0x61d22
cmpl $0x4000, %esi           # imm = 0x4000
je 0x61de4
jmp 0x61de6
xorl %eax, %eax
movl %eax, %ecx
shrl $0x3, %ecx
movzbl 0x10(%rdx,%rcx), %r8d
movzbl 0x11(%rdx,%rcx), %esi
shll $0x8, %esi
orl %r8d, %esi
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %esi
andb $0x3f, %sil
cmpb (%rdi), %sil
jbe 0x61dd5
movb %sil, (%rdi)
addq $0x6, %rax
incq %rdi
cmpq $0x18000, %rax          # imm = 0x18000
jne 0x61dac
xorl %eax, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %edx, %edx
callq 0x308e7
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x61e7c
movq %r14, %rdi
callq 0x30c6f
cmpq $0x10, %rax
jb 0x61e60
movq 0x8(%r14), %rax
cmpb $0x48, (%rax)
jne 0x61e60
cmpb $0x59, 0x1(%rax)
jne 0x61e60
cmpb $0x4c, 0x2(%rax)
jne 0x61e60
cmpb $0x4c, 0x3(%rax)
jne 0x61e60
movb 0x4(%rax), %al
cmpb $0x1, %al
jbe 0x61e83
leaq 0x3e2b6(%rip), %rdi     # 0xa011d
callq 0x281da
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2d894
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
testb %al, %al
jne 0x61e7c
movq %r14, %rdi
callq 0x30c6f
cmpq $0x3010, %rax           # imm = 0x3010
jne 0x61e60
jmp 0x61e7c
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/src/hyperloglog.c
// Function: pfaddCommand
void pfaddCommand(redisClient *c) {
    robj *o = lookupKeyWrite(c->db,c->argv[1]);
    struct hllhdr *hdr;
    int updated = 0, j;

    if (o == NULL) {
        /* Create the key with a string value of the exact length to
         * hold our HLL data structure. sdsnewlen() when NULL is passed
         * is guaranteed to return bytes initialized to zero. */
        o = createHLLObject();
        dbAdd(c->db,c->argv[1],o);
        updated++;
    } else {
        if (isHLLObjectOrReply(c,o) != REDIS_OK) return;
        o = dbUnshareStringValue(c->db,c->argv[1],o);
    }
    /* Perform the low level ADD operation for every element. */
    for (j = 2; j < c->argc; j++) {
        int retval = hllAdd(o, (unsigned char*)c->argv[j]->ptr,
                               sdslen(c->argv[j]->ptr));
        switch(retval) {
        case 1:
            updated++;
            break;
        case -1:
            addReplySds(c,sdsnew(invalid_hll_err));
            return;
        }
    }
    hdr = o->ptr;
    if (updated) {
        signalModifiedKey(c->db,c->argv[1]);
        notifyKeyspaceEvent(REDIS_NOTIFY_STRING,"pfadd",c->argv[1],c->db->id);
        server.dirty++;
        HLL_INVALIDATE_CACHE(hdr);
    }
    addReply(c, updated ? shared.cone : shared.czero);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x31454
testq %rax, %rax
je 0x61ed7
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61e16
testl %eax, %eax
je 0x61efa
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x61de9
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdx
callq 0x314ef
movl $0x1, %ebp
jmp 0x61f13
movq 0x8(%rbx), %rdi
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdx
callq 0x317d7
movq %rax, %r14
xorl %ebp, %ebp
cmpl $0x3, 0x30(%rbx)
jl 0x61f77
movl $0x2, %r12d
leaq 0x3e38d(%rip), %r15     # 0xa02b3
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rsi
movslq -0x8(%rsi), %rdx
movq %r14, %rdi
callq 0x61ccb
cmpl $-0x1, %eax
je 0x61f4e
movb $0x1, %cl
cmpl $0x1, %eax
jne 0x61f63
incl %ebp
jmp 0x61f63
movq %r15, %rdi
callq 0x281da
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2d894
xorl %ecx, %ecx
testb %cl, %cl
je 0x61ece
incq %r12
movslq 0x30(%rbx), %rax
cmpq %rax, %r12
jl 0x61f26
testl %ebp, %ebp
je 0x61fc3
movq 0x8(%r14), %r14
movq 0x8(%rbx), %rdi
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x316b7
movq 0x8(%rbx), %rax
movq 0x38(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x326b3(%rip), %rsi     # 0x94659
movl $0x8, %edi
callq 0x608b5
leaq 0x67ff1(%rip), %rax     # 0xc9fa8
incq 0x560(%rax)
orb $-0x80, 0x8(%r14)
xorl %eax, %eax
testl %ebp, %ebp
setne %al
leaq 0x6882f(%rip), %rcx     # 0xca800
movq 0x20(%rcx,%rax,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d6f0
// File: /workspace/github_c_makefile_star2_O1/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 0x64011
movq 0x8(%rdx), %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
jg 0x6405b
movq (%rdx), %rcx
movabsq $0x20c49ba5e353f7, %rdx # imm = 0x20C49BA5E353F7
cmpq %rdx, %rcx
jge 0x6405b
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 0x64017
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
callq 0x1f810
cmpl $0x73, (%rax)
jne 0x64051
movq %rax, %r12
movq %rsp, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x1f600
testl %eax, %eax
je 0x64049
cmpl $-0x1, %eax
jne 0x64073
leaq 0x3c5b7(%rip), %rsi     # 0xa05fb
movq %r14, %rdi
jmp 0x64056
movl $0x6e, (%r12)
movq %r14, %rdi
xorl %esi, %esi
callq 0x63c24
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 0x63bac
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x64067
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/ldo.c
// Function: luaD_protectedparser
int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
  struct SParser p;
  int status;
  p.z = z; p.name = name;
  luaZ_initbuffer(L, &p.buff);
  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
  luaZ_freebuffer(L, &p.buff);
  return status;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x20(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x18(%r14)
movq 0x10(%rdi), %rcx
movq 0xb0(%rdi), %r8
subq 0x40(%rdi), %rcx
leaq 0x27(%rip), %rsi        # 0x69012
movq %r14, %rdx
callq 0x68e93
movl %eax, %ebp
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x6a93a
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/ldump.c
// Function: luaU_dump
int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
{
 DumpState D;
 D.L=L;
 D.writer=w;
 D.data=data;
 D.strip=strip;
 D.status=0;
 DumpHeader(&D);
 DumpFunction(f,NULL,&D);
 return D.status;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x20(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x6ed94
cmpl $0x0, 0x24(%rsp)
jne 0x6912f
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x2c(%rsp), %rsi
movl $0xc, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x6914d
movl 0x1c(%r14), %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/ldump.c
// Function: DumpString
static void DumpString(const TString* s, DumpState* D)
{
 if (s==NULL || getstr(s)==NULL)
 {
  size_t size=0;
  DumpVar(size,D);
 }
 else
 {
  size_t size=s->tsv.len+1;		/* include trailing '\0' */
  DumpVar(size,D);
  DumpBlock(getstr(s),size,D);
 }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x694d3
movq %rdi, %r14
movq 0x10(%rdi), %rax
incq %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x694b9
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
cmpl $0x0, 0x1c(%rbx)
jne 0x694f6
addq $0x18, %r14
movq (%rsp), %rdx
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %r14, %rsi
jmp 0x694f0
movq $0x0, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x694f6
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lfunc.c
// Function: luaF_newupval
UpVal *luaF_newupval (lua_State *L) {
  UpVal *uv = luaM_new(L, UpVal);
  luaC_link(L, obj2gco(uv), LUA_TUPVAL);
  uv->v = &uv->u.value;
  setnilvalue(uv->v);
  return uv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x28, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x6a93a
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0xa, %edx
callq 0x6a2ce
leaq 0x18(%r14), %rax
movq %rax, 0x10(%r14)
movl $0x0, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lfunc.c
// Function: luaF_findupval
UpVal *luaF_findupval (lua_State *L, StkId level) {
  global_State *g = G(L);
  GCObject **pp = &L->openupval;
  UpVal *p;
  UpVal *uv;
  while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
    lua_assert(p->v != &p->u.value);
    if (p->v == level) {  /* found a corresponding upvalue? */
      if (isdead(g, obj2gco(p)))  /* is it dead? */
        changewhite(obj2gco(p));  /* ressurect it */
      return p;
    }
    pp = &p->next;
  }
  uv = luaM_new(L, UpVal);  /* not found: create a new one */
  uv->tt = LUA_TUPVAL;
  uv->marked = luaC_white(g);
  uv->v = level;  /* current value lives in the stack */
  uv->next = *pp;  /* chain it in the proper position */
  *pp = obj2gco(uv);
  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
  uv->u.l.next = g->uvhead.u.l.next;
  uv->u.l.next->u.l.prev = uv;
  g->uvhead.u.l.next = uv;
  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
  return uv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x20(%rdi), %r14
leaq 0x98(%rdi), %r15
movq (%r15), %rax
testq %rax, %rax
je 0x696a6
cmpq %rbx, 0x10(%rax)
jb 0x696a6
movq %rax, %r15
jne 0x6967b
movb 0x9(%rax), %cl
movb 0x20(%r14), %dl
notb %dl
andb %cl, %dl
testb $0x3, %dl
je 0x696f0
xorb $0x3, %cl
movb %cl, 0x9(%rax)
jmp 0x696f0
movl $0x28, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x6a93a
movb $0xa, 0x8(%rax)
movb 0x20(%r14), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movq %rbx, 0x10(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movq %rax, (%r15)
leaq 0xb8(%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0xd8(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rcx)
movq %rax, 0xd8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lfunc.c
// Function: luaF_newproto
Proto *luaF_newproto (lua_State *L) {
  Proto *f = luaM_new(L, Proto);
  luaC_link(L, obj2gco(f), LUA_TPROTO);
  f->k = NULL;
  f->sizek = 0;
  f->p = NULL;
  f->sizep = 0;
  f->code = NULL;
  f->sizecode = 0;
  f->sizelineinfo = 0;
  f->sizeupvalues = 0;
  f->nups = 0;
  f->upvalues = NULL;
  f->numparams = 0;
  f->is_vararg = 0;
  f->maxstacksize = 0;
  f->lineinfo = NULL;
  f->sizelocvars = 0;
  f->locvars = NULL;
  f->linedefined = 0;
  f->lastlinedefined = 0;
  f->source = NULL;
  return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x78, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x6a93a
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x9, %edx
callq 0x6a2ce
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movq $0x0, 0x60(%r14)
movl $0x0, 0x70(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lfunc.c
// Function: luaF_freeproto
void luaF_freeproto (lua_State *L, Proto *f) {
  luaM_freearray(L, f->code, f->sizecode, Instruction);
  luaM_freearray(L, f->p, f->sizep, Proto *);
  luaM_freearray(L, f->k, f->sizek, TValue);
  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
  luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
  luaM_free(L, f);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
movslq 0x50(%rbx), %rdx
shlq $0x2, %rdx
xorl %ecx, %ecx
callq 0x6a93a
movq 0x20(%rbx), %rsi
movslq 0x58(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6a93a
movq 0x10(%rbx), %rsi
movslq 0x4c(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6a93a
movq 0x28(%rbx), %rsi
movslq 0x54(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6a93a
movq 0x30(%rbx), %rsi
movslq 0x5c(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6a93a
movq 0x38(%rbx), %rsi
movslq 0x48(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6a93a
movl $0x78, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6a93a
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lgc.c
// Function: luaC_freeall
void luaC_freeall (lua_State *L) {
  global_State *g = G(L);
  int i;
  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
  sweepwholelist(L, &g->rootgc);
  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
    sweepwholelist(L, &g->strt.hash[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movb $0x43, 0x20(%r14)
leaq 0x28(%r14), %rsi
movq $-0x3, %rdx
callq 0x69b47
cmpl $0x0, 0xc(%r14)
jle 0x69b3b
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq $-0x3, %rdx
callq 0x69b47
incq %r12
movslq 0xc(%r14), %rax
addq $0x8, %r15
cmpq %rax, %r12
jl 0x69b16
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lgc.c
// Function: luaC_fullgc
void luaC_fullgc (lua_State *L) {
  global_State *g = G(L);
  if (g->gcstate <= GCSpropagate) {
    /* reset sweep marks to sweep all elements (returning them to white) */
    g->sweepstrgc = 0;
    g->sweepgc = &g->rootgc;
    /* reset other collector lists */
    g->gray = NULL;
    g->grayagain = NULL;
    g->weak = NULL;
    g->gcstate = GCSsweepstring;
  }
  lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
  /* finish any pending sweep phase */
  while (g->gcstate != GCSfinalize) {
    lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
    singlestep(L);
  }
  markroot(L);
  while (g->gcstate != GCSpause) {
    singlestep(L);
  }
  setthreshold(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
cmpb $0x1, 0x21(%r14)
ja 0x6a104
movl $0x0, 0x24(%r14)
leaq 0x28(%r14), %rax
movq %rax, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movq $0x0, 0x48(%r14)
movb $0x2, 0x21(%r14)
jmp 0x6a104
movq %rbx, %rdi
callq 0x69d34
cmpb $0x4, 0x21(%r14)
jne 0x6a0fc
movq %rbx, %rdi
callq 0x6a157
cmpb $0x0, 0x21(%r14)
je 0x6a124
movq %rbx, %rdi
callq 0x69d34
jmp 0x6a113
movq 0x80(%r14), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shrq $0x2, %rdx
movslq 0x90(%r14), %rax
imulq %rdx, %rax
movq %rax, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lgc.c
// Function: luaC_barrierf
void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
  global_State *g = G(L);
  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
  lua_assert(ttype(&o->gch) != LUA_TTABLE);
  /* must keep invariant? */
  if (g->gcstate == GCSpropagate)
    reallymarkobject(g, v);  /* restore invariant */
  else  /* don't mind */
    makewhite(g, o);  /* mark as white just to avoid other barriers */
}

// Assembly:
movq 0x20(%rdi), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x6a1ed
movq %rdx, %rsi
jmp 0x6a1fe
movb 0x9(%rsi), %al
andb $-0x8, %al
movb 0x20(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lgc.c
// Function: luaC_link
void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
  global_State *g = G(L);
  o->gch.next = g->rootgc;
  g->rootgc = o;
  o->gch.marked = luaC_white(g);
  o->gch.tt = tt;
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, (%rsi)
movq %rsi, 0x28(%rax)
movb 0x20(%rax), %al
andb $0x3, %al
movb %al, 0x9(%rsi)
movb %dl, 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lgc.c
// Function: luaC_linkupval
void luaC_linkupval (lua_State *L, UpVal *uv) {
  global_State *g = G(L);
  GCObject *o = obj2gco(uv);
  o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
  g->rootgc = o;
  if (isgray(o)) { 
    if (g->gcstate == GCSpropagate) {
      gray2black(o);  /* closed upvalues need barrier */
      luaC_barrier(L, uv, uv->v);
    }
    else {  /* sweep phase: sweep it (turning it into white) */
      makewhite(g, o);
      lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
    }
  }
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, (%rsi)
movq %rsi, 0x28(%rax)
movb 0x9(%rsi), %cl
testb $0x7, %cl
je 0x6a301
retq
cmpb $0x1, 0x21(%rax)
jne 0x6a333
movl %ecx, %eax
orb $0x4, %al
movb %al, 0x9(%rsi)
movq 0x10(%rsi), %rax
cmpl $0x4, 0x8(%rax)
jl 0x6a300
movq (%rax), %rax
testb $0x3, 0x9(%rax)
je 0x6a300
movq 0x20(%rdi), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x6a33e
movq %rax, %rsi
jmp 0x6a1fe
movb 0x20(%rax), %al
andb $0x3, %al
orb %cl, %al
movb %al, 0x9(%rsi)
retq
movb 0x20(%rdi), %al
jmp 0x6a336
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* expoent */
  while (x >= 16) {
    x = (x+1) >> 1;
    e++;
  }
  if (x < 8) return x;
  else return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
movl $0x8, %ecx
cmpl $0x10, %edi
jb 0x6a9b8
incl %edi
movl %edi, %edx
shrl %edx
addl $0x8, %ecx
cmpl $0x1f, %edi
movl %edx, %edi
ja 0x6a9a6
jmp 0x6a9ba
movl %edi, %edx
leal -0x8(%rdx), %eax
orl %ecx, %eax
cmpl $0x8, %edx
cmovbl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lstate.c
// Function: luaE_newthread
lua_State *luaE_newthread (lua_State *L) {
  lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
  luaC_link(L, obj2gco(L1), LUA_TTHREAD);
  preinit_state(L1, G(L));
  stack_init(L1, L);  /* init stack */
  setobj2n(L, gt(L1), gt(L));  /* share table of globals */
  L1->hookmask = L->hookmask;
  L1->basehookcount = L->basehookcount;
  L1->hook = L->hook;
  resethookcount(L1);
  lua_assert(iswhite(obj2gco(L1)));
  return L1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0xb8, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x6a93a
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x6a2ce
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r15, 0x40(%r14)
movl %r15d, 0x58(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%r14)
movw $0x100, 0x64(%r14)      # imm = 0x100
movups %xmm0, 0x68(%r14)
movq %r15, 0x98(%r14)
movb $0x0, 0xa(%r14)
movq %r15, 0x50(%r14)
movl %r15d, 0x80(%r14)
movups %xmm0, 0x28(%r14)
movq %r15, 0x5c(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d3a2
movq 0x78(%rbx), %rax
movq %rax, 0x78(%r14)
movl 0x80(%rbx), %eax
movl %eax, 0x80(%r14)
movb 0x64(%rbx), %al
movb %al, 0x64(%r14)
movl 0x68(%rbx), %eax
movl %eax, 0x68(%r14)
movq 0x70(%rbx), %rcx
movq %rcx, 0x70(%r14)
movl %eax, 0x6c(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lstate.c
// Function: luaE_freethread
void luaE_freethread (lua_State *L, lua_State *L1) {
  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
  lua_assert(L1->openupval == NULL);
  luai_userstatefree(L1);
  freestack(L, L1);
  luaM_freemem(L, fromstate(L1), state_size(lua_State));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rsi), %rsi
movq %rbx, %rdi
callq 0x69724
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d46b
movl $0xb8, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6a93a
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lstring.c
// Function: luaS_newudata
Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
  Udata *u;
  if (s > MAX_SIZET - sizeof(Udata))
    luaM_toobig(L);
  u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
  u->uv.marked = luaC_white(G(L));  /* is not finalized */
  u->uv.tt = LUA_TUSERDATA;
  u->uv.len = s;
  u->uv.metatable = NULL;
  u->uv.env = e;
  /* chain it on udata list (after main thread) */
  u->uv.next = G(L)->mainthread->next;
  G(L)->mainthread->next = obj2gco(u);
  return u;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $-0x2a, %rsi
jb 0x6da19
movq %rbx, %rdi
callq 0x6a986
leaq 0x28(%r15), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6a93a
movq 0x20(%rbx), %rcx
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0x7, 0x8(%rax)
movq %r15, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq %r14, 0x18(%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq %rax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/ltable.c
// Function: luaH_free
void luaH_free (lua_State *L, Table *t) {
  if (t->node != dummynode)
    luaM_freearray(L, t->node, sizenode(t), Node);
  luaM_freearray(L, t->array, t->sizearray, TValue);
  luaM_free(L, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
leaq 0x3343f(%rip), %rax     # 0xa13b0
cmpq %rax, %rsi
je 0x6df94
movb 0xb(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
cltq
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6a93a
movq 0x18(%rbx), %rsi
movslq 0x38(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6a93a
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6a93a
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lzio.c
// Function: luaZ_read
size_t luaZ_read (ZIO *z, void *b, size_t n) {
  while (n) {
    size_t m;
    if (luaZ_lookahead(z) == EOZ)
      return n;  /* return number of missing bytes */
    m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
    memcpy(b, z->p, m);
    z->n -= m;
    z->p += m;
    b = (char *)b + m;
    n -= m;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rbx, %rbx
je 0x70cd6
movq %r15, %rdi
callq 0x70c3b
movl %eax, %ebp
cmpl $-0x1, %eax
je 0x70ccc
movq (%r15), %r13
movq 0x8(%r15), %rsi
cmpq %r13, %rbx
cmovbq %rbx, %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0x1fbd0
subq %r13, (%r15)
addq %r13, 0x8(%r15)
addq %r13, %r14
subq %r13, %rbx
jmp 0x70ccf
movq %rbx, %r12
cmpl $-0x1, %ebp
jne 0x70c90
jmp 0x70cd9
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/ltablib.c
// Function: setn
static int setn (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
#ifndef luaL_setn
  luaL_setn(L, 1, luaL_checkint(L, 2));
#else
  luaL_error(L, LUA_QL("setn") " is obsolete");
#endif
  lua_pushvalue(L, 1);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x7119e
leaq 0x2d468(%rip), %rsi     # 0xa1dff
movq %rbx, %rdi
xorl %eax, %eax
callq 0x70df6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x662d0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x66095
cmpl $0x1, %eax
je 0x76d4d
leaq 0x2b494(%rip), %rdx     # 0xa21d4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70d3c
movq %rbx, %rdi
callq 0x771e2
movq %rax, %r15
movl $0x0, 0x528(%rax)
leaq 0x500(%rax), %r14
cmpq $0x0, 0x500(%rax)
je 0x76d80
movl $0x0, 0x50c(%r15)
jmp 0x76d8a
movq %r14, %rdi
xorl %esi, %esi
callq 0x7beb0
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x77240
movslq 0x50c(%r15), %rdx
movq 0x500(%r15), %rsi
movq %rbx, %rdi
callq 0x66700
cmpl $0x0, 0x544(%r15)
jne 0x76dc0
movq %r14, %rdi
callq 0x7bf64
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x778f7
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x71043
movq %rax, %r14
cmpq $0x2, (%r15)
jb 0x76e1e
cmpb $0x0, (%r14)
je 0x76e0d
cmpb $0x0, 0x1(%r14)
jne 0x76e1e
leaq 0x2b57f(%rip), %rsi     # 0xa2393
movq %rbx, %rdi
xorl %eax, %eax
callq 0x70df6
movl 0x8(%rsp), %ebp
movq %rbx, %rdi
callq 0x771e2
leaq 0x10(%rsp), %r15
movq %rax, 0x18(%r15)
movq %r14, (%r15)
movl $0x0, 0x8(%r15)
movl %ebp, %edi
callq 0x7bf06
movq %rax, 0x10(%r15)
leaq 0x30(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x7792b
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x77d4d
movq %r15, %rdi
movq %r14, %rsi
callq 0x7792b
cmpl $0xa, (%r14)
je 0x76e91
leaq 0x2b55b(%rip), %rdx     # 0xa23da
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x77fab
movq 0x20(%rsp), %rdi
callq 0x7bf64
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x778f7
movq %rbx, %rdi
callq 0x771e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x66095
cmpl $0x1, %eax
je 0x76f43
cmpl $0x2, %eax
je 0x76f13
cmpl $0x3, %eax
jne 0x76f7d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x71293
movq %rax, %r15
testl %r15d, %r15d
jns 0x76f0c
leaq 0x2b655(%rip), %rdx     # 0xa2554
movq %rbx, %rdi
movl $0x3, %esi
callq 0x70d3c
movl %r15d, 0x534(%r14)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x71293
movq %rax, %r15
testl %r15d, %r15d
jns 0x76f3c
leaq 0x2b625(%rip), %rdx     # 0xa2554
movq %rbx, %rdi
movl $0x2, %esi
callq 0x70d3c
movl %r15d, 0x530(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x662f0
cmpl $0x1, %eax
je 0x76f69
leaq 0x2b60e(%rip), %rdx     # 0xa256a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70d3c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x66508
movl %eax, 0x52c(%r14)
movl 0x52c(%r14), %esi
movq %rbx, %rdi
callq 0x6691c
movslq 0x530(%r14), %rsi
movq %rbx, %rdi
callq 0x666e6
movslq 0x534(%r14), %rsi
movq %rbx, %rdi
callq 0x666e6
movl $0x3, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x778f7
movq %rbx, %rdi
callq 0x771e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x66095
testl %eax, %eax
je 0x7700e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x71293
movq %rax, %r15
testl %r15d, %r15d
jg 0x77007
leaq 0x2b581(%rip), %rdx     # 0xa257b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70d3c
movl %r15d, 0x538(%r14)
movslq 0x538(%r14), %rsi
movq %rbx, %rdi
callq 0x666e6
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq