LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_cfg_encode_number_precision
static int json_cfg_encode_number_precision(lua_State *l)
{
    json_config_t *cfg;
    int precision;

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

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

    lua_pushinteger(l, cfg->encode_number_precision);

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x778f7
movq %rbx, %rdi
callq 0x771e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x66095
testl %eax, %eax
je 0x7709e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x71293
movq %rax, %r15
decl %eax
cmpl $0xe, %eax
jb 0x7707c
leaq 0x2b526(%rip), %rdx     # 0xa2595
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70d3c
movl %r15d, 0x548(%r14)
movq %r14, %rdi
addq $0x520, %rdi            # imm = 0x520
leaq 0x2b523(%rip), %rsi     # 0xa25b7
movl %r15d, %edx
xorl %eax, %eax
callq 0x1f570
movslq 0x548(%r14), %rsi
movq %rbx, %rdi
callq 0x666e6
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_cfg_encode_keep_buffer
static int json_cfg_encode_keep_buffer(lua_State *l)
{
    json_config_t *cfg;

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

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

    lua_pushboolean(l, cfg->encode_keep_buffer);

    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x778f7
movq %rbx, %rdi
callq 0x771e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x66095
testl %eax, %eax
je 0x77106
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x7119e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x66508
movl %eax, 0x544(%r14)
movl 0x544(%r14), %esi
movq %rbx, %rdi
callq 0x6691c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_cfg_refuse_invalid_numbers
static int json_cfg_refuse_invalid_numbers(lua_State *l)
{
    static const char *options_enc_dec[] = { "none", "encode", "decode",
                                             "both", NULL };
    json_config_t *cfg;

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

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

    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x778f7
movq %rbx, %rdi
callq 0x771e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x66095
testl %eax, %eax
je 0x7716e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x662f0
cmpl $0x1, %eax
jne 0x77180
movq %rbx, %rdi
movl $0x1, %esi
callq 0x66508
leal (%rax,%rax,2), %eax
jmp 0x77196
movl 0x540(%r14), %eax
addl %eax, %eax
orl 0x53c(%r14), %eax
jmp 0x771b0
leaq 0x52d89(%rip), %rcx     # 0xc9f10
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x70f59
movl %eax, %ecx
andl $0x1, %ecx
movl %ecx, 0x53c(%r14)
movl %eax, %ecx
shrl %ecx
andl $0x1, %ecx
movl %ecx, 0x540(%r14)
testl %eax, %eax
je 0x771cb
cltq
leaq 0x52d53(%rip), %rcx     # 0xc9f10
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x66757
jmp 0x771d5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6691c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_fetch_config
static json_config_t *json_fetch_config(lua_State *l)
{
    json_config_t *cfg;

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

    lua_pop(l, 1);

    return cfg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x67960(%rip), %rsi     # 0xdeb50
callq 0x66936
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x6696e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x66621
movq %rax, %r14
testq %rax, %rax
jne 0x77228
leaq 0x2afca(%rip), %rsi     # 0xa21e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x70df6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x660a2
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/lua_cjson.c
// Function: json_append_string
static void json_append_string(lua_State *l, strbuf_t *json, int lindex)
{
    const char *escstr;
    int i;
    const char *str;
    size_t len;

    str = lua_tolstring(l, lindex, &len);

    /* Worst case is len * 6 (all unicode escapes).
     * This buffer is reused constantly for small strings
     * If there are any excess pages, they won't be hit anyway.
     * This gains ~5% speedup. */
    strbuf_ensure_empty_length(json, len * 6 + 2);

    strbuf_append_char_unsafe(json, '\"');
    for (i = 0; i < len; i++) {
        escstr = char2escape[(unsigned char)str[i]];
        if (escstr)
            strbuf_append_string(json, escstr);
        else
            strbuf_append_char_unsafe(json, str[i]);
    }
    strbuf_append_char_unsafe(json, '\"');
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r15
movl %edx, %esi
movq %r15, %rdx
callq 0x6652e
movq %rax, %r14
movl (%r15), %eax
leal (%rax,%rax,2), %eax
leal 0x2(,%rax,2), %esi
movl 0xc(%rbx), %eax
movl %eax, %ecx
notl %ecx
addl 0x8(%rbx), %ecx
cmpl %esi, %ecx
jge 0x7775a
addl %eax, %esi
movq %rbx, %rdi
callq 0x7bfe8
movq (%rbx), %rax
movslq 0xc(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%rbx)
movb $0x22, (%rax,%rcx)
cmpq $0x0, (%rsp)
je 0x777ad
xorl %r15d, %r15d
leaq 0x4c664(%rip), %r12     # 0xc3de0
movzbl (%r14,%r15), %eax
movq (%r12,%rax,8), %rsi
testq %rsi, %rsi
je 0x77794
movq %rbx, %rdi
callq 0x7c07f
jmp 0x777a4
movq (%rbx), %rcx
movslq 0xc(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0xc(%rbx)
movb %al, (%rcx,%rdx)
incq %r15
cmpq %r15, (%rsp)
ja 0x7777c
movq (%rbx), %rax
movslq 0xc(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%rbx)
movb $0x22, (%rax,%rcx)
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/lua_cjson.c
// Function: json_append_number
static void json_append_number(lua_State *l, strbuf_t *json, int index,
                               json_config_t *cfg)
{
    double num = lua_tonumber(l, index);

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

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

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

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

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

// Assembly:
movl 0x528(%rsi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x528(%rsi)
cmpl 0x538(%rsi), %eax
jge 0x778b9
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x544(%rsi)
jne 0x778d8
leaq 0x500(%r14), %rdi
callq 0x7bf64
movl 0x528(%r14), %edx
leaq 0x2aa47(%rip), %rsi     # 0xa232d
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x70df6
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_throw_parse_error
static void json_throw_parse_error(lua_State *l, json_parse_t *json,
                                   const char *exp, json_token_t *token)
{
    const char *found;

    strbuf_free(json->tmp);

    if (token->type == T_ERROR)
        found = token->value.string;
    else
        found = json_token_type_name[token->type];

    /* Note: token->index is 0 based, display starting from 1 */
    luaL_error(l, "Expected %s but found %s at character %d",
               exp, found, token->index + 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rdi
callq 0x7bf64
movl (%rbx), %eax
movl 0x4(%rbx), %r8d
addq $0x8, %rbx
cmpq $0xc, %rax
leaq 0x4c609(%rip), %rcx     # 0xc45e0
leaq (%rcx,%rax,8), %rax
cmoveq %rbx, %rax
movq (%rax), %rcx
incl %r8d
leaq 0x2a4bb(%rip), %rsi     # 0xa24a7
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x70df6
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_is_invalid_number
static int json_is_invalid_number(json_parse_t *json)
{
    int i = json->index;

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

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

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

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

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


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

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

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

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

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x5, (%rsi)
movslq 0x8(%rdi), %r15
addq (%rdi), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1fc40
movsd %xmm0, 0x8(%r14)
movq (%r12), %rax
cmpq %rax, %r15
je 0x780c9
subl %r15d, %eax
addl %eax, 0x8(%rbx)
jmp 0x780e2
movl $0xc, (%r14)
movl 0x8(%rbx), %eax
movl %eax, 0x4(%r14)
leaq 0x2a312(%rip), %rax     # 0xa23f0
movq %rax, 0x8(%r14)
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/lua_cjson.c
// Function: decode_hex4
static int decode_hex4(const char *hex)
{
    int digit[4];
    int i;

    /* Convert ASCII hex digit to numeric digit
     * Note: this returns an error for invalid hex digits, including
     *       NULL */
    for (i = 0; i < 4; i++) {
        digit[i] = hexdigit2int(hex[i]);
        if (digit[i] < 0) {
            return -1;
        }
    }

    return (digit[0] << 12) +
           (digit[1] << 8) +
           (digit[2] << 4) +
            digit[3];
}

// Assembly:
xorl %eax, %eax
movzbl (%rdi,%rax), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x78103
addl $-0x30, %ecx
movl %ecx, %edx
jmp 0x7811a
orb $0x20, %cl
leal -0x61(%rcx), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpb $0x5, %sil
ja 0x7811a
movzbl %cl, %edx
addl $-0x57, %edx
movl %edx, -0x18(%rsp,%rax,4)
testl %edx, %edx
js 0x78149
incq %rax
cmpq $0x4, %rax
jne 0x780f0
movl -0x18(%rsp), %eax
movl -0x14(%rsp), %ecx
shll $0xc, %eax
shll $0x8, %ecx
addl %eax, %ecx
movl -0x10(%rsp), %eax
shll $0x4, %eax
addl %ecx, %eax
addl -0xc(%rsp), %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cjson.c
// Function: json_destroy_config
static int json_destroy_config(lua_State *l)
{
    json_config_t *cfg;

    cfg = lua_touserdata(l, 1);
    if (cfg)
        strbuf_free(&cfg->encode_buf);
    cfg = NULL;

    return 0;
}

// Assembly:
pushq %rax
movl $0x1, %esi
callq 0x66621
testq %rax, %rax
je 0x781ab
addq $0x500, %rax            # imm = 0x500
movq %rax, %rdi
callq 0x7bf64
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_struct.c
// Function: b_size
static int b_size (lua_State *L) {
  Header h;
  const char *fmt = luaL_checkstring(L, 1);
  size_t pos = 0;
  defaultoptions(&h);
  while (*fmt) {
    int opt = *fmt++;
    size_t size = optsize(L, opt, &fmt);
    pos += gettoalign(pos, &h, opt, size);
    if (opt == 's')
      luaL_argerror(L, 1, "option 's' has no fixed size");
    else if (opt == 'c' && size == 0)
      luaL_argerror(L, 1, "option 'c0' has no fixed size");
    if (!isalnum(opt))
      controloptions(L, opt, &fmt, &h);
    pos += size;
  }
  lua_pushinteger(L, pos);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x71043
movq %rax, 0x8(%rsp)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x10(%rsp)
movb (%rax), %r13b
testb %r13b, %r13b
je 0x78aab
xorl %r12d, %r12d
incq %rax
movq %rax, 0x8(%rsp)
movsbl %r13b, %ebp
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x8(%rsp), %rdx
callq 0x78aca
movq %rax, %r15
testq %rax, %rax
sete %al
cmpb $0x63, %bpl
sete %cl
orb %al, %cl
je 0x78a1f
xorl %r14d, %r14d
jmp 0x78a3a
movslq 0x14(%rsp), %rax
cmpq %r15, %rax
cmovaeq %r15, %rax
leal -0x1(%rax), %ecx
movl %r12d, %edx
andl %ecx, %edx
subl %edx, %eax
andl %ecx, %eax
movslq %eax, %r14
leaq 0x29d0a(%rip), %rdx     # 0xa274b
cmpb $0x73, %r13b
je 0x78a5f
testq %r15, %r15
setne %al
cmpb $0x63, %r13b
setne %cl
orb %al, %cl
leaq 0x29d0b(%rip), %rdx     # 0xa2768
jne 0x78a6c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70d3c
callq 0x1f550
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x8, (%rax,%rcx,2)
jne 0x78a91
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x78b77
addq %r12, %r15
addq %r14, %r15
movq 0x8(%rsp), %rax
movb (%rax), %r13b
movq %r15, %r12
testb %r13b, %r13b
jne 0x789eb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x666e6
movl $0x1, %eax
addq $0x18, %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/lua_struct.c
// Function: optsize
static size_t optsize (lua_State *L, char opt, const char **fmt) {
  switch (opt) {
    case 'B': case 'b': return sizeof(char);
    case 'H': case 'h': return sizeof(short);
    case 'L': case 'l': return sizeof(long);
    case 'T': return sizeof(size_t);
    case 'f':  return sizeof(float);
    case 'd':  return sizeof(double);
    case 'x': return 1;
    case 'c': return getnum(fmt, 1);
    case 'i': case 'I': {
      int sz = getnum(fmt, sizeof(int));
      if (sz > MAXINTSIZE)
        luaL_error(L, "integral size %d is larger than limit of %d",
                       sz, MAXINTSIZE);
      return sz;
    }
    default: return 0;  /* other cases do not need alignment */
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %eax
cmpl $0x53, %esi
jle 0x78b03
leal -0x62(%rsi), %ecx
cmpl $0xa, %ecx
ja 0x78b56
leaq 0x29b6b(%rip), %rsi     # 0xa2654
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq %rdx, %rdi
movl $0x1, %esi
callq 0x78c3c
cltq
jmp 0x78b69
cmpl $0x48, %esi
jg 0x78b19
cmpl $0x42, %esi
je 0x78b69
cmpl $0x48, %esi
jne 0x78b60
movl $0x2, %eax
jmp 0x78b69
cmpl $0x49, %esi
je 0x78b25
cmpl $0x4c, %esi
je 0x78b64
jmp 0x78b60
movq %rdx, %rdi
movl $0x4, %esi
callq 0x78c3c
movl %eax, %ebp
cmpl $0x21, %eax
jl 0x78b51
leaq 0x29b40(%rip), %rsi     # 0xa2680
movq %rbx, %rdi
movl %ebp, %edx
movl $0x20, %ecx
xorl %eax, %eax
callq 0x70df6
movslq %ebp, %rax
jmp 0x78b69
cmpl $0x54, %esi
je 0x78b64
cmpl $0x78, %esi
je 0x78b69
xorl %eax, %eax
jmp 0x78b69
movl $0x8, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x4, %eax
jmp 0x78b69
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_struct.c
// Function: controloptions
static void controloptions (lua_State *L, int opt, const char **fmt,
                            Header *h) {
  switch (opt) {
    case  ' ': return;  /* ignore white spaces */
    case '>': h->endian = BIG; return;
    case '<': h->endian = LITTLE; return;
    case '!': {
      int a = getnum(fmt, MAXALIGN);
      if (!isp2(a))
        luaL_error(L, "alignment %d is not a power of 2", a);
      h->align = a;
      return;
    }
    default: {
      const char *msg = lua_pushfstring(L, "invalid format option '%c'", opt);
      luaL_argerror(L, 1, msg);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %esi, %eax
movq %rdi, %r14
cmpl $0x3b, %esi
jg 0x78bf8
cmpl $0x20, %eax
je 0x78c37
cmpl $0x21, %eax
jne 0x78c0a
movq %rdx, %rdi
movl $0x8, %esi
callq 0x78c3c
movl %eax, %ebp
testl %eax, %eax
jle 0x78be0
movl %ebp, %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl %ebp, %ecx
subl %eax, %ecx
movl $0x33333333, %eax       # imm = 0x33333333
movl %ecx, %edx
andl %eax, %edx
shrl $0x2, %ecx
andl %eax, %ecx
addl %edx, %ecx
movl %ecx, %eax
shrl $0x4, %eax
addl %ecx, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
imull $0x1010101, %eax, %eax  # imm = 0x1010101
shrl $0x18, %eax
cmpl $0x2, %eax
jb 0x78bf3
leaq 0x29ac5(%rip), %rsi     # 0xa26ac
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x70df6
movl %ebp, 0x4(%rbx)
jmp 0x78c37
cmpl $0x3c, %eax
je 0x78c31
cmpl $0x3e, %eax
jne 0x78c0a
movl $0x0, (%rbx)
jmp 0x78c37
leaq 0x29abc(%rip), %rsi     # 0xa26cd
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x667d5
movq %r14, %rdi
movl $0x1, %esi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x70d3c
movl $0x1, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_struct.c
// Function: getnum
static int getnum (const char **fmt, int df) {
  if (!isdigit(**fmt))  /* no number? */
    return df;  /* return default value */
  else {
    int a = 0;
    do {
      a = a*10 + *((*fmt)++) - '0';
    } while (isdigit(**fmt));
    return a;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x1f550
movq (%rax), %rcx
movq (%rbx), %rdx
movsbq (%rdx), %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x78c87
xorl %r14d, %r14d
leal (%r14,%r14,4), %ecx
movq (%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, (%rbx)
movsbl (%rdx), %esi
leal (%rsi,%rcx,2), %r14d
addl $-0x30, %r14d
movq (%rax), %rcx
movsbq 0x1(%rdx), %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x78c5f
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdx, 0x10(%rdi)
jae 0x78cc5
movq 0x8(%r14), %r12
addq %rbx, %r12
movq (%r14), %rdi
leaq (%r12,%r12), %rsi
callq 0x1fab0
movq %rax, (%r14)
movq %r12, 0x10(%r14)
movq (%r14), %rdi
addq 0x8(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1fbd0
addq %rbx, 0x8(%r14)
subq %rbx, 0x10(%r14)
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/lua_cmsgpack.c
// Function: mp_decode_to_lua_array
void mp_decode_to_lua_array(lua_State *L, mp_cur *c, size_t len) {
    int index = 1;

    lua_newtable(L);
    while(len--) {
        lua_pushnumber(L,index++);
        mp_decode_to_lua_type(L,c);
        if (c->err) return;
        lua_settable(L,-3);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
callq 0x66a47
testq %rbx, %rbx
je 0x78d5d
xorl %r12d, %r12d
leal 0x1(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq %r15, %rdi
callq 0x666d1
movq %r15, %rdi
movq %r14, %rsi
callq 0x78d69
cmpl $0x0, 0x10(%r14)
jne 0x78d5d
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x66b43
incq %r12
cmpq %r12, %rbx
jne 0x78d22
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/lua_cmsgpack.c
// Function: mp_decode_to_lua_hash
void mp_decode_to_lua_hash(lua_State *L, mp_cur *c, size_t len) {
    lua_newtable(L);
    while(len--) {
        mp_decode_to_lua_type(L,c); /* key */
        if (c->err) return;
        mp_decode_to_lua_type(L,c); /* value */
        if (c->err) return;
        lua_settable(L,-3);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
callq 0x66a47
testq %rbx, %rbx
je 0x791a7
movq %r15, %rdi
movq %r14, %rsi
callq 0x78d69
cmpl $0x0, 0x10(%r14)
jne 0x791a7
movq %r15, %rdi
movq %r14, %rsi
callq 0x78d69
cmpl $0x0, 0x10(%r14)
jne 0x791a7
decq %rbx
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x66b43
jmp 0x7916c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cmsgpack.c
// Function: luaopen_cmsgpack
LUALIB_API int luaopen_cmsgpack (lua_State *L) {
    luaL_register(L, "cmsgpack", thislib);

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x24736(%rip), %rsi     # 0x9d8ee
leaq 0x4b4e1(%rip), %rdx     # 0xc46a0
callq 0x713dc
leaq 0x29651(%rip), %rsi     # 0xa281c
movl $0x12, %edx
movq %rbx, %rdi
callq 0x66700
leaq 0x28648(%rip), %rdx     # 0xa1827
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x66b6a
leaq 0x2963c(%rip), %rsi     # 0xa282f
movl $0x28, %edx
movq %rbx, %rdi
callq 0x66700
leaq 0x29651(%rip), %rdx     # 0xa2858
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x66b6a
leaq 0x29648(%rip), %rsi     # 0xa2863
movl $0x24, %edx
movq %rbx, %rdi
callq 0x66700
leaq 0x29659(%rip), %rdx     # 0xa2888
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x66b6a
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lua_cmsgpack.c
// Function: mp_pack
static int mp_pack(lua_State *L) {
    mp_buf *buf = mp_buf_new();

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6637a
testl %eax, %eax
jne 0x792ce
leaq 0x295d7(%rip), %rsi     # 0xa2895
movq %rbx, %rdi
callq 0x66757
movq %rbx, %rdi
callq 0x6704e
movq %rsp, %r14
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x6652e
movq %rax, %r15
movq (%r14), %r12
movl $0x18, %edi
callq 0x1f350
movq %rax, %r14
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x78d69
movl 0x10(%r14), %eax
cmpl $0x1, %eax
je 0x79324
cmpl $0x2, %eax
jne 0x7932d
leaq 0x295b9(%rip), %r15     # 0xa28db
jmp 0x7933b
leaq 0x29598(%rip), %r15     # 0xa28c3
jmp 0x7933b
cmpq $0x0, 0x8(%r14)
je 0x79356
leaq 0x295ba(%rip), %r15     # 0xa28f5
movq %r14, %rdi
callq 0x1f4d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x66757
movq %rbx, %rdi
callq 0x6704e
movq %r14, %rdi
callq 0x1f4d0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lcode.c
// Function: luaK_self
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  int func;
  luaK_exp2anyreg(fs, e);
  freeexp(fs, e);
  func = fs->freereg;
  luaK_reserveregs(fs, 2);
  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
  freeexp(fs, key);
  e->u.s.info = func;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x79fe4
cmpl $0xc, (%rbx)
jne 0x7a22b
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x7a22b
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %eax
jl 0x7a22b
decl 0x3c(%r14)
movl 0x3c(%r14), %r12d
movq %r14, %rdi
movl $0x2, %esi
callq 0x79b5b
addl $0x2, 0x3c(%r14)
movl 0x8(%rbx), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x7a04a
movl %r12d, %ecx
shll $0x6, %ecx
shll $0x17, %ebp
orl %ecx, %ebp
shll $0xe, %eax
orl %eax, %ebp
orl $0xb, %ebp
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x7aac9
cmpl $0xc, (%r15)
jne 0x7a290
movl 0x8(%r15), %eax
btl $0x8, %eax
jb 0x7a290
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %eax
jl 0x7a290
decl 0x3c(%r14)
movl %r12d, 0x8(%rbx)
movl $0xc, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lcode.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
  expdesc e2;
  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
  switch (op) {
    case OPR_MINUS: {
      if (!isnumeral(e))
        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
      codearith(fs, OP_UNM, e, &e2);
      break;
    }
    case OPR_NOT: codenot(fs, e); break;
    case OPR_LEN: {
      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
      codearith(fs, OP_LEN, e, &e2);
      break;
    }
    default: lua_assert(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq $-0x1, 0x10(%rsp)
movl $0x5, (%rsp)
movq $0x0, 0x8(%rsp)
cmpl $0x2, %esi
je 0x7a4cf
cmpl $0x1, %esi
je 0x7a49c
testl %esi, %esi
jne 0x7a4ed
cmpl $0x5, (%rbx)
jne 0x7a484
cmpl $-0x1, 0x10(%rbx)
jne 0x7a484
cmpl $-0x1, 0x14(%rbx)
je 0x7a48f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79fe4
movq %rsp, %rcx
movq %r14, %rdi
movl $0x12, %esi
jmp 0x7a4e5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc8
movl (%rbx), %eax
decl %eax
cmpl $0xb, %eax
ja 0x7a595
leaq 0x28485(%rip), %rcx     # 0xa2940
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%rbx)
jmp 0x7a595
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79fe4
movq %rsp, %rcx
movq %r14, %rdi
movl $0x14, %esi
movq %rbx, %rdx
callq 0x7a5bb
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x2, (%rbx)
jmp 0x7a595
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7adc8
cmpl $0xc, (%rbx)
jne 0x7a526
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x7a526
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %eax
jl 0x7a526
decl 0x3c(%r14)
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x13, %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x7aac9
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
jmp 0x7a595
movslq 0x8(%rbx), %rcx
movq (%r14), %rdx
leaq (,%rcx,4), %rax
addq 0x18(%rdx), %rax
testq %rcx, %rcx
jle 0x7a578
movl -0x4(%rax), %ecx
andl $0x3f, %ecx
leaq 0x26b02(%rip), %rdx     # 0xa1070
cmpb $0x0, (%rcx,%rdx)
jns 0x7a578
addq $-0x4, %rax
movl (%rax), %ecx
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %eax
movl %esi, 0x14(%rbx)
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x7adff
movl 0x10(%rbx), %esi
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x7adff
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/lcode.c
// Function: luaK_infix
void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
  switch (op) {
    case OPR_AND: {
      luaK_goiftrue(fs, v);
      break;
    }
    case OPR_OR: {
      luaK_goiffalse(fs, v);
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
      break;
    }
    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
    case OPR_MOD: case OPR_POW: {
      if (!isnumeral(v)) luaK_exp2RK(fs, v);
      break;
    }
    default: {
      luaK_exp2RK(fs, v);
      break;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0xe, %esi
ja 0x7a7ae
movl %esi, %eax
leaq 0x28204(%rip), %rcx     # 0xa2994
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x5, (%rbx)
jne 0x7a7ae
cmpl $-0x1, 0x10(%rbx)
jne 0x7a7ae
cmpl $-0x1, 0x14(%rbx)
je 0x7a846
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a04a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x79e61
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a2a3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc8
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x7a81c
cmpl $0x3, %eax
je 0x7a81c
cmpl $0xa, %eax
jne 0x7a80a
movl 0x8(%rbx), %edx
jmp 0x7a81c
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x7a35d
movl %eax, %edx
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x799ea
movl 0x14(%rbx), %edx
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
leaq 0x38(%r14), %rsi
movq %r14, %rdi
callq 0x799ea
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/llex.c
// Function: luaX_init
void luaX_init (lua_State *L) {
  int i;
  for (i=0; i<NUM_RESERVED; i++) {
    TString *ts = luaS_new(L, luaX_tokens[i]);
    luaS_fix(ts);  /* reserved words are never collected */
    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
    ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb $0x1, %bpl
xorl %r15d, %r15d
leaq 0x4986c(%rip), %r12     # 0xc46d0
movq (%r15,%r12), %r14
movq %r14, %rdi
callq 0x1f4f0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6d88b
orb $0x20, 0x9(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %r15
incb %bpl
cmpq $0xa8, %r15
jne 0x7ae64
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/llex.c
// Function: luaX_setinput
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
  ls->decpoint = '.';
  ls->L = L;
  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
  ls->z = z;
  ls->fs = NULL;
  ls->linenumber = 1;
  ls->lastline = 1;
  ls->source = source;
  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
  next(ls);  /* read first char */
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movb $0x2e, 0x58(%rsi)
movq %rdi, 0x38(%rsi)
movl $0x11f, 0x20(%rsi)      # imm = 0x11F
movq %rdx, 0x40(%rsi)
movq $0x0, 0x30(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rsi)
movq %rcx, 0x50(%rsi)
movq 0x48(%rsi), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
movl $0x20, %ecx
callq 0x6a93a
movq 0x48(%rbx), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x7b070
callq 0x70bec
jmp 0x7b07f
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: die
void die(const char *fmt, ...)
{
    va_list arg;

    va_start(arg, fmt);
    vfprintf(stderr, fmt, arg);
    va_end(arg);
    fprintf(stderr, "\n");

    exit(-1);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x7be67
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x4a13a(%rip), %rbx     # 0xc5fc8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x1f450
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1f4a0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1f2b0
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: strbuf_init
void strbuf_init(strbuf_t *s, int len)
{
    int size;

    if (len <= 0)
        size = STRBUF_DEFAULT_SIZE;
    else
        size = len + 1;         /* \0 terminator */

    s->buf = NULL;
    s->size = size;
    s->length = 0;
    s->increment = STRBUF_DEFAULT_INCREMENT;
    s->dynamic = 0;
    s->reallocs = 0;
    s->debug = 0;

    s->buf = malloc(size);
    if (!s->buf)
        die("Out of memory");

    strbuf_ensure_null(s);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leal 0x1(%rsi), %eax
testl %esi, %esi
movl $0x3ff, %edi            # imm = 0x3FF
cmovgl %eax, %edi
movq $0x0, (%rbx)
movl %edi, 0x8(%rbx)
movsd 0x26d2d(%rip), %xmm0    # 0xa2c00
movups %xmm0, 0xc(%rbx)
movl $0x0, 0x1c(%rbx)
callq 0x1f350
movq %rax, (%rbx)
testq %rax, %rax
je 0x7bef8
movq (%rbx), %rax
movslq 0xc(%rbx), %rcx
movb $0x0, (%rax,%rcx)
popq %rbx
retq
leaq 0x248eb(%rip), %rdi     # 0xa07ea
xorl %eax, %eax
callq 0x7be08
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: strbuf_new
strbuf_t *strbuf_new(int len)
{
    strbuf_t *s;

    s = malloc(sizeof(strbuf_t));
    if (!s)
        die("Out of memory");

    strbuf_init(s, len);

    /* Dynamic strbuf allocation / deallocation */
    s->dynamic = 1;

    return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x20, %edi
callq 0x1f350
testq %rax, %rax
je 0x7bf3b
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x7beb0
movl $0x1, 0x14(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x248a8(%rip), %rdi     # 0xa07ea
xorl %eax, %eax
callq 0x7be08
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: strbuf_free
void strbuf_free(strbuf_t *s)
{
    debug_stats(s);

    if (s->buf) {
        free(s->buf);
        s->buf = NULL;
    }
    if (s->dynamic)
        free(s);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x1c(%rdi)
jne 0x7bf93
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7bf82
callq 0x1f4d0
movq $0x0, (%rbx)
cmpl $0x0, 0x14(%rbx)
je 0x7bf91
movq %rbx, %rdi
popq %rbx
jmp 0x1f4d0
popq %rbx
retq
movq %rbx, %rdi
callq 0x2024b
jmp 0x7bf6e
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: strbuf_free_to_string
char *strbuf_free_to_string(strbuf_t *s, int *len)
{
    char *buf;

    debug_stats(s);

    strbuf_ensure_null(s);

    buf = s->buf;
    if (len)
        *len = s->length;

    if (s->dynamic)
        free(s);

    return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x1c(%rdi)
jne 0x7bfde
movq (%rbx), %rax
movslq 0xc(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %r15
testq %r14, %r14
je 0x7bfc7
movl 0xc(%rbx), %eax
movl %eax, (%r14)
cmpl $0x0, 0x14(%rbx)
je 0x7bfd5
movq %rbx, %rdi
callq 0x1f4d0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x20271
jmp 0x7bfae
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: strbuf_resize
void strbuf_resize(strbuf_t *s, int len)
{
    int newsize;

    newsize = calculate_new_size(s, len);

    if (s->debug > 1) {
        fprintf(stderr, "strbuf(%lx) resize: %d => %d\n",
                (long)s, s->size, newsize);
    }

    s->size = newsize;
    s->buf = realloc(s->buf, s->size);
    if (!s->buf)
        die("Out of memory");
    s->reallocs++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x7c068
movq %rdi, %rbx
leal 0x1(%rsi), %ebp
movl 0x8(%rdi), %ecx
cmpl %ebp, %ecx
jg 0x7c022
movl 0x10(%rbx), %edi
testl %edi, %edi
js 0x7c011
leal (%rdi,%rcx), %ebp
decl %ebp
movl %ebp, %eax
cltd
idivl %edi
subl %edx, %ebp
jmp 0x7c022
movl %ecx, %ebp
cmpl %esi, %ecx
jg 0x7c022
movl %ecx, %ebp
imull %edi, %ebp
negl %ebp
cmpl %esi, %ebp
jle 0x7c019
cmpl $0x2, 0x1c(%rbx)
jge 0x7c048
movl %ebp, 0x8(%rbx)
movq (%rbx), %rdi
movslq %ebp, %rsi
callq 0x1fab0
movq %rax, (%rbx)
testq %rax, %rax
je 0x7c071
incl 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x49f79(%rip), %rax     # 0xc5fc8
movq (%rax), %rdi
leaq 0x26bd5(%rip), %rsi     # 0xa2c2e
movq %rbx, %rdx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x1fb10
jmp 0x7c028
leaq 0x26c53(%rip), %rdi     # 0xa2cc2
jmp 0x7c078
leaq 0x24772(%rip), %rdi     # 0xa07ea
xorl %eax, %eax
callq 0x7be08
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: strbuf_append_string
void strbuf_append_string(strbuf_t *s, const char *str)
{
    int space, i;

    space = strbuf_empty_length(s);

    for (i = 0; str[i]; i++) {
        if (space < 1) {
            strbuf_resize(s, s->length + 1);
            space = strbuf_empty_length(s);
        }

        s->buf[s->length] = str[i];
        s->length++;
        space--;
    }
}

// Assembly:
cmpb $0x0, (%rsi)
je 0x7c0d6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %eax
notl %eax
addl 0x8(%rdi), %eax
incq %r14
testl %eax, %eax
jg 0x7c0b2
movl 0xc(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0x7bfe8
movl 0xc(%rbx), %eax
notl %eax
addl 0x8(%rbx), %eax
movb -0x1(%r14), %cl
movq (%rbx), %rdx
movslq 0xc(%rbx), %rsi
movb %cl, (%rdx,%rsi)
incl 0xc(%rbx)
decl %eax
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x7c099
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: strbuf_append_fmt
void strbuf_append_fmt(strbuf_t *s, int len, const char *fmt, ...)
{
    va_list arg;
    int fmt_len;

    strbuf_ensure_empty_length(s, len);

    va_start(arg, fmt);
    fmt_len = vsnprintf(s->buf + s->length, len, fmt, arg);
    va_end(arg);

    if (fmt_len < 0)
        die("BUG: Unable to convert number");  /* This should never happen.. */

    s->length += fmt_len;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x7c134
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl 0xc(%rdi), %esi
movl %esi, %eax
notl %eax
addl 0x8(%rdi), %eax
cmpl %ebp, %eax
jge 0x7c14c
addl %ebp, %esi
movq %rbx, %rdi
callq 0x7bfe8
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
movslq 0xc(%rbx), %rdi
addq (%rbx), %rdi
movslq %ebp, %rsi
movq %r14, %rdx
callq 0x1f7b0
testl %eax, %eax
js 0x7c196
addl %eax, 0xc(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x26aaf(%rip), %rdi     # 0xa2c4c
xorl %eax, %eax
callq 0x7be08
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/lua/src/strbuf.c
// Function: strbuf_append_fmt_retry
void strbuf_append_fmt_retry(strbuf_t *s, const char *fmt, ...)
{
    va_list arg;
    int fmt_len, try;
    int empty_len;

    /* If the first attempt to append fails, resize the buffer appropriately
     * and try again */
    for (try = 0; ; try++) {
        va_start(arg, fmt);
        /* Append the new formatted string */
        /* fmt_len is the length of the string required, excluding the
         * trailing NULL */
        empty_len = strbuf_empty_length(s);
        /* Add 1 since there is also space to store the terminating NULL. */
        fmt_len = vsnprintf(s->buf + s->length, empty_len + 1, fmt, arg);
        va_end(arg);

        if (fmt_len <= empty_len)
            break;  /* SUCCESS */
        if (try > 0)
            die("BUG: length of formatted string changed");

        strbuf_resize(s, s->length + fmt_len);
    }

    s->length += fmt_len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x7c20f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %r12, 0x10(%rcx)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rbp     # imm = 0x3000000010
movq %rbp, (%rcx)
movl 0x8(%rdi), %eax
movslq 0xc(%rdi), %rdi
movl %edi, %r15d
notl %r15d
addl %eax, %r15d
subl %edi, %eax
addq (%rbx), %rdi
movslq %eax, %rsi
movq %r14, %rdx
callq 0x1f7b0
cmpl %r15d, %eax
jle 0x7c2ab
movb $0x1, %cl
movq %rsp, %r15
testb $0x1, %cl
je 0x7c2c0
addl 0xc(%rbx), %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x7bfe8
movq %r12, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rbp, (%rsp)
movl 0x8(%rbx), %eax
movslq 0xc(%rbx), %rdi
movl %edi, %r13d
notl %r13d
addl %eax, %r13d
subl %edi, %eax
addq (%rbx), %rdi
movslq %eax, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1f7b0
xorl %ecx, %ecx
cmpl %r13d, %eax
jg 0x7c259
addl %eax, 0xc(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x269a3(%rip), %rdi     # 0xa2c6a
xorl %eax, %eax
callq 0x7be08
nop
// File: /workspace/github_c_makefile_star2_O1/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: arenas_extend
arena_t *
arenas_extend(unsigned ind)
{
	arena_t *ret;

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

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

	return (arenas[0]);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x11c0, %edi           # imm = 0x11C0
callq 0x85158
testq %rax, %rax
je 0x7c2f5
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
callq 0x8295d
testb %al, %al
je 0x7c316
leaq 0x26bd8(%rip), %rdi     # 0xa2ed4
callq 0x9124c
cmpb $0x1, 0x62852(%rip)     # 0xdeb5a
je 0x7c32d
movq 0x62867(%rip), %rax     # 0xdeb78
movq (%rax), %rbx
jmp 0x7c323
movq 0x6285b(%rip), %rax     # 0xdeb78
movl %ebp, %ecx
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1f1b0