LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: luaL_setfuncs
static void luaL_setfuncs (lua_State *l, const luaL_Reg *reg, int nup)
{
    int i;

    luaL_checkstack(l, nup, "too many upvalues");
    for (; reg->name != NULL; reg++) {  /* fill the table with given functions */
        for (i = 0; i < nup; i++)  /* copy upvalues to the top */
            lua_pushvalue(l, -nup);
        lua_pushcclosure(l, reg->func, nup);  /* closure with those upvalues */
        lua_setfield(l, -(nup + 2), reg->name);
    }
    lua_pop(l, nup);  /* remove upvalues */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x826bf(%rip), %rdx     # 0x14bb30
callq 0xc0830
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc94e4
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc94a8
movq -0x8(%rbp), %rdi
xorl %esi, %esi
subl -0x14(%rbp), %esi
callq 0xaca40
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc9487
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0xad5a0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x2, %eax
xorl %esi, %esi
subl %eax, %esi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0xadca0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xc9476
movq -0x8(%rbp), %rdi
xorl %esi, %esi
subl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0xac570
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_fetch_config
static json_config_t *json_fetch_config(lua_State *l)
{
    json_config_t *cfg;

    cfg = lua_touserdata(l, lua_upvalueindex(1));
    if (!cfg)
        luaL_error(l, "BUG: Unable to fetch CJSON configuration");

    return cfg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0xad160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc9537
movq -0x8(%rbp), %rdi
leaq 0x82202(%rip), %rsi     # 0x14b732
movb $0x0, %al
callq 0xc0370
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0xacf60
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
imulq $0x6, -0x38(%rbp), %rax
addq $0x2, %rax
movl %eax, %esi
callq 0xc9e50
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0xc9e90
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xc97df
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xae0d1(%rip), %rax     # 0x177870
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc97bd
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd2e10
jmp 0xc97d2
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0xc9e90
jmp 0xc97d4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc9780
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0xc9e90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_check_encode_depth
static void json_check_encode_depth(lua_State *l, json_config_t *cfg,
                                    int current_depth, strbuf_t *json)
{
    /* Ensure there are enough slots free to traverse a table (key,
     * value) and push a string for a potential error message.
     *
     * Unlike "decode", the key and value are still on the stack when
     * lua_checkstack() is called.  Hence an extra slot for luaL_error()
     * below is required just in case the next check to lua_checkstack()
     * fails.
     *
     * While this won't cause a crash due to the EXTRA_STACK reserve
     * slots, it would still be an improper use of the API. */
    if (current_depth <= cfg->encode_max_depth && lua_checkstack(l, 3))
        return;

    if (!cfg->encode_keep_buffer)
        strbuf_free(json);

    luaL_error(l, "Cannot serialise, excessive nesting (%d)",
               current_depth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x52c(%rcx), %eax
jg 0xc9a4b
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xac2d0
cmpl $0x0, %eax
je 0xc9a4b
jmp 0xc9a76
movq -0x10(%rbp), %rax
cmpl $0x0, 0x538(%rax)
jne 0xc9a61
movq -0x20(%rbp), %rdi
callq 0xd2bb0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x81de6(%rip), %rsi     # 0x14b855
movb $0x0, %al
callq 0xc0370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: lua_array_length
static int lua_array_length(lua_State *l, json_config_t *cfg, strbuf_t *json)
{
    double k;
    int max;
    int items;

    max = 0;
    items = 0;

    lua_pushnil(l);
    /* table, startkey */
    while (lua_next(l, -2) != 0) {
        /* table, key, value */
        if (lua_type(l, -2) == LUA_TNUMBER &&
            (k = lua_tonumber(l, -2))) {
            /* Integer >= 1 ? */
            if (floor(k) == k && k >= 1) {
                if (k > max)
                    max = k;
                items++;
                lua_pop(l, 1);
                continue;
            }
        }

        /* Must not be an array (non integer key) */
        lua_pop(l, 2);
        return -1;
    }

    /* Encode excessively sparse arrays as objects (if enabled) */
    if (cfg->encode_sparse_ratio > 0 &&
        max > items * cfg->encode_sparse_ratio &&
        max > cfg->encode_sparse_safe) {
        if (!cfg->encode_sparse_convert)
            json_encode_exception(l, cfg, json, -1, "excessively sparse array");

        return -1;
    }

    return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xad2c0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xae690
cmpl $0x0, %eax
je 0xc9b68
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xacaa0
cmpl $0x3, %eax
jne 0xc9b51
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xace10
movsd %xmm0, -0x28(%rbp)
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc9af5
jp 0xc9af5
jmp 0xc9b51
movsd -0x28(%rbp), %xmm0
callq 0x26b60
ucomisd -0x28(%rbp), %xmm0
jne 0xc9b4f
jp 0xc9b4f
movsd -0x28(%rbp), %xmm0
movsd 0x6d953(%rip), %xmm1    # 0x137468
ucomisd %xmm1, %xmm0
jb 0xc9b4f
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xc9b33
cvttsd2si -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xac570
jmp 0xc9aab
jmp 0xc9b51
movq -0x10(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xac570
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc9bd2
movq -0x18(%rbp), %rax
cmpl $0x0, 0x524(%rax)
jle 0xc9bcc
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rdx
imull 0x524(%rdx), %ecx
cmpl %ecx, %eax
jle 0xc9bcc
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x528(%rcx), %eax
jle 0xc9bcc
movq -0x18(%rbp), %rax
cmpl $0x0, 0x520(%rax)
jne 0xc9bc3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq 0x81cc0(%rip), %r8      # 0x14b87e
callq 0xc9dd0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc9bd2
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_append_array
static void json_append_array(lua_State *l, json_config_t *cfg, int current_depth,
                              strbuf_t *json, int array_length)
{
    int comma, i;

    strbuf_append_char(json, '[');

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

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

    strbuf_append_char(json, ']');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl $0x5b, %esi
callq 0xc9f20
movl $0x0, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0xc9c7a
cmpl $0x0, -0x28(%rbp)
je 0xc9c35
movq -0x20(%rbp), %rdi
movl $0x2c, %esi
callq 0xc9f20
jmp 0xc9c3c
movl $0x1, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xad960
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0xc9570
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xac570
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc9c17
movq -0x20(%rbp), %rdi
movl $0x5d, %esi
callq 0xc9f20
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_append_object
static void json_append_object(lua_State *l, json_config_t *cfg,
                               int current_depth, strbuf_t *json)
{
    int comma, keytype;

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

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

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

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

    strbuf_append_char(json, '}');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x7b, %esi
callq 0xc9f20
movq -0x8(%rbp), %rdi
callq 0xad2c0
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xae690
cmpl $0x0, %eax
je 0xc9db9
cmpl $0x0, -0x24(%rbp)
je 0xc9cf2
movq -0x20(%rbp), %rdi
movl $0x2c, %esi
callq 0xc9f20
jmp 0xc9cf9
movl $0x1, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xacaa0
movl %eax, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jne 0xc9d4b
movq -0x20(%rbp), %rdi
movl $0x22, %esi
callq 0xc9f20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0xc9800
movq -0x20(%rbp), %rdi
leaq 0x81b58(%rip), %rsi     # 0x14b897
movl $0x2, %edx
callq 0xc99b0
jmp 0xc9d92
cmpl $0x4, -0x28(%rbp)
jne 0xc9d73
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0xc9730
movq -0x20(%rbp), %rdi
movl $0x3a, %esi
callq 0xc9f20
jmp 0xc9d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
leaq 0x81b0f(%rip), %r8      # 0x14b89a
callq 0xc9dd0
jmp 0xc9d92
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0xc9570
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xac570
jmp 0xc9cc5
movq -0x20(%rbp), %rdi
movl $0x7d, %esi
callq 0xc9f20
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_encode_exception
static void json_encode_exception(lua_State *l, json_config_t *cfg, strbuf_t *json, int lindex,
                                  const char *reason)
{
    if (!cfg->encode_keep_buffer)
        strbuf_free(json);
    luaL_error(l, "Cannot serialise %s: %s",
                  lua_typename(l, lua_type(l, lindex)), reason);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x538(%rax)
jne 0xc9e01
movq -0x18(%rbp), %rdi
callq 0xd2bb0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xacaa0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0xacaf0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
leaq 0x81a85(%rip), %rsi     # 0x14b8bf
movb $0x0, %al
callq 0xc0370
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_process_value
static void json_process_value(lua_State *l, json_parse_t *json,
                               json_token_t *token)
{
    switch (token->type) {
    case T_STRING:
        lua_pushlstring(l, token->value.string, token->string_len);
        break;;
    case T_NUMBER:
        lua_pushnumber(l, token->value.number);
        break;;
    case T_BOOLEAN:
        lua_pushboolean(l, token->value.boolean);
        break;;
    case T_OBJ_BEGIN:
        json_parse_object_context(l, json);
        break;;
    case T_ARR_BEGIN:
        json_parse_array_context(l, json);
        break;;
    case T_NULL:
        /* In Lua, setting "t[k] = nil" will delete k from the table.
         * Hence a NULL pointer lightuserdata object is used instead */
        lua_pushlightuserdata(l, NULL);
        break;;
    default:
        json_throw_parse_error(l, json, "value", token);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0xca27a
movq -0x20(%rbp), %rax
leaq 0x81455(%rip), %rcx     # 0x14b658
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rdx
callq 0xad390
jmp 0xca292
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0xad2f0
jmp 0xca292
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xad710
jmp 0xca292
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcaa80
jmp 0xca292
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcabb0
jmp 0xca292
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xad760
jmp 0xca292
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq 0x811d0(%rip), %rdx     # 0x14b45d
callq 0xca2a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd2bb0
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0xca2dc
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xca2f3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xadd85(%rip), %rax     # 0x178070
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %r8d
addl $0x1, %r8d
leaq 0x81735(%rip), %rsi     # 0x14ba47
movb $0x0, %al
callq 0xc0370
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_is_invalid_number
static int json_is_invalid_number(json_parse_t *json)
{
    const char *p = json->ptr;

    /* Reject numbers starting with + */
    if (*p == '+')
        return 1;

    /* Skip minus sign if it exists */
    if (*p == '-')
        p++;

    /* Reject numbers starting with 0x, or leading zeros */
    if (*p == '0') {
        int ch2 = *(p + 1);

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

        return 0;
    } else if (*p <= '9') {
        return 0;                           /* Ordinary number */
    }

    /* Reject inf/nan */
    if (!strncasecmp(p, "inf", 3))
        return 1;
    if (!strncasecmp(p, "nan", 3))
        return 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0xca540
movl $0x1, -0x4(%rbp)
jmp 0xca600
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xca558
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xca59c
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
orl $0x20, %eax
cmpl $0x78, %eax
je 0xca58a
movl $0x30, %eax
cmpl -0x1c(%rbp), %eax
jg 0xca593
cmpl $0x39, -0x1c(%rbp)
jg 0xca593
movl $0x1, -0x4(%rbp)
jmp 0xca600
movl $0x0, -0x4(%rbp)
jmp 0xca600
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0xca5b1
movl $0x0, -0x4(%rbp)
jmp 0xca600
jmp 0xca5b3
movq -0x18(%rbp), %rdi
leaq 0x704cd(%rip), %rsi     # 0x13aa8b
movl $0x3, %edx
callq 0x268d0
cmpl $0x0, %eax
jne 0xca5d6
movl $0x1, -0x4(%rbp)
jmp 0xca600
movq -0x18(%rbp), %rdi
leaq 0x71008(%rip), %rsi     # 0x13b5e9
movl $0x3, %edx
callq 0x268d0
cmpl $0x0, %eax
jne 0xca5f9
movl $0x1, -0x4(%rbp)
jmp 0xca600
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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)
{
    char *endptr;

    token->type = T_NUMBER;
    token->value.number = fpconv_strtod(json->ptr, &endptr);
    if (json->ptr == endptr)
        json_set_token_error(token, json, "invalid number");
    else
        json->ptr = endptr;     /* Skip the processed number */

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0xd3120
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xca668
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x812ba(%rip), %rdx     # 0x14b91b
callq 0xca320
jmp 0xca674
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0xca865
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xcaa10
movl %eax, %ecx
movslq -0x24(%rbp), %rax
movl %ecx, -0x20(%rbp,%rax,4)
movslq -0x24(%rbp), %rax
cmpl $0x0, -0x20(%rbp,%rax,4)
jge 0xca858
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca881
jmp 0xca85a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xca823
movl -0x20(%rbp), %eax
shll $0xc, %eax
movl -0x1c(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl -0x18(%rbp), %ecx
shll $0x4, %ecx
addl %ecx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: codepoint_to_utf8
static int codepoint_to_utf8(char *utf8, int codepoint)
{
    /* 0xxxxxxx */
    if (codepoint <= 0x7F) {
        utf8[0] = codepoint;
        return 1;
    }

    /* 110xxxxx 10xxxxxx */
    if (codepoint <= 0x7FF) {
        utf8[0] = (codepoint >> 6) | 0xC0;
        utf8[1] = (codepoint & 0x3F) | 0x80;
        return 2;
    }

    /* 1110xxxx 10xxxxxx 10xxxxxx */
    if (codepoint <= 0xFFFF) {
        utf8[0] = (codepoint >> 12) | 0xE0;
        utf8[1] = ((codepoint >> 6) & 0x3F) | 0x80;
        utf8[2] = (codepoint & 0x3F) | 0x80;
        return 3;
    }

    /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
    if (codepoint <= 0x1FFFFF) {
        utf8[0] = (codepoint >> 18) | 0xF0;
        utf8[1] = ((codepoint >> 12) & 0x3F) | 0x80;
        utf8[2] = ((codepoint >> 6) & 0x3F) | 0x80;
        utf8[3] = (codepoint & 0x3F) | 0x80;
        return 4;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x7f, -0x14(%rbp)
jg 0xca8b8
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xca9b2
cmpl $0x7ff, -0x14(%rbp)     # imm = 0x7FF
jg 0xca8f4
movl -0x14(%rbp), %eax
sarl $0x6, %eax
orl $0xc0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0xca9b2
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jg 0xca944
movl -0x14(%rbp), %eax
sarl $0xc, %eax
orl $0xe0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl $0x3, -0x4(%rbp)
jmp 0xca9b2
cmpl $0x1fffff, -0x14(%rbp)  # imm = 0x1FFFFF
jg 0xca9ab
movl -0x14(%rbp), %eax
sarl $0x12, %eax
orl $0xf0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
jmp 0xca9b2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: hexdigit2int
static int hexdigit2int(char hex)
{
    if ('0' <= hex  && hex <= '9')
        return hex - '0';

    /* Force lowercase */
    hex |= 0x20;
    if ('a' <= hex && hex <= 'f')
        return 10 + hex - 'a';

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0xcaa3c
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0xcaa3c
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0xcaa72
movsbl -0x5(%rbp), %eax
orl $0x20, %eax
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0xcaa6b
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0xcaa6b
movsbl -0x5(%rbp), %eax
addl $0xa, %eax
subl $0x61, %eax
movl %eax, -0x4(%rbp)
jmp 0xcaa72
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_parse_object_context
static void json_parse_object_context(lua_State *l, json_parse_t *json)
{
    json_token_t token;

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

    lua_newtable(l);

    json_next_token(json, &token);

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

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

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

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

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

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

        json_next_token(json, &token);

        if (token.type == T_OBJ_END) {
            json_decode_ascend(json);
            return;
        }

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

        json_next_token(json, &token);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0xcac80
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xad9e0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc9f70
cmpl $0x1, -0x28(%rbp)
jne 0xcaad0
movq -0x10(%rbp), %rdi
callq 0xcad10
jmp 0xcaba6
jmp 0xcaad2
cmpl $0x4, -0x28(%rbp)
je 0xcaaf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x80ee6(%rip), %rdx     # 0x14b9cd
leaq -0x28(%rbp), %rcx
callq 0xca2a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0xad390
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc9f70
cmpl $0x8, -0x28(%rbp)
je 0xcab2c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x80ebc(%rip), %rdx     # 0x14b9df
leaq -0x28(%rbp), %rcx
callq 0xca2a0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc9f70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xca1d0
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xadd40
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc9f70
cmpl $0x1, -0x28(%rbp)
jne 0xcab76
movq -0x10(%rbp), %rdi
callq 0xcad10
jmp 0xcaba6
cmpl $0x9, -0x28(%rbp)
je 0xcab94
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x80e5a(%rip), %rdx     # 0x14b9e5
leaq -0x28(%rbp), %rcx
callq 0xca2a0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc9f70
jmp 0xcaad2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_parse_array_context
static void json_parse_array_context(lua_State *l, json_parse_t *json)
{
    json_token_t token;
    int i;

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

    lua_newtable(l);

    json_next_token(json, &token);

    /* Handle empty arrays */
    if (token.type == T_ARR_END) {
        json_decode_ascend(json);
        return;
    }

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

        json_next_token(json, &token);

        if (token.type == T_ARR_END) {
            json_decode_ascend(json);
            return;
        }

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

        json_next_token(json, &token);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0xcac80
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xad9e0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc9f70
cmpl $0x3, -0x28(%rbp)
jne 0xcabfd
movq -0x10(%rbp), %rdi
callq 0xcad10
jmp 0xcac7a
movl $0x1, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xca1d0
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xade10
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc9f70
cmpl $0x3, -0x28(%rbp)
jne 0xcac44
movq -0x10(%rbp), %rdi
callq 0xcad10
jmp 0xcac7a
cmpl $0x9, -0x28(%rbp)
je 0xcac62
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x80ddb(%rip), %rdx     # 0x14ba34
leaq -0x28(%rbp), %rcx
callq 0xca2a0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc9f70
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xcac04
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_decode_descend
static void json_decode_descend(lua_State *l, json_parse_t *json, int slots)
{
    json->current_depth++;

    if (json->current_depth <= json->cfg->decode_max_depth &&
        lua_checkstack(l, slots)) {
        return;
    }

    strbuf_free(json->tmp);
    luaL_error(l, "Found too many nested data structures (%d) at character %d",
        json->current_depth, json->ptr - json->data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x540(%rcx), %eax
jg 0xcacca
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xac2d0
cmpl $0x0, %eax
je 0xcacca
jmp 0xcad02
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd2bb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
leaq 0x80cfe(%rip), %rsi     # 0x14b9f9
movb $0x0, %al
callq 0xc0370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_arg_init
static json_config_t *json_arg_init(lua_State *l, int args)
{
    luaL_argcheck(l, lua_gettop(l) <= args, args + 1,
                  "found too many arguments");

    while (lua_gettop(l) < args)
        lua_pushnil(l);

    return json_fetch_config(l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xac540
movl %eax, %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0xd(%rbp)
jle 0xcad73
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
leaq 0x80d8f(%rip), %rdx     # 0x14baf4
callq 0xc0270
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movq -0x8(%rbp), %rdi
callq 0xac540
cmpl -0xc(%rbp), %eax
jge 0xcad8f
movq -0x8(%rbp), %rdi
callq 0xad2c0
jmp 0xcad76
movq -0x8(%rbp), %rdi
callq 0xc9500
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_enum_option
static int json_enum_option(lua_State *l, int optindex, int *setting,
                            const char **options, int bool_true)
{
    static const char *bool_options[] = { "off", "on", NULL };

    if (!options) {
        options = bool_options;
        bool_true = 1;
    }

    if (!lua_isnil(l, optindex)) {
        if (bool_true && lua_isboolean(l, optindex))
            *setting = lua_toboolean(l, optindex) * bool_true;
        else
            *setting = luaL_checkoption(l, optindex, NULL, options);
    }

    if (bool_true && (*setting == 0 || *setting == bool_true))
        lua_pushboolean(l, *setting);
    else
        lua_pushstring(l, options[*setting]);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcadd4
leaq 0xad327(%rip), %rax     # 0x1780f0
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xacaa0
cmpl $0x0, %eax
je 0xcae34
cmpl $0x0, -0x24(%rbp)
je 0xcae16
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xacaa0
cmpl $0x1, %eax
jne 0xcae16
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xacf00
movl %eax, %ecx
imull -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xcae32
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xc0540
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xcae34
cmpl $0x0, -0x24(%rbp)
je 0xcae5f
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xcae4e
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0xcae5f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xad710
jmp 0xcae77
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xad410
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_integer_option
static int json_integer_option(lua_State *l, int optindex, int *setting,
                               int min, int max)
{
    char errmsg[64];
    int value;

    if (!lua_isnil(l, optindex)) {
        value = luaL_checkinteger(l, optindex);
        snprintf(errmsg, sizeof(errmsg), "expected integer between %d and %d", min, max);
        luaL_argcheck(l, min <= value && value <= max, 1, errmsg);
        *setting = value;
    }

    lua_pushinteger(l, *setting);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xacaa0
cmpl $0x0, %eax
je 0xcaf24
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc09f0
movl %eax, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl $0x40, %esi
leaq 0x80c2c(%rip), %rdx     # 0x14bb0d
movb $0x0, %al
callq 0x26120
movl -0x1c(%rbp), %eax
cmpl -0x64(%rbp), %eax
jg 0xcaefd
movl -0x64(%rbp), %ecx
movb $0x1, %al
cmpl -0x20(%rbp), %ecx
movb %al, -0x65(%rbp)
jle 0xcaf18
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rdx
movl $0x1, %esi
callq 0xc0270
cmpl $0x0, %eax
setne %al
movb %al, -0x65(%rbp)
movb -0x65(%rbp), %al
movl -0x64(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0xad340
movl $0x1, %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xad160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcaf75
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
callq 0xd2bb0
movq $0x0, -0x10(%rbp)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_protect_conversion
static int json_protect_conversion(lua_State *l)
{
    int err;

    /* Deliberately throw an error for invalid arguments */
    luaL_argcheck(l, lua_gettop(l) == 1, 1, "expected 1 argument");

    /* pcall() the function stored as upvalue(1) */
    lua_pushvalue(l, lua_upvalueindex(1));
    lua_insert(l, 1);
    err = lua_pcall(l, 1, 1, 0);
    if (!err)
        return 1;

    if (err == LUA_ERRRUN) {
        lua_pushnil(l);
        lua_insert(l, -2);
        return 2;
    }

    /* Since we are not using a custom error handler, the only remaining
     * errors are memory related */
    return luaL_error(l, "Memory allocation error in CJSON protected call");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xac540
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x15(%rbp)
je 0xcafcf
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x8075d(%rip), %rdx     # 0x14b71e
callq 0xc0270
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movq -0x10(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0xaca40
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xac800
movq -0x10(%rbp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movl %edx, %esi
callq 0xae1c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xcb012
movl $0x1, -0x4(%rbp)
jmp 0xcb04d
cmpl $0x2, -0x14(%rbp)
jne 0xcb038
movq -0x10(%rbp), %rdi
callq 0xad2c0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xac800
movl $0x2, -0x4(%rbp)
jmp 0xcb04d
movq -0x10(%rbp), %rdi
leaq 0x80aff(%rip), %rsi     # 0x14bb42
movb $0x0, %al
callq 0xc0370
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xc06a0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movsbl 0x805e3(%rip), %eax     # 0x14be84
movl %eax, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xcb980
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
leaq -0x18(%rbp), %rdx
movsbl %al, %esi
callq 0xcb9a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
leaq -0x10(%rbp), %rsi
callq 0xcbaa0
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x73, -0x24(%rbp)
jne 0xcb91f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x80652(%rip), %rdx     # 0x14bf6a
callq 0xc0270
jmp 0xcb943
cmpl $0x63, -0x24(%rbp)
jne 0xcb941
cmpq $0x0, -0x30(%rbp)
jne 0xcb941
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x8064b(%rip), %rdx     # 0x14bf87
callq 0xc0270
jmp 0xcb943
callq 0x26550
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xcb96f
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x10(%rbp), %rcx
callq 0xcbca0
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xcb8ab
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xad340
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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(L, fmt, 1);
    case 'i': case 'I': {
      int sz = getnum(L, 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
addl $-0x42, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x36, %eax
ja 0xcba88
movq -0x30(%rbp), %rax
leaq 0x80355(%rip), %rcx     # 0x14bd2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x1, -0x8(%rbp)
jmp 0xcba90
movq $0x2, -0x8(%rbp)
jmp 0xcba90
movq $0x8, -0x8(%rbp)
jmp 0xcba90
movq $0x8, -0x8(%rbp)
jmp 0xcba90
movq $0x4, -0x8(%rbp)
jmp 0xcba90
movq $0x8, -0x8(%rbp)
jmp 0xcba90
movq $0x1, -0x8(%rbp)
jmp 0xcba90
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0xcbd80
cltq
movq %rax, -0x8(%rbp)
jmp 0xcba90
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0xcbd80
movl %eax, -0x24(%rbp)
cmpl $0x20, -0x24(%rbp)
jle 0xcba7e
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x80416(%rip), %rsi     # 0x14be88
movl $0x20, %ecx
movb $0x0, %al
callq 0xc0370
movslq -0x24(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcba90
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_struct.c
// Function: gettoalign
static int gettoalign (size_t len, Header *h, int opt, size_t size) {
  if (size == 0 || opt == 'c') return 0;
  if (size > (size_t)h->align)
    size = h->align;  /* respect max. alignment */
  return (size - (len & (size - 1))) & (size - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xcbac0
cmpl $0x63, -0x1c(%rbp)
jne 0xcbac9
movl $0x0, -0x4(%rbp)
jmp 0xcbb0a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
jbe 0xcbae6
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
andq %rdx, %rcx
subq %rcx, %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_struct.c
// Function: putinteger
static void putinteger (lua_State *L, luaL_Buffer *b, int arg, int endian,
                        int size) {
  lua_Number n = luaL_checknumber(L, arg);
  Uinttype value;
  char buff[MAXINTSIZE];
  if (n < 0)
    value = (Uinttype)(Inttype)n;
  else
    value = (Uinttype)n;
  if (endian == LITTLE) {
    int i;
    for (i = 0; i < size; i++) {
      buff[i] = (value & 0xff);
      value >>= 8;
    }
  }
  else {
    int i;
    for (i = size - 1; i >= 0; i--) {
      buff[i] = (value & 0xff);
      value >>= 8;
    }
  }
  luaL_addlstring(b, buff, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc0940
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0xcbb51
cvttsd2si -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xcbb80
movsd -0x28(%rbp), %xmm0
movsd 0x7bc3a(%rip), %xmm2    # 0x147798
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0xcbbc2
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xcbbc0
movq -0x30(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movslq -0x54(%rbp), %rax
movb %cl, -0x50(%rbp,%rax)
movq -0x30(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xcbb8d
jmp 0xcbbfe
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
jl 0xcbbfc
movq -0x30(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movslq -0x58(%rbp), %rax
movb %cl, -0x50(%rbp,%rax)
movq -0x30(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x58(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xcbbcb
jmp 0xcbbfe
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0xc1030
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_struct.c
// Function: correctbytes
static void correctbytes (char *b, int size, int endian) {
  if (endian != native.endian) {
    int i = 0;
    while (i < --size) {
      char temp = b[i];
      b[i++] = b[size];
      b[size] = temp;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movsbl 0x8024c(%rip), %ecx     # 0x14be84
cmpl %ecx, %eax
je 0xcbc93
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl %ecx, %eax
jge 0xcbc91
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x15(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xcbc43
jmp 0xcbc93
popq %rbp
retq
nopw %cs:(%rax,%rax)