LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $-0x20, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x1e, %eax
ja 0xcbd4c
movq -0x38(%rbp), %rax
leaq 0x80131(%rip), %rcx     # 0x14be08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xcbd77
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
jmp 0xcbd77
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
jmp 0xcbd77
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0xcbd80
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0xcbd2b
movl -0x24(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xcbd40
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x80192(%rip), %rsi     # 0x14becb
movb $0x0, %al
callq 0xc0370
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0xcbd77
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x80192(%rip), %rsi     # 0x14beec
movb $0x0, %al
callq 0xad4d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x1, %esi
callq 0xc0270
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
callq 0x26550
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xcbdc1
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcbe48
movl $0x0, -0x20(%rbp)
cmpl $0xccccccc, -0x20(%rbp) # imm = 0xCCCCCCC
jg 0xcbded
imull $0xa, -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %edx
subl $0x30, %edx
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subl %edx, %ecx
cmpl %ecx, %eax
jle 0xcbdff
movq -0x10(%rbp), %rdi
leaq 0x800bc(%rip), %rsi     # 0x14beb4
movb $0x0, %al
callq 0xc0370
imull $0xa, -0x20(%rbp), %eax
movq -0x18(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x20(%rbp)
callq 0x26550
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xcbdc8
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_struct.c
// Function: getinteger
static lua_Number getinteger (const char *buff, int endian,
                        int issigned, int size) {
  Uinttype l = 0;
  int i;
  if (endian == BIG) {
    for (i = 0; i < size; i++) {
      l <<= 8;
      l |= (Uinttype)(unsigned char)buff[i];
    }
  }
  else {
    for (i = size - 1; i >= 0; i--) {
      l <<= 8;
      l |= (Uinttype)(unsigned char)buff[i];
    }
  }
  if (!issigned)
    return (lua_Number)l;
  else {  /* signed format */
    Uinttype mask = (Uinttype)(~((Uinttype)0)) << (size*8 - 1);
    if (l & mask)  /* negative value? */
      l |= mask;  /* signal extension */
    return (lua_Number)(Inttype)l;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xcbebb
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xcbeb9
movq -0x28(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xcbe86
jmp 0xcbef7
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0xcbef5
movq -0x28(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xcbec4
jmp 0xcbef7
cmpl $0x0, -0x18(%rbp)
jne 0xcbf2b
movaps 0x6b59c(%rip), %xmm1    # 0x1374a0
movq -0x28(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6b59b(%rip), %xmm1    # 0x1374b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xcbf6b
movl -0x1c(%rbp), %eax
shll $0x3, %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
andq -0x38(%rbp), %rax
cmpq $0x0, %rax
je 0xcbf60
movq -0x38(%rbp), %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cvtsi2sdq -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xcbfc1
jmp 0xcc019
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0xcc019
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcbfcc
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cmsgpack.c
// Function: mp_realloc
void *mp_realloc(lua_State *L, void *target, size_t osize,size_t nsize) {
    void *(*local_realloc) (void *, void *, size_t osize, size_t nsize) = NULL;
    void *ud;

    local_realloc = lua_getallocf(L, &ud);

    return local_realloc(ud, target, osize, nsize);
}

// 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 $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xae7e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x18, %ecx
movq %rdx, %rsi
callq 0xcc020
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
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), %rax
cmpq -0x20(%rbp), %rax
jae 0xcc14b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0xcc020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x26c60
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x20, -0x20(%rbp)
jae 0xcc25e
movq -0x20(%rbp), %rax
andq $0xff, %rax
orq $0xa0, %rax
movb %al, -0x25(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0xcc307
cmpq $0xff, -0x20(%rbp)
ja 0xcc27f
movb $-0x27, -0x25(%rbp)
movq -0x20(%rbp), %rax
movb %al, -0x24(%rbp)
movl $0x2, -0x2c(%rbp)
jmp 0xcc305
cmpq $0xffff, -0x20(%rbp)    # imm = 0xFFFF
ja 0xcc2b4
movb $-0x26, -0x25(%rbp)
movq -0x20(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
shrq $0x8, %rax
movb %al, -0x24(%rbp)
movq -0x20(%rbp), %rax
andq $0xff, %rax
movb %al, -0x23(%rbp)
movl $0x3, -0x2c(%rbp)
jmp 0xcc303
movb $-0x25, -0x25(%rbp)
movabsq $0xff000000, %rax       # imm = 0xFF000000
andq -0x20(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x24(%rbp)
movq -0x20(%rbp), %rax
andq $0xff0000, %rax         # imm = 0xFF0000
shrq $0x10, %rax
movb %al, -0x23(%rbp)
movq -0x20(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
shrq $0x8, %rax
movb %al, -0x22(%rbp)
movq -0x20(%rbp), %rax
andq $0xff, %rax
movb %al, -0x21(%rbp)
movl $0x5, -0x2c(%rbp)
jmp 0xcc305
jmp 0xcc307
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x25(%rbp), %rdx
movslq -0x2c(%rbp), %rcx
callq 0xcc0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xcc0d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcc3ad
jp 0xcc3ad
movb $-0x36, -0x21(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
addq $0x1, %rdi
movl $0x4, %esi
callq 0xcbf80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x21(%rbp), %rdx
movl $0x5, %ecx
callq 0xcc0d0
jmp 0xcc3e1
movb $-0x35, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
addq $0x1, %rdi
movl $0x8, %esi
callq 0xcbf80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x21(%rbp), %rdx
movl $0x9, %ecx
callq 0xcc0d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0xf, -0x18(%rbp)
jg 0xcc778
movq -0x18(%rbp), %rax
andq $0xf, %rax
orq $0x90, %rax
movb %al, -0x1d(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xcc7fe
cmpq $0xffff, -0x18(%rbp)    # imm = 0xFFFF
jg 0xcc7ad
movb $-0x24, -0x1d(%rbp)
movq -0x18(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
sarq $0x8, %rax
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
andq $0xff, %rax
movb %al, -0x1b(%rbp)
movl $0x3, -0x24(%rbp)
jmp 0xcc7fc
movb $-0x23, -0x1d(%rbp)
movabsq $0xff000000, %rax       # imm = 0xFF000000
andq -0x18(%rbp), %rax
sarq $0x18, %rax
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
andq $0xff0000, %rax         # imm = 0xFF0000
sarq $0x10, %rax
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
sarq $0x8, %rax
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
andq $0xff, %rax
movb %al, -0x19(%rbp)
movl $0x5, -0x24(%rbp)
jmp 0xcc7fe
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x1d(%rbp), %rdx
movslq -0x24(%rbp), %rcx
callq 0xcc0d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0xf, -0x18(%rbp)
jg 0xcc858
movq -0x18(%rbp), %rax
andq $0xf, %rax
orq $0x80, %rax
movb %al, -0x1d(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xcc8de
cmpq $0xffff, -0x18(%rbp)    # imm = 0xFFFF
jg 0xcc88d
movb $-0x22, -0x1d(%rbp)
movq -0x18(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
sarq $0x8, %rax
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
andq $0xff, %rax
movb %al, -0x1b(%rbp)
movl $0x3, -0x24(%rbp)
jmp 0xcc8dc
movb $-0x21, -0x1d(%rbp)
movabsq $0xff000000, %rax       # imm = 0xFF000000
andq -0x18(%rbp), %rax
sarq $0x18, %rax
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
andq $0xff0000, %rax         # imm = 0xFF0000
sarq $0x10, %rax
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
sarq $0x8, %rax
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
andq $0xff, %rax
movb %al, -0x19(%rbp)
movl $0x5, -0x24(%rbp)
jmp 0xcc8de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x1d(%rbp), %rdx
movslq -0x24(%rbp), %rcx
callq 0xcc0d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xace10
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0x6dffe(%rip), %xmm2    # 0x13aa10
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x6dfcc(%rip), %xmm1    # 0x13aa00
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
jne 0xcca6f
cvttsd2si -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0xcca6f
jp 0xcca6f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcc9a0
jmp 0xcca81
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0xcc340
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xad020
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xcc740
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0xccb37
movq -0x8(%rbp), %rdi
movaps 0x6a9bd(%rip), %xmm1    # 0x1374a0
movq -0x28(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6a9bc(%rip), %xmm1    # 0x1374b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0xad2f0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xad800
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xccb40
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xccace
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xacaa0
movl %eax, -0x18(%rbp)
cmpl $0x5, -0x18(%rbp)
jne 0xccb77
cmpl $0x10, -0x14(%rbp)
jne 0xccb77
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0xccbda
movq -0x20(%rbp), %rax
leaq 0x7f416(%rip), %rcx     # 0x14bfa8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcc900
jmp 0xccbe7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcc950
jmp 0xccbe7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcc9e0
jmp 0xccbe7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xcce30
jmp 0xccbe7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcce80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
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_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xad2c0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xae690
cmpl $0x0, %eax
je 0xccc53
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xac570
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xccc24
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xcc820
movq -0x8(%rbp), %rdi
callq 0xad2c0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xae690
cmpl $0x0, %eax
je 0xcccb6
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xaca40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xccb40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xccb40
jmp 0xccc6d
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcccc0
cmpl $0x0, %eax
je 0xcce63
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xcca90
jmp 0xcce73
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xccc00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xac540
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xccee8
movq -0x10(%rbp), %rdi
xorl %esi, %esi
leaq 0x7f161(%rip), %rdx     # 0x14c03c
callq 0xc0270
movl %eax, -0x4(%rbp)
jmp 0xccf82
movq -0x10(%rbp), %rdi
callq 0xcc070
movq %rax, -0x20(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xccf62
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xaca40
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0xccb40
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0xad390
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xccefc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xcc190
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xae700
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
ja 0xccfb1
jmp 0xccfd0
leaq 0x7f0a2(%rip), %rdi     # 0x14c05a
leaq 0x7f0ab(%rip), %rsi     # 0x14c06a
movl $0x222, %edx            # imm = 0x222
leaq 0x7f0ae(%rip), %rcx     # 0x14c079
callq 0x262e0
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xad9e0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0xcd03a
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
cvtsi2sd %eax, %xmm0
callq 0xad2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcd040
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xcd02a
jmp 0xcd03a
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xadc40
jmp 0xccfe4
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
ja 0xcdcd1
jmp 0xcdcf0
leaq 0x7e382(%rip), %rdi     # 0x14c05a
leaq 0x7e38b(%rip), %rsi     # 0x14c06a
movl $0x22f, %edx            # imm = 0x22F
leaq 0x7e3c9(%rip), %rcx     # 0x14c0b4
callq 0x262e0
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xad9e0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0xcdd54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcd040
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xcdd2b
jmp 0xcdd54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcd040
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xcdd44
jmp 0xcdd54
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xadc40
jmp 0xcdcfd
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xce1d0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x4, %rax
jae 0xce2ac
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0xa2fbb(%rip), %rax     # 0x171210
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xad850
movq -0x8(%rbp), %rdi
leaq -0x264(%rip), %rsi      # 0xce010
movl $0x1, %edx
callq 0xad5a0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0xa2f83(%rip), %rax     # 0x171210
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xadca0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xce23c
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xaca40
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x7df9a(%rip), %rdx     # 0x14c264
callq 0xadca0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_bit.c
// Function: luaopen_bit
LUALIB_API int luaopen_bit(lua_State *L)
{
  UBits b;
  lua_pushnumber(L, (lua_Number)1437217655L);
  b = barg(L, -1);
  if (b != (UBits)1437217655L || BAD_SAR) {  /* Perform a simple self-test. */
    const char *msg = "compiled with incompatible luaconf.h";
#ifdef LUA_NUMBER_DOUBLE
#ifdef _WIN32
    if (b == (UBits)1610612736L)
      msg = "use D3DCREATE_FPU_PRESERVE with DirectX";
#endif
    if (b == (UBits)1127743488L)
      msg = "not compiled with SWAPPED_DOUBLE";
#endif
    if (BAD_SAR)
      msg = "arithmetic right-shift broken";
    luaL_error(L, "bit library self-test failed (%s)", msg);
  }
#if LUA_VERSION_NUM < 502
  luaL_register(L, "bit", bit_funcs);
#else
  luaL_newlib(L, bit_funcs);
#endif
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x7df80(%rip), %xmm0    # 0x14c278
callq 0xad2f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xce370
movl %eax, -0xc(%rbp)
cmpl $0x55aa3377, -0xc(%rbp) # imm = 0x55AA3377
je 0xce34c
leaq 0x7df6a(%rip), %rax     # 0x14c288
movq %rax, -0x18(%rbp)
cmpl $0x43380000, -0xc(%rbp) # imm = 0x43380000
jne 0xce336
leaq 0x7df7b(%rip), %rax     # 0x14c2ad
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7df89(%rip), %rsi     # 0x14c2ce
movb $0x0, %al
callq 0xc0370
movq -0x8(%rbp), %rdi
leaq 0x7df9b(%rip), %rsi     # 0x14c2f2
leaq 0xa2f02(%rip), %rdx     # 0x171260
callq 0xc0bc0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xce370
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xacaa0
cmpl $-0x1, %eax
jne 0xce85a
movl $0x8, %eax
movl %eax, -0x28(%rbp)
jmp 0xce86b
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xce370
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq 0x6cd78(%rip), %rax     # 0x13b5f0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0xce895
xorl %eax, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq 0x7da97(%rip), %rax     # 0x14c328
movq %rax, -0x18(%rbp)
cmpl $0x8, -0x10(%rbp)
jle 0xce8a2
movl $0x8, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jl 0xce8d8
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
andl $0xf, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movslq -0x24(%rbp), %rax
movb %cl, -0x20(%rbp,%rax)
movl -0xc(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0xce8a8
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0xad390
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/strbuf.c
// Function: strbuf_init
void strbuf_init(strbuf_t *s, int len)
{
    int size;

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

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

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

    strbuf_ensure_null(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0xd29ae
movl $0x3ff, -0x10(%rbp)     # imm = 0x3FF
jmp 0xd29b7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0xfffffffe, 0x10(%rax) # imm = 0xFFFFFFFE
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movslq -0x10(%rbp), %rdi
callq 0x26360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd2a2e
leaq 0x771af(%rip), %rdi     # 0x149bd6
movb $0x0, %al
callq 0xd2a40
movq -0x8(%rbp), %rdi
callq 0xd2b00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xd2a75
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xa0521(%rip), %rax     # 0x172fe8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x26460
leaq -0x20(%rbp), %rax
movq 0xa0506(%rip), %rax     # 0x172fe8
movq (%rax), %rdi
leaq 0x6734d(%rip), %rsi     # 0x139e39
movb $0x0, %al
callq 0x26ba0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x262d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x20, %edi
callq 0x26360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd2b4e
leaq 0x7708f(%rip), %rdi     # 0x149bd6
movb $0x0, %al
callq 0xd2a40
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xd2990
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd2c00
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd2be6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x264c0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0xd2bf9
movq -0x8(%rbp), %rdi
callq 0x264c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd2c00
movq -0x8(%rbp), %rdi
callq 0xd2b00
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd2c91
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0xd2ca4
movq -0x8(%rbp), %rdi
callq 0x264c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xd2d60
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1c(%rax)
jle 0xd2cff
movq 0xa0309(%rip), %rax     # 0x172fe8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movl -0x10(%rbp), %r8d
leaq 0x7992f(%rip), %rsi     # 0x14c627
movb $0x0, %al
callq 0x26ba0
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0x26b40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd2d3f
leaq 0x76e9e(%rip), %rdi     # 0x149bd6
movb $0x0, %al
callq 0xd2a40
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%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/strbuf.c
// Function: calculate_new_size
static int calculate_new_size(strbuf_t *s, int len)
{
    int reqsize, newsize;

    if (len <= 0)
        die("BUG: Invalid strbuf length requested");

    /* Ensure there is room for optional NULL termination */
    reqsize = len + 1;

    /* If the user has requested to shrink the buffer, do it exactly */
    if (s->size > reqsize)
        return reqsize;

    newsize = s->size;
    if (s->increment < 0) {
        /* Exponential sizing */
        while (newsize < reqsize)
            newsize *= -s->increment;
    } else {
        /* Linear sizing */
        newsize = ((newsize + s->increment - 1) / s->increment) * s->increment;
    }

    return newsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xd2d83
leaq 0x7993f(%rip), %rdi     # 0x14c6bb
movb $0x0, %al
callq 0xd2a40
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jle 0xd2da0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd2df8
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jge 0xd2dd2
jmp 0xd2db6
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xd2dd0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x10(%rcx), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xd2db6
jmp 0xd2df2
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
cltd
idivl 0x10(%rcx)
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd2eb0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xd2ea4
cmpl $0x1, -0x14(%rbp)
jge 0xd2e66
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
addl $0x1, %esi
callq 0xd2cb0
movq -0x8(%rbp), %rdi
callq 0xd2eb0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd2e33
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xd2f0b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xd2fc0
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
addq %rax, %rdi
movslq -0xc(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x26810
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
jge 0xd2f99
leaq 0x796b3(%rip), %rdi     # 0x14c645
movb $0x0, %al
callq 0xd2a40
movl -0x34(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl %edx, %ecx
movl %ecx, 0xc(%rax)
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)