LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: restore_stack_limit
static void restore_stack_limit (lua_State *L) {
  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
  if (L->size_ci > LUAI_MAXCALLS) {  /* there was an overflow? */
    int inuse = cast_int(L->ci - L->base_ci);
    if (inuse + 1 < LUAI_MAXCALLS)  /* can `undo' overflow? */
      luaD_reallocCI(L, LUAI_MAXCALLS);
  }
}

// Assembly:
cmpl $0x4e21, 0x5c(%rdi)     # imm = 0x4E21
jl 0x8061
movq 0x28(%rdi), %rax
subq 0x50(%rdi), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
cmpl $0x4e1e, %eax           # imm = 0x4E1E
jg 0x8061
movl $0x4e20, %esi           # imm = 0x4E20
jmp 0x76c7
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_protectedparser
int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
  struct SParser p;
  int status;
  p.z = z; p.name = name;
  luaZ_initbuffer(L, &p.buff);
  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
  luaZ_freebuffer(L, &p.buff);
  return status;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rbx
movq %rsi, (%rbx)
movq %rdx, 0x20(%rbx)
andq $0x0, 0x8(%rbx)
movq %rdi, %r14
andq $0x0, 0x18(%rbx)
movq 0x10(%rdi), %rcx
movq 0xb0(%rdi), %r8
subq 0x40(%rdi), %rcx
leaq 0x27(%rip), %rsi        # 0x80c0
movq %rbx, %rdx
callq 0x7f89
movl %eax, %ebp
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: f_parser
static void f_parser (lua_State *L, void *ud) {
  int i;
  Proto *tf;
  Closure *cl;
  struct SParser *p = cast(struct SParser *, ud);
  int c = luaZ_lookahead(p->z);
  luaC_checkGC(L);
  tf = (luaY_parser)(L, p->z,
                                                             &p->buff, p->name);
  cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
  cl->l.p = tf;
  for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */
    cl->l.upvals[i] = luaF_newupval(L);
  setclvalue(L, L->top, cl);
  incr_top(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0xf2e1
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x80ec
movq %rbx, %rdi
callq 0x8b89
leaq 0x8(%r14), %rdx
movq (%r14), %rsi
movq 0x20(%r14), %rcx
movq %rbx, %rdi
callq 0x9ddc
movq %rax, %r14
movzbl 0x70(%rax), %esi
movq 0x78(%rbx), %rdx
movq %rbx, %rdi
callq 0x8523
movq %rax, %r15
movq %r14, 0x20(%rax)
xorl %r12d, %r12d
movzbl 0x70(%r14), %eax
cmpq %rax, %r12
jae 0x8138
movq %rbx, %rdi
callq 0x858b
movq %rax, 0x28(%r15,%r12,8)
incq %r12
jmp 0x811c
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movl $0x6, 0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0x8166
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x7732
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldump.c
// Function: luaU_dump
int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
{
 DumpState D;
 D.L=L;
 D.writer=w;
 D.data=data;
 D.strip=strip;
 D.status=0;
 DumpHeader(&D);
 DumpFunction(f,NULL,&D);
 return D.status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rsp), %r13
movq %rdi, (%r13)
movq %rdx, 0x8(%r13)
movq %rcx, 0x10(%r13)
movl %r8d, 0x18(%r13)
leaq 0xc(%rsp), %rbp
movq %rbp, %rdi
callq 0xd6ef
pushq $0xc
popq %rdx
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq *%r14
movl %eax, 0x1c(%r13)
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x81eb
movl 0x1c(%r13), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldump.c
// Function: DumpFunction
static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
{
 DumpString((f->source==p || D->strip) ? NULL : f->source,D);
 DumpInt(f->linedefined,D);
 DumpInt(f->lastlinedefined,D);
 DumpChar(f->nups,D);
 DumpChar(f->numparams,D);
 DumpChar(f->is_vararg,D);
 DumpChar(f->maxstacksize,D);
 DumpCode(f,D);
 DumpConstants(f,D);
 DumpDebug(f,D);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rax
xorl %ebp, %ebp
xorl %edi, %edi
cmpq %rsi, %rax
je 0x8211
cmpl $0x0, 0x18(%rbx)
cmoveq %rax, %rdi
movq %rbx, %rsi
callq 0x841a
movl 0x60(%r14), %edi
movq %rbx, %rsi
callq 0x8475
movl 0x64(%r14), %edi
movq %rbx, %rsi
callq 0x8475
movzbl 0x70(%r14), %edi
movq %rbx, %rsi
callq 0x848d
movzbl 0x71(%r14), %edi
movq %rbx, %rsi
callq 0x848d
movzbl 0x72(%r14), %edi
movq %rbx, %rsi
callq 0x848d
movzbl 0x73(%r14), %edi
movq %rbx, %rsi
callq 0x848d
movq 0x18(%r14), %rdi
movl 0x50(%r14), %esi
movq %rbx, %rdx
callq 0x84a6
movl 0x4c(%r14), %r15d
movl %r15d, %edi
movq %rbx, %rsi
callq 0x8475
testl %r15d, %r15d
cmovlel %ebp, %r15d
shlq $0x4, %r15
pushq $0x8
popq %r13
cmpq %rbp, %r15
je 0x82f8
movq 0x10(%r14), %r12
movl 0x8(%r12,%rbp), %edi
movq %rbx, %rsi
callq 0x848d
movl 0x8(%r12,%rbp), %eax
cmpl $0x4, %eax
je 0x82e6
cmpl $0x3, %eax
je 0x82cb
cmpl $0x1, %eax
jne 0x82f2
movl (%r12,%rbp), %edi
movq %rbx, %rsi
callq 0x848d
jmp 0x82f2
movsd (%r12,%rbp), %xmm0
movsd %xmm0, (%rsp)
movq %rsp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x83fb
jmp 0x82f2
movq (%r12,%rbp), %rdi
movq %rbx, %rsi
callq 0x841a
addq $0x10, %rbp
jmp 0x8293
movl 0x58(%r14), %r15d
movl %r15d, %edi
movq %rbx, %rsi
callq 0x8475
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x832f
movq 0x20(%r14), %rax
movq 0x40(%r14), %rsi
movq (%rax,%r12,8), %rdi
movq %rbx, %rdx
callq 0x81eb
incq %r12
jmp 0x8311
xorl %r15d, %r15d
cmpl $0x0, 0x18(%rbx)
movl $0x0, %esi
jne 0x8341
movl 0x54(%r14), %esi
movq 0x28(%r14), %rdi
movq %rbx, %rdx
callq 0x84a6
cmpl $0x0, 0x18(%rbx)
jne 0x8357
movl 0x5c(%r14), %r15d
movl %r15d, %edi
movq %rbx, %rsi
callq 0x8475
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
shlq $0x4, %r15
cmpq %r12, %r15
je 0x83ad
movq 0x30(%r14), %rax
movq (%rax,%r12), %rdi
movq %rbx, %rsi
callq 0x841a
movq 0x30(%r14), %rax
movl 0x8(%rax,%r12), %edi
movq %rbx, %rsi
callq 0x8475
movq 0x30(%r14), %rax
movl 0xc(%rax,%r12), %edi
movq %rbx, %rsi
callq 0x8475
addq $0x10, %r12
jmp 0x8370
xorl %r12d, %r12d
cmpl $0x0, 0x18(%rbx)
movl $0x0, %r15d
jne 0x83c0
movl 0x48(%r14), %r15d
movl %r15d, %edi
movq %rbx, %rsi
callq 0x8475
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x83ec
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x841a
incq %r12
jmp 0x83d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldump.c
// Function: DumpString
static void DumpString(const TString* s, DumpState* D)
{
 if (s==NULL || getstr(s)==NULL)
 {
  size_t size=0;
  DumpVar(size,D);
 }
 else
 {
  size_t size=s->tsv.len+1;		/* include trailing '\0' */
  DumpVar(size,D);
  DumpBlock(getstr(s),size,D);
 }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x8457
movq %rdi, %r14
movq 0x10(%rdi), %rax
addq $0x18, %r14
incq %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
pushq $0x8
popq %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x83fb
movq (%r15), %rsi
movq %r14, %rdi
jmp 0x8463
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
pushq $0x8
popq %rsi
movq %rbx, %rdx
callq 0x83fb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lfunc.c
// Function: luaF_newCclosure
Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
  Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
  c->c.isC = 1;
  c->c.env = e;
  c->c.nupvalues = cast_byte(nelems);
  return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
shll $0x4, %eax
addl $0x28, %eax
movslq %eax, %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x97a6
movq %rax, %r15
pushq $0x6
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x9158
movb $0x1, 0xa(%r15)
movq %rbx, 0x18(%r15)
movb %bpl, 0xb(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lfunc.c
// Function: luaF_newLclosure
Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
  Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
  c->l.isC = 0;
  c->l.env = e;
  c->l.nupvalues = cast_byte(nelems);
  while (nelems--) c->l.upvals[nelems] = NULL;
  return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
leal 0x28(,%r15,8), %eax
movslq %eax, %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x97a6
movq %rax, %rbx
pushq $0x6
popq %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0x9158
movb $0x0, 0xa(%rbx)
movq %r14, 0x18(%rbx)
movb %r15b, 0xb(%rbx)
movslq %r15d, %rax
addq $0x4, %rax
cmpq $0x4, %rax
je 0x857c
andq $0x0, (%rbx,%rax,8)
decq %rax
jmp 0x856c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lfunc.c
// Function: luaF_newupval
UpVal *luaF_newupval (lua_State *L) {
  UpVal *uv = luaM_new(L, UpVal);
  luaC_link(L, obj2gco(uv), LUA_TUPVAL);
  uv->v = &uv->u.value;
  setnilvalue(uv->v);
  return uv;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x20(%rdi), %r14
leaq 0x98(%rdi), %r15
movq (%r15), %rax
testq %rax, %rax
je 0x8605
cmpq %rbx, 0x10(%rax)
jb 0x8605
movq %rax, %r15
jne 0x85da
movb 0x9(%rax), %cl
movb 0x20(%r14), %dl
notb %dl
andb %cl, %dl
testb $0x3, %dl
je 0x864d
xorb $0x3, %cl
movb %cl, 0x9(%rax)
jmp 0x864d
pushq $0x28
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x97a6
movb $0xa, 0x8(%rax)
movb 0x20(%r14), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movq %rbx, 0x10(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movq %rax, (%r15)
leaq 0xb8(%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0xd8(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rcx)
movq %rax, 0xd8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lfunc.c
// Function: luaF_close
void luaF_close (lua_State *L, StkId level) {
  UpVal *uv;
  global_State *g = G(L);
  while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
    GCObject *o = obj2gco(uv);
    lua_assert(!isblack(o) && uv->v != &uv->u.value);
    L->openupval = uv->next;  /* remove from `open' list */
    if (isdead(g, o))
      luaF_freeupval(L, uv);  /* free upvalue */
    else {
      unlinkupval(uv);
      setobj(L, &uv->u.value, uv->v);
      uv->v = &uv->u.value;  /* now current value lives here */
      luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r15
movq 0x98(%r14), %rsi
testq %rsi, %rsi
je 0x86f4
cmpq %rbx, 0x10(%rsi)
jb 0x86f4
movq (%rsi), %rax
movq %rax, 0x98(%r14)
movb 0x20(%r15), %al
notb %al
andb 0x9(%rsi), %al
testb $0x3, %al
je 0x86bd
movq %r14, %rdi
callq 0x8653
jmp 0x868a
leaq 0x18(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rdx
movq %rcx, 0x18(%rdx)
movq 0x20(%rsi), %rdx
movq %rdx, 0x20(%rcx)
movq 0x10(%rsi), %rcx
movq (%rcx), %rdx
movq %rdx, 0x18(%rsi)
movl 0x8(%rcx), %ecx
movl %ecx, 0x20(%rsi)
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x9173
jmp 0x868a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lfunc.c
// Function: luaF_newproto
Proto *luaF_newproto (lua_State *L) {
  Proto *f = luaM_new(L, Proto);
  luaC_link(L, obj2gco(f), LUA_TPROTO);
  f->k = NULL;
  f->sizek = 0;
  f->p = NULL;
  f->sizep = 0;
  f->code = NULL;
  f->sizecode = 0;
  f->sizelineinfo = 0;
  f->sizeupvalues = 0;
  f->nups = 0;
  f->upvalues = NULL;
  f->numparams = 0;
  f->is_vararg = 0;
  f->maxstacksize = 0;
  f->lineinfo = NULL;
  f->sizelocvars = 0;
  f->locvars = NULL;
  f->linedefined = 0;
  f->lastlinedefined = 0;
  f->source = NULL;
  return f;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
movslq 0x50(%rbx), %rdx
shlq $0x2, %rdx
xorl %ecx, %ecx
callq 0x97a6
movq 0x20(%rbx), %rsi
movslq 0x58(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
movq 0x10(%rbx), %rsi
movslq 0x4c(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
movq 0x28(%rbx), %rsi
movslq 0x54(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
movq 0x30(%rbx), %rsi
movslq 0x5c(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
movq 0x38(%rbx), %rsi
movslq 0x48(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
pushq $0x78
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x97a6
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_separateudata
size_t luaC_separateudata (lua_State *L, int all) {
  global_State *g = G(L);
  size_t deadmem = 0;
  GCObject **p = &g->mainthread->next;
  GCObject *curr;
  while ((curr = *p) != NULL) {
    if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
      p = &curr->gch.next;  /* don't bother with them */
    else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
      markfinalized(gco2u(curr));  /* don't need finalization */
      p = &curr->gch.next;
    }
    else {  /* must call its gc method */
      deadmem += sizeudata(gco2u(curr));
      markfinalized(gco2u(curr));
      *p = curr->gch.next;
      /* link `curr' at the end of `tmudata' list */
      if (g->tmudata == NULL)  /* list is empty? */
        g->tmudata = curr->gch.next = curr;  /* creates a circular list */
      else {
        curr->gch.next = g->tmudata->gch.next;
        g->tmudata->gch.next = curr;
        g->tmudata = curr;
      }
    }
  }
  return deadmem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x20(%rdi), %r12
movq 0xb0(%r12), %rbp
xorl %r15d, %r15d
movq (%rbp), %r13
testq %r13, %r13
je 0x890a
movzbl 0x9(%r13), %ecx
movl %ecx, %eax
andl $0x3, %eax
orl %ebx, %eax
testb $0x8, %cl
jne 0x8902
testl %eax, %eax
je 0x8902
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x88fb
testb $0x4, 0xa(%rdi)
jne 0x88fb
movq 0x20(%r14), %rax
movq 0x138(%rax), %rdx
pushq $0x2
popq %rsi
callq 0xd1c6
movb 0x9(%r13), %cl
testq %rax, %rax
je 0x88fb
movq (%r13), %rdx
movq 0x20(%r13), %rax
orb $0x8, %cl
movb %cl, 0x9(%r13)
movq %rdx, (%rbp)
movq 0x50(%r12), %rcx
testq %rcx, %rcx
je 0x88e6
movq (%rcx), %rcx
movq %rcx, (%r13)
movq 0x50(%r12), %rcx
movq %r13, (%rcx)
jmp 0x88ea
movq %r13, (%r13)
addq %rax, %r15
addq $0x28, %r15
movq %r13, 0x50(%r12)
jmp 0x886b
orb $0x8, %cl
movb %cl, 0x9(%r13)
movq %r13, %rbp
jmp 0x886b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: GCTM
static void GCTM (lua_State *L) {
  global_State *g = G(L);
  GCObject *o = g->tmudata->gch.next;  /* get first element */
  Udata *udata = rawgco2u(o);
  const TValue *tm;
  /* remove udata from `tmudata' */
  if (o == g->tmudata)  /* last element? */
    g->tmudata = NULL;
  else
    g->tmudata->gch.next = udata->uv.next;
  udata->uv.next = g->mainthread->next;  /* return it to `root' list */
  g->mainthread->next = o;
  makewhite(g, o);
  tm = fasttm(L, udata->uv.metatable, TM_GC);
  if (tm != NULL) {
    lu_byte oldah = L->allowhook;
    lu_mem oldt = g->GCthreshold;
    L->allowhook = 0;  /* stop debug hooks during GC tag method */
    g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
    setobj2s(L, L->top, tm);
    setuvalue(L, L->top+1, udata);
    L->top += 2;
    luaD_call(L, L->top - 2, 0);
    L->allowhook = oldah;  /* restore hooks */
    g->GCthreshold = oldt;  /* restore threshold */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x50(%r14), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x895a
movq (%r15), %rcx
movq %rcx, (%rax)
jmp 0x895f
andq $0x0, 0x50(%r14)
movq 0xb0(%r14), %rax
movq (%rax), %rax
movq %rax, (%r15)
movq 0xb0(%r14), %rax
movq %r15, (%rax)
movb 0x9(%r15), %al
andb $-0x8, %al
movb 0x20(%r14), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r15)
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x8a04
testb $0x4, 0xa(%rdi)
jne 0x8a04
movq 0x20(%rbx), %rax
movq 0x138(%rax), %rdx
pushq $0x2
popq %rsi
callq 0xd1c6
testq %rax, %rax
je 0x8a04
movb 0x65(%rbx), %bpl
movq 0x70(%r14), %r12
movb $0x0, 0x65(%rbx)
movq 0x78(%r14), %rcx
addq %rcx, %rcx
movq %rcx, 0x70(%r14)
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq %r15, 0x10(%rax)
movl $0x7, 0x18(%rax)
movq 0x10(%rbx), %rsi
leaq 0x20(%rsi), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7d4b
movb %bpl, 0x65(%rbx)
movq %r12, 0x70(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_freeall
void luaC_freeall (lua_State *L) {
  global_State *g = G(L);
  int i;
  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
  sweepwholelist(L, &g->rootgc);
  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
    sweepwholelist(L, &g->strt.hash[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movb $0x43, 0x20(%r15)
leaq 0x28(%r15), %rsi
pushq $-0x3
popq %r14
movq %r14, %rdx
callq 0x8a65
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0xc(%r15), %rax
cmpq %rax, %r13
jge 0x8a5b
movq (%r15), %rsi
addq %r12, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8a65
incq %r13
addq $0x8, %r12
jmp 0x8a38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: sweeplist
static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
  GCObject *curr;
  global_State *g = G(L);
  int deadmask = otherwhite(g);
  while ((curr = *p) != NULL && count-- > 0) {
    if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */
      sweepwholelist(L, &gco2th(curr)->openupval);
    if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */
      lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
      makewhite(g, curr);  /* make it white (for next cycle) */
      p = &curr->gch.next;
    }
    else {  /* must erase `curr' */
      lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
      *p = curr->gch.next;
      if (curr == g->rootgc)  /* is the first element of the list? */
        g->rootgc = curr->gch.next;  /* adjust first */
      freeobj(L, curr);
    }
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x20(%rdi), %rbp
movb 0x20(%rbp), %r15b
xorb $0x3, %r15b
movq (%r12), %r13
testq %r13, %r13
je 0x8b77
subq $0x1, %rbx
jb 0x8b77
cmpb $0x8, 0x8(%r13)
jne 0x8ab5
leaq 0x98(%r13), %rsi
movq %r14, %rdi
pushq $-0x3
popq %rdx
callq 0x8a65
movb 0x9(%r13), %al
movl %eax, %ecx
xorb $0x3, %cl
testb %r15b, %cl
je 0x8ad6
andb $-0x8, %al
movb 0x20(%rbp), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r13)
jmp 0x8b6f
movq (%r13), %rax
movq %rax, (%r12)
cmpq 0x28(%rbp), %r13
jne 0x8ae8
movq %rax, 0x28(%rbp)
movzbl 0x8(%r13), %eax
addl $-0x4, %eax
cmpl $0x6, %eax
ja 0x8b6c
leaq 0x10ab0(%rip), %rcx     # 0x195ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%r14), %rax
decl 0x8(%rax)
movq 0x10(%r13), %rdx
addq $0x19, %rdx
jmp 0x8b38
movq %r14, %rdi
movq %r13, %rsi
callq 0xc066
jmp 0x8b6c
movq %r14, %rdi
movq %r13, %rsi
callq 0x87f1
jmp 0x8b6c
movq 0x20(%r13), %rdx
addq $0x28, %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x97a6
jmp 0x8b6c
movq %r14, %rdi
movq %r13, %rsi
callq 0xcab1
jmp 0x8b6c
movq %r14, %rdi
movq %r13, %rsi
callq 0x874f
jmp 0x8b6c
movq %r14, %rdi
movq %r13, %rsi
callq 0x8653
movq %r12, %r13
movq %r13, %r12
jmp 0x8a85
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_step
void luaC_step (lua_State *L) {
  global_State *g = G(L);
  l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
  if (lim == 0)
    lim = (MAX_LUMEM-1)/2;  /* no limit */
  g->gcdept += g->totalbytes - g->GCthreshold;
  do {
    lim -= singlestep(L);
    if (g->gcstate == GCSpause)
      break;
  } while (lim > 0);
  if (g->gcstate != GCSpause) {
    if (g->gcdept < GCSTEPSIZE)
      g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/
    else {
      g->gcdept -= GCSTEPSIZE;
      g->GCthreshold = g->totalbytes;
    }
  }
  else {
    setthreshold(g);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
imull $0xa, 0x94(%r14), %eax
testl %eax, %eax
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
cmovneq %rax, %r15
movq 0x78(%r14), %rax
subq 0x70(%r14), %rax
addq %rax, 0x88(%r14)
movq %rbx, %rdi
callq 0x8c29
movb 0x21(%r14), %cl
testb %cl, %cl
je 0x8bd4
subq %rax, %r15
testq %r15, %r15
jg 0x8bbc
testb %cl, %cl
je 0x8bf2
movq 0x88(%r14), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x8c0e
movl $0x400, %ecx            # imm = 0x400
addq 0x78(%r14), %rcx
jmp 0x8c1f
movq 0x80(%r14), %rax
pushq $0x64
popq %rcx
xorl %edx, %edx
divq %rcx
movslq 0x90(%r14), %rcx
imulq %rax, %rcx
jmp 0x8c1f
addq $-0x400, %rax           # imm = 0xFC00
movq %rax, 0x88(%r14)
movq 0x78(%r14), %rcx
movq %rcx, 0x70(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_fullgc
void luaC_fullgc (lua_State *L) {
  global_State *g = G(L);
  if (g->gcstate <= GCSpropagate) {
    /* reset sweep marks to sweep all elements (returning them to white) */
    g->sweepstrgc = 0;
    g->sweepgc = &g->rootgc;
    /* reset other collector lists */
    g->gray = NULL;
    g->grayagain = NULL;
    g->weak = NULL;
    g->gcstate = GCSsweepstring;
  }
  lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
  /* finish any pending sweep phase */
  while (g->gcstate != GCSfinalize) {
    lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
    singlestep(L);
  }
  markroot(L);
  while (g->gcstate != GCSpause) {
    singlestep(L);
  }
  setthreshold(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movb 0x21(%r14), %al
cmpb $0x1, %al
ja 0x8f9f
andl $0x0, 0x24(%r14)
leaq 0x28(%r14), %rax
movq %rax, 0x30(%r14)
andq $0x0, 0x48(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movb $0x2, 0x21(%r14)
movb $0x2, %al
jmp 0x8f9f
callq 0x8c29
movb 0x21(%r14), %al
movq %rbx, %rdi
cmpb $0x4, %al
jne 0x8f96
callq 0x8fe2
cmpb $0x0, 0x21(%r14)
je 0x8fbc
movq %rbx, %rdi
callq 0x8c29
jmp 0x8fab
movq 0x80(%r14), %rax
pushq $0x64
popq %rcx
xorl %edx, %edx
divq %rcx
movslq 0x90(%r14), %rcx
imulq %rax, %rcx
movq %rcx, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: markroot
static void markroot (lua_State *L) {
  global_State *g = G(L);
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  markobject(g, g->mainthread);
  /* make global table be traversed before main stack */
  markvalue(g, gt(g->mainthread));
  markvalue(g, registry(L));
  markmt(g);
  g->gcstate = GCSpropagate;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movq 0xb0(%rbx), %rsi
testb $0x3, 0x9(%rsi)
je 0x9015
movq %rbx, %rdi
callq 0x9086
movq 0xb0(%rbx), %rsi
cmpl $0x4, 0x80(%rsi)
jl 0x9030
movq 0x78(%rsi), %rsi
testb $0x3, 0x9(%rsi)
je 0x9030
movq %rbx, %rdi
callq 0x9086
movq 0x20(%r14), %rax
cmpl $0x4, 0xa8(%rax)
jl 0x9052
movq 0xa0(%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0x9052
movq %rbx, %rdi
callq 0x9086
movq %rbx, %rdi
callq 0x96ae
movb $0x1, 0x21(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_barrierf
void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
  global_State *g = G(L);
  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
  lua_assert(ttype(&o->gch) != LUA_TTABLE);
  /* must keep invariant? */
  if (g->gcstate == GCSpropagate)
    reallymarkobject(g, v);  /* restore invariant */
  else  /* don't mind */
    makewhite(g, o);  /* mark as white just to avoid other barriers */
}

// Assembly:
movq 0x20(%rdi), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x9075
movq %rdx, %rsi
jmp 0x9086
movb 0x9(%rsi), %al
andb $-0x8, %al
movb 0x20(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: reallymarkobject
static void reallymarkobject (global_State *g, GCObject *o) {
  lua_assert(iswhite(o) && !isdead(g, o));
  white2gray(o);
  switch (o->gch.tt) {
    case LUA_TSTRING: {
      return;
    }
    case LUA_TUSERDATA: {
      Table *mt = gco2u(o)->metatable;
      gray2black(o);  /* udata are never gray */
      if (mt) markobject(g, mt);
      markobject(g, gco2u(o)->env);
      return;
    }
    case LUA_TUPVAL: {
      UpVal *uv = gco2uv(o);
      markvalue(g, uv->v);
      if (uv->v == &uv->u.value)  /* closed? */
        gray2black(o);  /* open upvalues are never black */
      return;
    }
    case LUA_TFUNCTION: {
      gco2cl(o)->c.gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TTABLE: {
      gco2h(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TTHREAD: {
      gco2th(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TPROTO: {
      gco2p(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    default: lua_assert(0);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb 0x9(%rsi), %al
leaq 0x10541(%rip), %r15     # 0x195dc
andb $-0x4, %al
movb %al, 0x9(%rbx)
movzbl 0x8(%rbx), %ecx
addl $-0x5, %ecx
cmpl $0x5, %ecx
ja 0x913d
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movq 0x10(%rbx), %rsi
orb $0x4, %al
movb %al, 0x9(%rbx)
testq %rsi, %rsi
je 0x90d5
testb $0x3, 0x9(%rsi)
je 0x90d5
movq %r14, %rdi
callq 0x9086
movq 0x18(%rbx), %rbx
movb 0x9(%rbx), %al
testb $0x3, %al
jne 0x909b
jmp 0x913d
movq 0x10(%rbx), %rax
cmpl $0x4, 0x8(%rax)
jl 0x9101
movq (%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0x9101
movq %r14, %rdi
callq 0x9086
movq 0x10(%rbx), %rax
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
jne 0x913d
orb $0x4, 0x9(%rbx)
jmp 0x913d
movq 0x38(%r14), %rax
movq %rax, 0x10(%rbx)
jmp 0x9139
movq 0x38(%r14), %rax
movq %rax, 0x68(%rbx)
jmp 0x9139
movq 0x38(%r14), %rax
movq %rax, 0x30(%rbx)
jmp 0x9139
movq 0x38(%r14), %rax
movq %rax, 0xa0(%rbx)
movq %rbx, 0x38(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_linkupval
void luaC_linkupval (lua_State *L, UpVal *uv) {
  global_State *g = G(L);
  GCObject *o = obj2gco(uv);
  o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
  g->rootgc = o;
  if (isgray(o)) { 
    if (g->gcstate == GCSpropagate) {
      gray2black(o);  /* closed upvalues need barrier */
      luaC_barrier(L, uv, uv->v);
    }
    else {  /* sweep phase: sweep it (turning it into white) */
      makewhite(g, o);
      lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
    }
  }
}

// Assembly:
movq 0x20(%rdi), %rcx
movq 0x28(%rcx), %rax
movq %rax, (%rsi)
movq %rsi, 0x28(%rcx)
movb 0x9(%rsi), %al
testb $0x7, %al
je 0x918a
retq
cmpb $0x1, 0x21(%rcx)
jne 0x91ad
orb $0x4, %al
movb %al, 0x9(%rsi)
movq 0x10(%rsi), %rax
cmpl $0x4, 0x8(%rax)
jl 0x9189
movq (%rax), %rdx
testb $0x3, 0x9(%rdx)
je 0x9189
jmp 0x9066
movb 0x20(%rcx), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: iscleared
static int iscleared (const TValue *o, int iskey) {
  if (!iscollectable(o)) return 0;
  if (ttisstring(o)) {
    stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
    return 0;
  }
  return iswhite(gcvalue(o)) ||
    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
}

// Assembly:
movl 0x8(%rdi), %edx
xorl %eax, %eax
cmpl $0x4, %edx
jl 0x9715
movq (%rdi), %rdi
movzbl 0x9(%rdi), %ecx
jne 0x96fd
andb $-0x4, %cl
movb %cl, 0x9(%rdi)
retq
testb $0x3, %cl
je 0x9706
pushq $0x1
popq %rax
retq
xorl $0x7, %edx
orl %edx, %esi
jne 0x9715
shrl $0x3, %ecx
andl $0x1, %ecx
movl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lmem.c
// Function: luaM_growaux_
void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
                     int limit, const char *errormsg) {
  void *newblock;
  int newsize;
  if (*size >= limit/2) {  /* cannot double it? */
    if (*size >= limit)  /* cannot grow even a little? */
      luaG_runerror(L, errormsg);
    newsize = limit;  /* still have at least one free place */
  }
  else {
    newsize = (*size)*2;
    if (newsize < MINSIZEARRAY)
      newsize = MINSIZEARRAY;  /* minimum size */
  }
  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
  *size = newsize;  /* update only when everything else is OK */
  return newblock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl (%rdx), %ecx
pushq $0x2
popq %rsi
movl %r8d, %eax
cltd
idivl %esi
cmpl %eax, %ecx
jge 0x974b
addl %ecx, %ecx
cmpl $0x5, %ecx
pushq $0x4
popq %r14
cmovgel %ecx, %r14d
jmp 0x9760
movl %r8d, %r14d
cmpl %r8d, %ecx
jl 0x9760
movq %r15, %rdi
movq %r9, %rsi
xorl %eax, %eax
callq 0x7165
leal 0x1(%r14), %eax
movslq %eax, %rcx
pushq $-0x3
popq %rax
xorl %edx, %edx
divq %r13
cmpq %rcx, %rax
jae 0x9780
movq %r15, %rdi
callq 0x97f0
xorl %eax, %eax
jmp 0x9799
movslq (%rbx), %rdx
imulq %r13, %rdx
movslq %r14d, %rcx
imulq %r13, %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0x97a6
movl %r14d, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  global_State *g = G(L);
  lua_assert((osize == 0) == (block == NULL));
  block = (*g->frealloc)(g->ud, block, osize, nsize);
  if (block == NULL && nsize > 0)
    luaD_throw(L, LUA_ERRMEM);
  lua_assert((nsize == 0) == (block == NULL));
  g->totalbytes = (g->totalbytes - osize) + nsize;
  return block;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%rdi), %r13
movq 0x18(%r13), %rdi
callq *0x10(%r13)
movq %rax, %r12
testq %rbx, %rbx
je 0x97dc
testq %r12, %r12
jne 0x97dc
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x74ee
subq %r14, %rbx
addq %rbx, 0x78(%r13)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* expoent */
  while (x >= 16) {
    x = (x+1) >> 1;
    e++;
  }
  if (x < 8) return x;
  else return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
pushq $0x8
popq %rax
cmpl $0x10, %edi
jb 0x9815
incl %edi
shrl %edi
addl $0x8, %eax
jmp 0x9807
leal -0x8(%rdi), %ecx
orl %ecx, %eax
cmpl $0x8, %edi
cmovbl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_rawequalObj
int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
  if (ttype(t1) != ttype(t2)) return 0;
  else switch (ttype(t1)) {
    case LUA_TNIL:
      return 1;
    case LUA_TNUMBER:
      return luai_numeq(nvalue(t1), nvalue(t2));
    case LUA_TBOOLEAN:
      return bvalue(t1) == bvalue(t2);  /* boolean true must be 1 !! */
    case LUA_TLIGHTUSERDATA:
      return pvalue(t1) == pvalue(t2);
    default:
      lua_assert(iscollectable(t1));
      return gcvalue(t1) == gcvalue(t2);
  }
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x9883
cmpl $0x3, %eax
ja 0x9887
movl %eax, %eax
leaq 0xfdba(%rip), %rcx      # 0x19630
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %al
jmp 0x98a9
xorl %eax, %eax
jmp 0x98a9
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x9893
movl (%rdi), %eax
cmpl (%rsi), %eax
sete %al
jmp 0x98a9
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_str2d
int luaO_str2d (const char *s, lua_Number *result) {
  char *endptr;
  *result = lua_str2number(s, &endptr);
  if (endptr == s) return 0;  /* conversion failed */
  if (*endptr == 'x' || *endptr == 'X')  /* maybe an hexadecimal constant? */
    *result = cast_num(strtoul(s, &endptr, 16));
  if (*endptr == '\0') return 1;  /* most common case */
  while (isspace(cast(unsigned char, *endptr))) endptr++;
  if (*endptr != '\0') return 0;  /* invalid trailing characters? */
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x40e0
movsd %xmm0, (%rbx)
movq (%r15), %r15
cmpq %r14, %r15
je 0x9944
movzbl (%r15), %eax
movl %eax, %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0x9921
leaq 0x8(%rsp), %r15
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4460
movq %rax, %xmm0
punpckldq 0xfe4d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xfe55(%rip), %xmm0     # 0x19760
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movq (%r15), %r15
movb (%r15), %al
testb %al, %al
je 0x9948
callq 0x4570
movq (%rax), %rax
movzbl (%r15), %ecx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x992d
xorl %eax, %eax
testb %cl, %cl
sete %al
jmp 0x994b
xorl %eax, %eax
jmp 0x994b
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_chunkid
void luaO_chunkid (char *out, const char *source, size_t bufflen) {
  if (*source == '=') {
    strncpy(out, source+1, bufflen);  /* remove first char */
    out[bufflen-1] = '\0';  /* ensures null termination */
  }
  else {  /* out = "source", or "...source" */
    if (*source == '@') {
      size_t l;
      source++;  /* skip the `@' */
      bufflen -= sizeof(" '...' ");
      l = strlen(source);
      strcpy(out, "");
      if (l > bufflen) {
        source += (l-bufflen);  /* get last part of file name */
        strcat(out, "...");
      }
      strcat(out, source);
    }
    else {  /* out = [string "string"] */
      size_t len = strcspn(source, "\n\r");  /* stop at first newline */
      bufflen -= sizeof(" [string \"...\"] ");
      if (len > bufflen) len = bufflen;
      strcpy(out, "[string \"");
      if (source[len] != '\0') {  /* must truncate? */
        strncat(out, source, len);
        strcat(out, "...");
      }
      else
        strcat(out, source);
      strcat(out, "\"]");
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x40, %eax
je 0x9d29
cmpl $0x3d, %eax
jne 0x9d62
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4090
movb $0x0, -0x1(%rbx,%r15)
jmp 0x9dd3
incq %r14
addq $-0x8, %r15
movq %r14, %rdi
callq 0x4140
movb $0x0, (%rbx)
subq %r15, %rax
jbe 0x9d52
addq %rax, %r14
movq %rbx, %rdi
callq 0x4140
movl $0x2e2e2e, (%rbx,%rax)  # imm = 0x2E2E2E
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4480
leaq 0xfa10(%rip), %rsi      # 0x19779
movq %r14, %rdi
callq 0x4200
addq $-0x11, %r15
cmpq %r15, %rax
cmovbq %rax, %r15
movabsq $0x20676e697274735b, %rax # imm = 0x20676E697274735B
movq %rax, (%rbx)
movw $0x22, 0x8(%rbx)
cmpb $0x0, (%r14,%r15)
je 0x9db5
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x41c0
movq %rbx, %rdi
callq 0x4140
movl $0x2e2e2e, (%rbx,%rax)  # imm = 0x2E2E2E
jmp 0x9dc0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4480
movq %rbx, %rdi
callq 0x4140
movw $0x5d22, (%rbx,%rax)    # imm = 0x5D22
movb $0x0, 0x2(%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: luaY_parser
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
  struct LexState lexstate;
  struct FuncState funcstate;
  lexstate.buff = buff;
  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
  open_func(&lexstate, &funcstate);
  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
  luaX_next(&lexstate);  /* read first token */
  chunk(&lexstate);
  check(&lexstate, TK_EOS);
  close_func(&lexstate);
  lua_assert(funcstate.prev == NULL);
  lua_assert(funcstate.f->nups == 0);
  lua_assert(lexstate.fs == NULL);
  return funcstate.f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %rbx
movq %rdx, 0x48(%rbx)
movq %rcx, %rdi
callq 0x4140
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc466
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x117ce
leaq 0x60(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9e6f
movq (%r14), %rax
movb $0x2, 0x72(%rax)
movq %rbx, %rdi
callq 0x11842
movq %rbx, %rdi
callq 0x9f5a
movq %rbx, %rdi
movl $0x11f, %esi            # imm = 0x11F
callq 0xa835
movq %rbx, %rdi
callq 0xa83f
movq (%r14), %rax
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: open_func
static void open_func (LexState *ls, FuncState *fs) {
  lua_State *L = ls->L;
  Proto *f = luaF_newproto(L);
  fs->f = f;
  fs->prev = ls->fs;  /* linked list of funcstates */
  fs->ls = ls;
  fs->L = L;
  ls->fs = fs;
  fs->pc = 0;
  fs->lasttarget = -1;
  fs->jpc = NO_JUMP;
  fs->freereg = 0;
  fs->nk = 0;
  fs->np = 0;
  fs->nlocvars = 0;
  fs->nactvar = 0;
  fs->bl = NULL;
  f->source = ls->source;
  f->maxstacksize = 2;  /* registers 0/1 are always valid */
  fs->h = luaH_new(L, 0, 0);
  /* anchor table of constants and prototype (to avoid being collected) */
  sethvalue2s(L, L->top, fs->h);
  incr_top(L);
  setptvalue2s(L, L->top, f);
  incr_top(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x86fa
movq %rax, %r14
movq %rax, (%r15)
movq 0x30(%r12), %rax
movq %rax, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %rbx, 0x20(%r15)
movq %r15, 0x30(%r12)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x30(%r15)
orl $-0x1, 0x38(%r15)
andq $0x0, 0x28(%r15)
andq $0x0, 0x3c(%r15)
andq $0x0, 0x43(%r15)
movq 0x50(%r12), %rax
movq %rax, 0x40(%r14)
movb $0x2, 0x73(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc90c
movq %rax, 0x8(%r15)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x5, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0x9f13
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x7732
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, 0x10(%rax)
movl $0x9, 0x18(%rax)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0x9f46
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x7732
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: close_func
static void close_func (LexState *ls) {
  lua_State *L = ls->L;
  FuncState *fs = ls->fs;
  Proto *f = fs->f;
  removevars(ls, 0);
  luaK_ret(fs, 0, 0);  /* final return */
  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
  f->sizecode = fs->pc;
  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
  f->sizelineinfo = fs->pc;
  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
  f->sizek = fs->nk;
  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
  f->sizep = fs->np;
  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
  f->sizelocvars = fs->nlocvars;
  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
  f->sizeupvalues = f->nups;
  lua_assert(luaG_checkcode(f));
  lua_assert(fs->bl == NULL);
  ls->fs = fs->prev;
  /* last token read was anchored in defunct function; must reanchor it */
  if (fs) anchor_token(ls);
  L->top -= 2;  /* remove table and prototype from the stack */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %rbx
movq (%r15), %r12
xorl %esi, %esi
callq 0xaa36
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10513
movslq 0x30(%r15), %rcx
cmpq $-0x1, %rcx
jl 0xa88e
movq 0x18(%r12), %rsi
movslq 0x50(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0x97a6
jmp 0xa896
movq %rbx, %rdi
callq 0x97f0
movq %rax, 0x18(%r12)
movslq 0x30(%r15), %rcx
movl %ecx, 0x50(%r12)
cmpq $-0x1, %rcx
jl 0xa8c6
movq 0x28(%r12), %rsi
movslq 0x54(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0x97a6
jmp 0xa8ce
movq %rbx, %rdi
callq 0x97f0
movq %rax, 0x28(%r12)
movl 0x30(%r15), %eax
movl %eax, 0x54(%r12)
movslq 0x40(%r15), %rcx
cmpq $-0x1, %rcx
jl 0xa902
movq 0x10(%r12), %rsi
movslq 0x4c(%r12), %rdx
shlq $0x4, %rdx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x97a6
jmp 0xa90a
movq %rbx, %rdi
callq 0x97f0
movq %rax, 0x10(%r12)
movl 0x40(%r15), %eax
movl %eax, 0x4c(%r12)
movslq 0x44(%r15), %rcx
cmpq $-0x1, %rcx
jl 0xa93e
movq 0x20(%r12), %rsi
movslq 0x58(%r12), %rdx
shlq $0x3, %rdx
shlq $0x3, %rcx
movq %rbx, %rdi
callq 0x97a6
jmp 0xa946
movq %rbx, %rdi
callq 0x97f0
movq %rax, 0x20(%r12)
movl 0x44(%r15), %eax
movl %eax, 0x58(%r12)
movswq 0x48(%r15), %rcx
leaq 0x1(%rcx), %rax
shrq $0x3c, %rax
jne 0xa97f
movq 0x30(%r12), %rsi
movslq 0x5c(%r12), %rdx
shlq $0x4, %rdx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x97a6
jmp 0xa987
movq %rbx, %rdi
callq 0x97f0
movq %rax, 0x30(%r12)
movswl 0x48(%r15), %eax
movl %eax, 0x5c(%r12)
movzbl 0x70(%r12), %ecx
movq 0x38(%r12), %rsi
movslq 0x48(%r12), %rdx
shlq $0x3, %rdx
shll $0x3, %ecx
movq %rbx, %rdi
callq 0x97a6
movq %rax, 0x38(%r12)
movzbl 0x70(%r12), %eax
movl %eax, 0x48(%r12)
movq 0x10(%r15), %rax
movq %rax, 0x30(%r14)
movl $0xfffffee3, %eax       # imm = 0xFFFFFEE3
addl 0x10(%r14), %eax
cmpl $0x1, %eax
ja 0xa9ef
movq 0x18(%r14), %rsi
movq 0x10(%rsi), %rdx
addq $0x18, %rsi
movq %r14, %rdi
callq 0x11777
addq $-0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: block
static void block (LexState *ls) {
  /* block -> chunk */
  FuncState *fs = ls->fs;
  BlockCnt bl;
  enterblock(fs, &bl, 0);
  chunk(ls);
  lua_assert(bl.breaklist == NO_JUMP);
  leaveblock(fs);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x30(%rdi), %rbx
movq %rsp, %rax
orl $-0x1, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0xe(%rax)
movb 0x4a(%rbx), %dl
movb %dl, 0xc(%rax)
movb %cl, 0xd(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x28(%rbx)
callq 0x9f5a
movq %rbx, %rdi
callq 0xbb98
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: check_match
static void check_match (LexState *ls, int what, int who, int where) {
  if (!testnext(ls, what)) {
    if (where == ls->linenumber)
      error_expected(ls, what);
    else {
      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
             LUA_QS " expected (to close " LUA_QS " at line %d)",
              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0xaa8f
testl %eax, %eax
je 0xab05
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl %ebp, 0x4(%rbx)
jne 0xab1d
movq %rbx, %rdi
movl %r15d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xaa00
movq 0x38(%rbx), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x11669
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11669
leaq 0xefbf(%rip), %rsi      # 0x19b00
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x9c6e
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1176f