LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0x860ba
testl %eax, %eax
je 0x98664
movq %rbx, %rdi
movl %r15d, %esi
callq 0x915e4
movq %rax, %r15
leaq 0x395c0(%rip), %rdx     # 0xd1bea
movq %rsp, %rdi
movl $0x40, %esi
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x26120
cmpl %r12d, %r15d
setge %al
cmpl %ebp, %r15d
setle %cl
testb %cl, %al
jne 0x9865f
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x91090
movl %r15d, (%r14)
jmp 0x98667
movl (%r14), %r15d
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x864b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movl $0x1, %esi
callq 0x863eb
testq %rax, %rax
je 0x9869d
addq $0x500, %rax            # imm = 0x500
movq %rax, %rdi
callq 0x9d0c9
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x85d4c
cmpl $0x1, %eax
je 0x986c5
leaq 0x39146(%rip), %rdx     # 0xd17fe
movq %rbx, %rdi
movl $0x1, %esi
callq 0x91090
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x8609a
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x85f9e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x86bad
testl %eax, %eax
je 0x9871b
cmpl $0x2, %eax
jne 0x98724
movq %rbx, %rdi
callq 0x86487
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x85f9e
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x394f4(%rip), %rsi     # 0xd1c1f
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x91147
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
movl $0x1, %esi
xorl %edx, %edx
callq 0x91394
movl $0x1, 0x14(%rsp)
movb (%rax), %r13b
testb %r13b, %r13b
je 0x98ff3
xorl %r15d, %r15d
incq %rax
movq %rax, 0x8(%rsp)
movsbl %r13b, %ebp
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x8(%rsp), %rdx
callq 0x99012
movq %rax, %r12
testq %rax, %rax
sete %al
cmpb $0x63, %bpl
sete %cl
orb %al, %cl
je 0x98f67
xorl %r14d, %r14d
jmp 0x98f82
movslq 0x14(%rsp), %rax
cmpq %r12, %rax
cmovaeq %r12, %rax
leal -0x1(%rax), %ecx
movl %r15d, %edx
andl %ecx, %edx
subl %edx, %eax
andl %ecx, %eax
movslq %eax, %r14
leaq 0x38e65(%rip), %rdx     # 0xd1dee
cmpb $0x73, %r13b
je 0x98fa7
cmpb $0x63, %r13b
setne %al
testq %r12, %r12
setne %cl
orb %al, %cl
leaq 0x38e66(%rip), %rdx     # 0xd1e0b
jne 0x98fb4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x91090
callq 0x26560
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x8, (%rax,%rcx,2)
jne 0x98fd9
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x990c5
addq %r15, %r12
addq %r14, %r12
movq 0x8(%rsp), %rax
movb (%rax), %r13b
movq %r12, %r15
testb %r13b, %r13b
jne 0x98f33
movq %rbx, %rdi
movq %r12, %rsi
callq 0x864b0
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_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %eax
cmpl $0x53, %esi
jle 0x9904e
leal -0x62(%rsi), %ecx
cmpl $0xa, %ecx
ja 0x990a4
leaq 0x38caf(%rip), %rsi     # 0xd1ce0
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq %rbx, %rdi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x9918d
cltq
jmp 0x990b7
cmpl $0x48, %esi
jg 0x99064
cmpl $0x42, %esi
je 0x990b7
cmpl $0x48, %esi
jne 0x990ae
movl $0x2, %eax
jmp 0x990b7
cmpl $0x49, %esi
je 0x99070
cmpl $0x4c, %esi
je 0x990b2
jmp 0x990ae
movq %rbx, %rdi
movq %rdx, %rsi
movl $0x4, %edx
callq 0x9918d
movl %eax, %ebp
cmpl $0x21, %eax
jl 0x9909f
leaq 0x38c7e(%rip), %rsi     # 0xd1d0c
movq %rbx, %rdi
movl %ebp, %edx
movl $0x20, %ecx
xorl %eax, %eax
callq 0x91147
movslq %ebp, %rax
jmp 0x990b7
cmpl $0x54, %esi
je 0x990b2
cmpl $0x78, %esi
je 0x990b7
xorl %eax, %eax
jmp 0x990b7
movl $0x8, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x4, %eax
jmp 0x990b7
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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(L, 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 0x99149
cmpl $0x20, %eax
je 0x99188
cmpl $0x21, %eax
jne 0x9915b
movq %r14, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x9918d
movl %eax, %ebp
testl %eax, %eax
jle 0x99131
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 0x99144
leaq 0x38c17(%rip), %rsi     # 0xd1d4f
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x91147
movl %ebp, 0x4(%rbx)
jmp 0x99188
cmpl $0x3c, %eax
je 0x99182
cmpl $0x3e, %eax
jne 0x9915b
movl $0x0, (%rbx)
jmp 0x99188
leaq 0x38c0e(%rip), %rsi     # 0xd1d70
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x8659f
movq %r14, %rdi
movl $0x1, %esi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x91090
movl $0x1, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_struct.c
// Function: getnum
static int getnum (lua_State *L, const char **fmt, int df) {
  if (!isdigit(**fmt))  /* no number? */
    return df;  /* return default value */
  else {
    int a = 0;
    do {
      if (a > (INT_MAX / 10) || a * 10 > (INT_MAX - (**fmt - '0')))
        luaL_error(L, "integral size overflow");
      a = a*10 + *((*fmt)++) - '0';
    } while (isdigit(**fmt));
    return a;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x26560
movq %rax, %r15
movq (%rax), %rdx
movq (%rbx), %rax
movsbq (%rax), %rcx
testb $0x8, 0x1(%rdx,%rcx,2)
je 0x9921a
leaq 0x38b77(%rip), %r12     # 0xd1d38
xorl %r13d, %r13d
leal (,%r13,2), %edx
leal (%rdx,%rdx,4), %ebp
cmpl $0xccccccc, %r13d       # imm = 0xCCCCCCC
jg 0x991e6
movsbl %cl, %ecx
movl $0x8000002f, %edx       # imm = 0x8000002F
subl %ecx, %edx
cmpl %edx, %ebp
jle 0x991f6
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x91147
movq (%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movsbl (%rax), %ecx
leal (%rcx,%rbp), %r13d
addl $-0x30, %r13d
movq (%r15), %rsi
movsbq 0x1(%rax), %rcx
testb $0x8, 0x1(%rsi,%rcx,2)
movq %rdx, %rax
jne 0x991c4
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: memrevifle
void memrevifle(void *ptr, size_t len) {
    unsigned char   *p = (unsigned char *)ptr,
                    *e = (unsigned char *)p+len-1,
                    aux;
    int test = 1;
    unsigned char *testp = (unsigned char*) &test;

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

// Assembly:
cmpq $0x2, %rsi
jb 0x99258
leaq (%rsi,%rdi), %rax
decq %rax
shrq %rsi
negq %rsi
xorl %ecx, %ecx
movb (%rdi), %dl
movb (%rax,%rcx), %r8b
movb %r8b, (%rdi)
movb %dl, (%rax,%rcx)
incq %rdi
decq %rcx
cmpq %rcx, %rsi
jne 0x99241
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_buf_new
mp_buf *mp_buf_new(lua_State *L) {
    mp_buf *buf = NULL;

    /* Old size = 0; new size = sizeof(*buf) */
    buf = (mp_buf*)mp_realloc(L, NULL, 0, sizeof(*buf));

    buf->b = NULL;
    buf->len = buf->free = 0;
    return buf;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x86ee7
movq (%rbx), %rdi
movl $0x18, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq *%rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_buf_append
void mp_buf_append(lua_State *L, mp_buf *buf, const unsigned char *s, size_t len) {
    if (buf->free < len) {
        size_t newsize = (buf->len+len)*2;

        buf->b = (unsigned char*)mp_realloc(L, buf->b, buf->len + buf->free, newsize);
        buf->free = newsize - buf->len;
    }
    memcpy(buf->b+buf->len,s,len);
    buf->len += len;
    buf->free -= len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rax
movq 0x10(%rsi), %r13
movq (%rsi), %r12
movq 0x8(%rsi), %rdi
cmpq %rcx, %r13
jae 0x99322
leaq (%rdi,%rbx), %rbp
addq %rbp, %rbp
addq %rdi, %r13
movq %rsp, %rsi
movq %rax, %rdi
callq 0x86ee7
movq %rsp, %rcx
movq (%rcx), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq *%rax
movq %rax, %r12
movq %rax, (%r14)
movq 0x8(%r14), %rdi
subq %rdi, %rbp
movq %rbp, 0x10(%r14)
addq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26c50
addq %rbx, 0x8(%r14)
subq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_bytes
void mp_encode_bytes(lua_State *L, mp_buf *buf, const unsigned char *s, size_t len) {
    unsigned char hdr[5];
    int hdrlen;

    if (len < 32) {
        hdr[0] = 0xa0 | (len&0xff); /* fix raw */
        hdrlen = 1;
    } else if (len <= 0xff) {
        hdr[0] = 0xd9;
        hdr[1] = len;
        hdrlen = 2;
    } else if (len <= 0xffff) {
        hdr[0] = 0xda;
        hdr[1] = (len&0xff00)>>8;
        hdr[2] = len&0xff;
        hdrlen = 3;
    } else {
        hdr[0] = 0xdb;
        hdr[1] = (len&0xff000000)>>24;
        hdr[2] = (len&0xff0000)>>16;
        hdr[3] = (len&0xff00)>>8;
        hdr[4] = len&0xff;
        hdrlen = 5;
    }
    mp_buf_append(L,buf,hdr,hdrlen);
    mp_buf_append(L,buf,s,len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x1f, %rcx
ja 0x993e5
movl %ebx, %eax
orb $-0x60, %al
movb %al, 0x3(%rsp)
movl $0x1, %ecx
jmp 0x9943f
cmpq $0xff, %rbx
ja 0x993fe
movb $-0x27, 0x3(%rsp)
movb %bl, 0x4(%rsp)
movl $0x2, %ecx
jmp 0x9943f
cmpq $0xffff, %rbx           # imm = 0xFFFF
ja 0x9941b
movb $-0x26, 0x3(%rsp)
movb %bh, 0x4(%rsp)
movb %bl, 0x5(%rsp)
movl $0x3, %ecx
jmp 0x9943f
movb $-0x25, 0x3(%rsp)
movl %ebx, %eax
shrl $0x18, %eax
movb %al, 0x4(%rsp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x5(%rsp)
movb %bh, 0x6(%rsp)
movb %bl, 0x7(%rsp)
movl $0x5, %ecx
leaq 0x3(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x992c4
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x992c4
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_double
void mp_encode_double(lua_State *L, mp_buf *buf, double d) {
    unsigned char b[9];
    float f = d;

    assert(sizeof(f) == 4 && sizeof(d) == 8);
    if (d == (double)f) {
        b[0] = 0xca;    /* float IEEE 754 */
        memcpy(b+1,&f,4);
        memrevifle(b+1,4);
        mp_buf_append(L,buf,b,5);
    } else if (sizeof(d) == 8) {
        b[0] = 0xcb;    /* double IEEE 754 */
        memcpy(b+1,&d,8);
        memrevifle(b+1,8);
        mp_buf_append(L,buf,b,9);
    }
}

// Assembly:
subq $0x18, %rsp
cvtsd2ss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
leaq 0x10(%rsp), %rax
jne 0x994b5
jp 0x994b5
movb $-0x36, 0xf(%rsp)
movss %xmm1, 0x10(%rsp)
movl $0x4, %ecx
movb (%rax), %dl
movb 0xf(%rsp,%rcx), %r8b
movb %r8b, (%rax)
movb %dl, 0xf(%rsp,%rcx)
incq %rax
decq %rcx
cmpq $0x2, %rcx
jne 0x99494
movl $0x5, %ecx
jmp 0x994e4
movb $-0x35, 0xf(%rsp)
movsd %xmm0, 0x10(%rsp)
movl $0x8, %ecx
movb (%rax), %dl
movb 0xf(%rsp,%rcx), %r8b
movb %r8b, (%rax)
movb %dl, 0xf(%rsp,%rcx)
incq %rax
decq %rcx
cmpq $0x4, %rcx
jne 0x994c5
movl $0x9, %ecx
leaq 0xf(%rsp), %rdx
callq 0x992c4
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_array
void mp_encode_array(lua_State *L, mp_buf *buf, int64_t n) {
    unsigned char b[5];
    int enclen;

    if (n <= 15) {
        b[0] = 0x90 | (n & 0xf);    /* fix array */
        enclen = 1;
    } else if (n <= 65535) {
        b[0] = 0xdc;                /* array 16 */
        b[1] = (n & 0xff00) >> 8;
        b[2] = n & 0xff;
        enclen = 3;
    } else {
        b[0] = 0xdd;                /* array 32 */
        b[1] = (n & 0xff000000) >> 24;
        b[2] = (n & 0xff0000) >> 16;
        b[3] = (n & 0xff00) >> 8;
        b[4] = n & 0xff;
        enclen = 5;
    }
    mp_buf_append(L,buf,b,enclen);
}

// Assembly:
pushq %rax
cmpq $0xf, %rdx
jg 0x9964d
andb $0xf, %dl
orb $-0x70, %dl
movb %dl, 0x3(%rsp)
movl $0x1, %ecx
jmp 0x9968e
cmpq $0xffff, %rdx           # imm = 0xFFFF
ja 0x9966a
movb $-0x24, 0x3(%rsp)
movb %dh, 0x4(%rsp)
movb %dl, 0x5(%rsp)
movl $0x3, %ecx
jmp 0x9968e
movb $-0x23, 0x3(%rsp)
movl %edx, %eax
shrl $0x18, %eax
movb %al, 0x4(%rsp)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x5(%rsp)
movb %dh, 0x6(%rsp)
movb %dl, 0x7(%rsp)
movl $0x5, %ecx
leaq 0x3(%rsp), %rdx
callq 0x992c4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_map
void mp_encode_map(lua_State *L, mp_buf *buf, int64_t n) {
    unsigned char b[5];
    int enclen;

    if (n <= 15) {
        b[0] = 0x80 | (n & 0xf);    /* fix map */
        enclen = 1;
    } else if (n <= 65535) {
        b[0] = 0xde;                /* map 16 */
        b[1] = (n & 0xff00) >> 8;
        b[2] = n & 0xff;
        enclen = 3;
    } else {
        b[0] = 0xdf;                /* map 32 */
        b[1] = (n & 0xff000000) >> 24;
        b[2] = (n & 0xff0000) >> 16;
        b[3] = (n & 0xff00) >> 8;
        b[4] = n & 0xff;
        enclen = 5;
    }
    mp_buf_append(L,buf,b,enclen);
}

// Assembly:
pushq %rax
cmpq $0xf, %rdx
jg 0x996b2
andb $0xf, %dl
orb $-0x80, %dl
movb %dl, 0x3(%rsp)
movl $0x1, %ecx
jmp 0x996f3
cmpq $0xffff, %rdx           # imm = 0xFFFF
ja 0x996cf
movb $-0x22, 0x3(%rsp)
movb %dh, 0x4(%rsp)
movb %dl, 0x5(%rsp)
movl $0x3, %ecx
jmp 0x996f3
movb $-0x21, 0x3(%rsp)
movl %edx, %eax
shrl $0x18, %eax
movb %al, 0x4(%rsp)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x5(%rsp)
movb %dh, 0x6(%rsp)
movb %dl, 0x7(%rsp)
movl $0x5, %ecx
leaq 0x3(%rsp), %rdx
callq 0x992c4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_lua_number
void mp_encode_lua_number(lua_State *L, mp_buf *buf) {
    lua_Number n = lua_tonumber(L,-1);

    if (IS_INT64_EQUIVALENT(n)) {
        mp_encode_lua_integer(L, buf);
    } else {
        mp_encode_double(L,buf,(double)n);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x86274
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
je 0x997ff
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x997ff
jp 0x997ff
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x862a3
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x994f3
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9946b
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_lua_table_as_array
void mp_encode_lua_table_as_array(lua_State *L, mp_buf *buf, int level) {
#if LUA_VERSION_NUM < 502
    size_t len = lua_objlen(L,-1), j;
#else
    size_t len = lua_rawlen(L,-1), j;
#endif

    mp_encode_array(L,buf,len);
    for (j = 1; j <= len; j++) {
        lua_pushnumber(L,j);
        lua_gettable(L,-2);
        mp_encode_lua_type(L,buf,level+1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x86369
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x99635
testq %r12, %r12
je 0x99895
incl %ebx
movl $0x1, %r13d
movq %r13, %xmm1
punpckldq 0x29109(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x29111(%rip), %xmm1    # 0xc2970
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %r15, %rdi
callq 0x8649b
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8673f
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9989f
incq %r13
cmpq %r12, %r13
jbe 0x9984a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_lua_type
void mp_encode_lua_type(lua_State *L, mp_buf *buf, int level) {
    int t = lua_type(L,-1);

    /* Limit the encoding of nested tables to a specified maximum depth, so that
     * we survive when called against circular references in tables. */
    if (t == LUA_TTABLE && level == LUACMSGPACK_MAX_NESTING) t = LUA_TNIL;
    switch(t) {
    case LUA_TSTRING: mp_encode_lua_string(L,buf); break;
    case LUA_TBOOLEAN: mp_encode_lua_bool(L,buf); break;
    case LUA_TNUMBER:
    #if LUA_VERSION_NUM < 503
        mp_encode_lua_number(L,buf); break;
    #else
        if (lua_isinteger(L, -1)) {
            mp_encode_lua_integer(L, buf);
        } else {
            mp_encode_lua_number(L, buf);
        }
        break;
    #endif
    case LUA_TTABLE: mp_encode_lua_table(L,buf,level); break;
    default: mp_encode_lua_null(L,buf); break;
    }
    lua_pop(L,1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x860ba
movl %eax, %edx
xorl $0x5, %edx
movl %ebp, %esi
xorl $0x10, %esi
xorl %ecx, %ecx
orl %edx, %esi
cmovnel %eax, %ecx
decl %ecx
cmpl $0x4, %ecx
ja 0x99944
leaq 0x38552(%rip), %rax     # 0xd1e2c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x862d2
testl %eax, %eax
sete %al
xorb $-0x3d, %al
leaq 0xe(%rsp), %rdx
movb %al, (%rdx)
jmp 0x9994c
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x862f8
movq (%r15), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x993bc
jmp 0x9995c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9979e
jmp 0x9995c
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x99b68
jmp 0x9995c
leaq 0xf(%rsp), %rdx
movb $-0x40, (%rdx)
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x992c4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x85d59
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_lua_table_as_map
void mp_encode_lua_table_as_map(lua_State *L, mp_buf *buf, int level) {
    size_t len = 0;

    /* First step: count keys into table. No other way to do it with the
     * Lua API, we need to iterate a first time. Note that an alternative
     * would be to do a single run, and then hack the buffer to insert the
     * map opcodes for message pack. Too hackish for this lib. */
    lua_pushnil(L);
    while(lua_next(L,-2)) {
        lua_pop(L,1); /* remove value, keep key for next iteration. */
        len++;
    }

    /* Step two: actually encoding of the map. */
    mp_encode_map(L,buf,len);
    lua_pushnil(L);
    while(lua_next(L,-2)) {
        /* Stack: ... key value */
        lua_pushvalue(L,-2); /* Stack: ... key value key */
        mp_encode_lua_type(L,buf,level+1); /* encode key */
        mp_encode_lua_type(L,buf,level+1); /* encode val */
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x86487
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x86e33
xorl %r12d, %r12d
movq %r15, %rdi
testl %eax, %eax
je 0x999bc
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x85d59
incq %r12
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x86e33
jmp 0x99999
movq %r14, %rsi
movq %r12, %rdx
callq 0x9969a
movq %r15, %rdi
callq 0x86487
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x86e33
testl %eax, %eax
je 0x99a1a
incl %ebx
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8609a
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9989f
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9989f
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x86e33
testl %eax, %eax
jne 0x999e2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: table_is_an_array
int table_is_an_array(lua_State *L) {
    int count = 0, max = 0;
#if LUA_VERSION_NUM < 503
    lua_Number n;
#else
    lua_Integer n;
#endif

    /* Stack top on function entry */
    int stacktop;

    stacktop = lua_gettop(L);

    lua_pushnil(L);
    while(lua_next(L,-2)) {
        /* Stack: ... key value */
        lua_pop(L,1); /* Stack: ... key */
        /* The <= 0 check is valid here because we're comparing indexes. */
#if LUA_VERSION_NUM < 503
        if ((LUA_TNUMBER != lua_type(L,-1)) || (n = lua_tonumber(L, -1)) <= 0 ||
            !IS_INT_EQUIVALENT(n))
#else
        if (!lua_isinteger(L,-1) || (n = lua_tointeger(L, -1)) <= 0)
#endif
        {
            lua_settop(L, stacktop);
            return 0;
        }
        max = (n > max ? n : max);
        count++;
    }
    /* We have the total number of elements in "count". Also we have
     * the max index encountered in "max". We can't reach this code
     * if there are indexes <= 0. If you also note that there can not be
     * repeated keys into a table, you have that if max==count you are sure
     * that there are all the keys form 1 to count (both included). */
    lua_settop(L, stacktop);
    return max == count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x85d4c
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
callq 0x86487
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x86e33
testl %eax, %eax
je 0x99b3f
xorl %r14d, %r14d
movabsq $-0x10000000000000, %r12 # imm = 0xFFF0000000000000
movabsq $0xfffffffffffff, %r13  # imm = 0xFFFFFFFFFFFFF
movabsq $0x7ff0000000000000, %rbp # imm = 0x7FF0000000000000
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x85d59
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x860ba
cmpl $0x3, %eax
jne 0x99b2f
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x86274
movq %xmm0, %rax
testq %rax, %rax
sets %cl
btrq $0x3f, %rax
leaq (%rax,%r12), %rdx
shrq $0x35, %rdx
cmpl $0x3ff, %edx            # imm = 0x3FF
setb %dl
andb %cl, %dl
leaq -0x1(%rax), %rsi
cmpq %r13, %rsi
setb %sil
andb %cl, %sil
testq %rax, %rax
sete %cl
cmpq %rbp, %rax
sete %al
orb %cl, %al
orb %sil, %al
orb %dl, %al
jne 0x99b2f
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x99b2f
jp 0x99b2f
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %r15d
incl %r14d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x86e33
testl %eax, %eax
jne 0x99a7e
jmp 0x99b45
movq %rbx, %rdi
movl 0x4(%rsp), %esi
callq 0x85d59
xorl %eax, %eax
jmp 0x99b59
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %rbx, %rdi
movl 0x4(%rsp), %esi
callq 0x85d59
xorl %eax, %eax
cmpl %r14d, %r15d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_encode_lua_table
void mp_encode_lua_table(lua_State *L, mp_buf *buf, int level) {
    if (table_is_an_array(L))
        mp_encode_lua_table_as_array(L,buf,level);
    else
        mp_encode_lua_table_as_map(L,buf,level);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x99a26
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
testl %eax, %eax
je 0x99b90
popq %rbx
popq %r14
popq %r15
jmp 0x99811
popq %rbx
popq %r14
popq %r15
jmp 0x99974
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_pack
int mp_pack(lua_State *L) {
    int nargs = lua_gettop(L);
    int i;
    mp_buf *buf;

    if (nargs == 0)
        return luaL_argerror(L, 0, "MessagePack pack needs input.");

    buf = mp_buf_new(L);
    for(i = 1; i <= nargs; i++) {
        /* Copy argument i to top of stack for _encode processing;
         * the encode function pops it from the stack when complete. */
        lua_pushvalue(L, i);

        mp_encode_lua_type(L,buf,0);

        lua_pushlstring(L,(char*)buf->b,buf->len);

        /* Reuse the buffer for the next operation by
         * setting its free count to the total buffer size
         * and the current position to zero. */
        buf->free += buf->len;
        buf->len = 0;
    }
    mp_buf_free(L, buf);

    /* Concatenate all nargs buffers together */
    lua_concat(L, nargs);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x85d4c
testl %eax, %eax
je 0x99c7d
movl %eax, %ebp
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x86ee7
movq (%r14), %rdi
movl $0x18, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq *%rax
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
testl %ebp, %ebp
jle 0x99c56
movl %ebp, %r12d
negl %r12d
movl $0x1, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8609a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x9989f
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x864ca
movq 0x8(%r14), %rax
addq %rax, 0x10(%r14)
movq $0x0, 0x8(%r14)
leal (%r12,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x99c0c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x99347
movq %rbx, %rdi
movl %ebp, %esi
callq 0x86e6a
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3823c(%rip), %rdx     # 0xd1ec0
movq %rbx, %rdi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x91090
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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) {
    assert(len <= UINT_MAX);
    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, %rax
shrq $0x20, %rax
jne 0x99d0c
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
callq 0x86818
testq %rbx, %rbx
je 0x99d00
xorl %r12d, %r12d
leal 0x1(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq %r15, %rdi
callq 0x8649b
movq %r15, %rdi
movq %r14, %rsi
callq 0x99d2b
cmpl $0x0, 0x10(%r14)
jne 0x99d00
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x86914
incq %r12
cmpq %r12, %rbx
jne 0x99cc5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x381cb(%rip), %rdi     # 0xd1ede
leaq 0x381d4(%rip), %rsi     # 0xd1eee
leaq 0x381dc(%rip), %rcx     # 0xd1efd
movl $0x222, %edx            # imm = 0x222
callq 0x262d0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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) {
    assert(len <= UINT_MAX);
    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, %rax
shrq $0x20, %rax
jne 0x9a195
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
callq 0x86818
testq %rbx, %rbx
je 0x9a18f
movq %r15, %rdi
movq %r14, %rsi
callq 0x99d2b
cmpl $0x0, 0x10(%r14)
jne 0x9a18f
movq %r15, %rdi
movq %r14, %rsi
callq 0x99d2b
cmpl $0x0, 0x10(%r14)
jne 0x9a18f
decq %rbx
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x86914
jmp 0x9a154
popq %rbx
popq %r14
popq %r15
retq
leaq 0x37d42(%rip), %rdi     # 0xd1ede
leaq 0x37d4b(%rip), %rsi     # 0xd1eee
leaq 0x37d8e(%rip), %rcx     # 0xd1f38
movl $0x22f, %edx            # imm = 0x22F
callq 0x262d0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: luaopen_cmsgpack_safe
LUALIB_API int luaopen_cmsgpack_safe(lua_State *L) {
    int i;

    luaopen_cmsgpack(L);

    /* Wrap all functions in the safe handler */
    for (i = 0; i < (sizeof(cmds)/sizeof(*cmds) - 1); i++) {
        lua_getfield(L, -1, cmds[i].name);
        lua_pushcclosure(L, mp_safe, 1);
        lua_setfield(L, -2, cmds[i].name);
    }

#if LUA_VERSION_NUM < 502
    /* Register name globally for 5.1 */
    lua_pushvalue(L, -1);
    lua_setglobal(L, LUACMSGPACK_SAFE_NAME);
#endif

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x9a4cb
xorl %r12d, %r12d
leaq 0x60c59(%rip), %r13     # 0xfb170
leaq -0x1b6(%rip), %r14      # 0x9a368
movq (%r12,%r13), %r15
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x8675f
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x8664f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x8693b
addq $0x10, %r12
cmpq $0x40, %r12
jne 0x9a51e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8609a
leaq 0x37b78(%rip), %rdx     # 0xd20e8
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x8693b
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua_bit.c
// Function: bit_tohex
static int bit_tohex(lua_State *L)
{
  UBits b = barg(L, 1);
  SBits n = lua_isnone(L, 2) ? 8 : (SBits)barg(L, 2);
  const char *hexdigits = "0123456789abcdef";
  char buf[8];
  int i;
  if (n < 0) { n = -n; hexdigits = "0123456789ABCDEF"; }
  if (n > 8) n = 8;
  for (i = (int)n; --i >= 0; ) { buf[i] = hexdigits[b & 15]; b >>= 4; }
  lua_pushlstring(L, buf, (size_t)n);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x9a5f6
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x860ba
cmpl $-0x1, %eax
je 0x9a911
movq %rbx, %rdi
movl $0x2, %esi
callq 0x9a5f6
leaq 0x378aa(%rip), %rdx     # 0xd21a8
leaq 0x2618e(%rip), %rcx     # 0xc0a93
testl %eax, %eax
cmovsq %rdx, %rcx
jne 0x9a91d
xorl %eax, %eax
jmp 0x9a950
movl $0x8, %eax
leaq 0x26176(%rip), %rcx     # 0xc0a93
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
cmpl $0x8, %edx
movl $0x8, %esi
cmovll %edx, %esi
leal 0x1(%rsi), %edx
decl %esi
addq %rsp, %rsi
movl %ebp, %edi
andl $0xf, %edi
movb (%rcx,%rdi), %dil
movb %dil, (%rsi)
shrl $0x4, %ebp
decl %edx
decq %rsi
cmpl $0x1, %edx
jg 0x9a937
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x8, %ecx
movl $0x8, %edx
cmovbl %ecx, %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x864ca
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/strbuf.c
// Function: die
static 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 0x9d022
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 0x5ff7f(%rip), %rbx     # 0xfcfc8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x26460
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x264a0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x262c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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 0x26360
testq %rax, %rax
je 0x9d0a0
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x9cf7c
movl $0x1, 0x14(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x32d9f(%rip), %rdi     # 0xcfe46
xorl %eax, %eax
callq 0x9cfc3
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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 0x9d0f8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9d0e7
callq 0x264d0
movq $0x0, (%rbx)
cmpl $0x0, 0x14(%rbx)
je 0x9d0f6
movq %rbx, %rdi
popq %rbx
jmp 0x264d0
popq %rbx
retq
movq %rbx, %rdi
callq 0x27740
jmp 0x9d0d3
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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 0x9d143
movq (%rbx), %rax
movslq 0xc(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %r15
testq %r14, %r14
je 0x9d12c
movl 0xc(%rbx), %eax
movl %eax, (%r14)
cmpl $0x0, 0x14(%rbx)
je 0x9d13a
movq %rbx, %rdi
callq 0x264d0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x27766
jmp 0x9d113
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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 0x9d1cd
movq %rdi, %rbx
leal 0x1(%rsi), %ebp
movl 0x8(%rdi), %ecx
cmpl %ebp, %ecx
jg 0x9d187
movl 0x10(%rbx), %edi
testl %edi, %edi
js 0x9d176
leal (%rdi,%rcx), %ebp
decl %ebp
movl %ebp, %eax
cltd
idivl %edi
subl %edx, %ebp
jmp 0x9d187
movl %ecx, %ebp
cmpl %esi, %ecx
jg 0x9d187
movl %ecx, %ebp
imull %edi, %ebp
negl %ebp
cmpl %esi, %ebp
jle 0x9d17e
cmpl $0x2, 0x1c(%rbx)
jge 0x9d1ad
movl %ebp, 0x8(%rbx)
movq (%rbx), %rdi
movslq %ebp, %rsi
callq 0x26b30
movq %rax, (%rbx)
testq %rax, %rax
je 0x9d1d6
incl 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x5fe14(%rip), %rax     # 0xfcfc8
movq (%rax), %rdi
leaq 0x35320(%rip), %rsi     # 0xd24de
movq %rbx, %rdx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x26b90
jmp 0x9d18d
leaq 0x3539e(%rip), %rdi     # 0xd2572
jmp 0x9d1dd
leaq 0x32c69(%rip), %rdi     # 0xcfe46
xorl %eax, %eax
callq 0x9cfc3
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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:
movb (%rsi), %cl
testb %cl, %cl
je 0x9d243
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %esi
movl %esi, %eax
notl %eax
addl 0x8(%rdi), %eax
incq %rbx
testl %eax, %eax
jg 0x9d21e
incl %esi
movq %r14, %rdi
callq 0x9d14d
movl 0xc(%r14), %esi
movl %esi, %eax
notl %eax
addl 0x8(%r14), %eax
movb -0x1(%rbx), %cl
movq (%r14), %rdx
movslq %esi, %rsi
movb %cl, (%rdx,%rsi)
movl 0xc(%r14), %esi
incl %esi
movl %esi, 0xc(%r14)
decl %eax
movb (%rbx), %cl
incq %rbx
testb %cl, %cl
jne 0x9d201
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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 0x9d2a1
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 0x9d2b9
addl %ebp, %esi
movq %rbx, %rdi
callq 0x9d14d
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 0x26810
testl %eax, %eax
js 0x9d303
addl %eax, 0xc(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x351f2(%rip), %rdi     # 0xd24fc
xorl %eax, %eax
callq 0x9cfc3
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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 0x9d37c
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 0x26810
cmpl %r15d, %eax
jle 0x9d418
movb $0x1, %cl
movq %rsp, %r15
testb $0x1, %cl
je 0x9d42d
addl 0xc(%rbx), %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x9d14d
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 0x26810
xorl %ecx, %ecx
cmpl %r13d, %eax
jg 0x9d3c6
addl %eax, 0xc(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x350e6(%rip), %rdi     # 0xd251a
xorl %eax, %eax
callq 0x9cfc3
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/fpconv.c
// Function: fpconv_strtod
double fpconv_strtod(const char *nptr, char **endptr)
{
    char localbuf[FPCONV_G_FMT_BUFSIZE];
    char *buf, *endbuf, *dp;
    int buflen;
    double value;

    /* System strtod() is fine when decimal point is '.' */
    if (locale_decimal_point == '.')
        return strtod(nptr, endptr);

    buflen = strtod_buffer_size(nptr);
    if (!buflen) {
        /* No valid characters found, standard strtod() return */
        *endptr = (char *)nptr;
        return 0;
    }

    /* Duplicate number into buffer */
    if (buflen >= FPCONV_G_FMT_BUFSIZE) {
        /* Handle unusually large numbers */
        buf = malloc(buflen + 1);
        if (!buf) {
            fprintf(stderr, "Out of memory");
            abort();
        }
    } else {
        /* This is the common case.. */
        buf = localbuf;
    }
    memcpy(buf, nptr, buflen);
    buf[buflen] = 0;

    /* Update decimal point character if found */
    dp = strchr(buf, '.');
    if (dp)
        *dp = locale_decimal_point;

    value = strtod(buf, &endbuf);
    *endptr = (char *)&nptr[endbuf - buf];
    if (buflen >= FPCONV_G_FMT_BUFSIZE)
        free(buf);

    return value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x643a9(%rip), %bpl     # 0x101800
cmpb $0x2e, %bpl
jne 0x9d476
movq %r14, %rdi
movq %rbx, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26cc0
xorl %r13d, %r13d
movabsq $0x100000000, %rax      # imm = 0x100000000
movabsq $0x680000000000, %rcx   # imm = 0x680000000000
xorl %r15d, %r15d
movzbl (%r14,%r13), %edx
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x9d4b6
cmpl $0x2e, %edx
ja 0x9d4ab
movl %edx, %esi
btq %rsi, %rcx
jb 0x9d4b6
orb $0x20, %dl
addb $-0x7a, %dl
cmpb $-0x19, %dl
jb 0x9d4be
addq %rax, %r15
incq %r13
jmp 0x9d490
testl %r13d, %r13d
je 0x9d4e0
cmpl $0x20, %r13d
jl 0x9d4e8
movl %r13d, %edi
incl %edi
callq 0x26360
movq %rax, %r12
testq %rax, %rax
jne 0x9d4ed
callq 0x2778c
movq %r14, (%rbx)
xorps %xmm0, %xmm0
jmp 0x9d54d
leaq 0x10(%rsp), %r12
sarq $0x20, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x26c50
movb $0x0, (%r12,%r15)
movq %r12, %rdi
movl $0x2e, %esi
callq 0x267f0
testq %rax, %rax
je 0x9d519
movb %bpl, (%rax)
leaq 0x8(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x26cc0
movq (%r15), %rax
subq %r12, %rax
addq %rax, %r14
movq %r14, (%rbx)
cmpl $0x20, %r13d
jl 0x9d54d
movq %r12, %rdi
movsd %xmm0, (%rsp)
callq 0x264d0
movsd (%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq