LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_gc
LUA_API int lua_gc (lua_State *L, int what, int data) {
  int res = 0;
  global_State *g;
  lua_lock(L);
  g = G(L);
  switch (what) {
    case LUA_GCSTOP: {
      g->GCthreshold = MAX_LUMEM;
      break;
    }
    case LUA_GCRESTART: {
      g->GCthreshold = g->totalbytes;
      break;
    }
    case LUA_GCCOLLECT: {
      luaC_fullgc(L);
      break;
    }
    case LUA_GCCOUNT: {
      /* GC values are expressed in Kbytes: #bytes/2^10 */
      res = cast_int(g->totalbytes >> 10);
      break;
    }
    case LUA_GCCOUNTB: {
      res = cast_int(g->totalbytes & 0x3ff);
      break;
    }
    case LUA_GCSTEP: {
      lu_mem a = (cast(lu_mem, data) << 10);
      if (a <= g->totalbytes)
        g->GCthreshold = g->totalbytes - a;
      else
        g->GCthreshold = 0;
      while (g->GCthreshold <= g->totalbytes) {
        luaC_step(L);
        if (g->gcstate == GCSpause) {  /* end of cycle? */
          res = 1;  /* signal it */
          break;
        }
      }
      break;
    }
    case LUA_GCSETPAUSE: {
      res = g->gcpause;
      g->gcpause = data;
      break;
    }
    case LUA_GCSETSTEPMUL: {
      res = g->gcstepmul;
      g->gcstepmul = data;
      break;
    }
    default: res = -1;  /* invalid option */
  }
  lua_unlock(L);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x7, %esi
ja 0x65ac
movq %rdi, %r14
movq 0x20(%rdi), %r15
movl %esi, %eax
leaq 0x14dc2(%rip), %rcx     # 0x1b2d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $-0x3, 0x70(%r15)
jmp 0x655b
movl $0x3ff, %ebx            # imm = 0x3FF
andl 0x78(%r15), %ebx
jmp 0x65b1
movq %r14, %rdi
callq 0x986e
jmp 0x655b
movq 0x78(%r15), %rbx
shrq $0xa, %rbx
jmp 0x65b1
movl 0x94(%r15), %ebx
movl %edx, 0x94(%r15)
jmp 0x65b1
movq 0x78(%r15), %rax
movq %rax, 0x70(%r15)
xorl %ebx, %ebx
jmp 0x65b1
movslq %edx, %rax
shlq $0xa, %rax
movq 0x78(%r15), %rcx
xorl %ebx, %ebx
subq %rax, %rcx
movl $0x0, %eax
cmovaeq %rcx, %rax
movq %rax, 0x70(%r15)
movq 0x70(%r15), %rax
cmpq 0x78(%r15), %rax
ja 0x65b1
movq %r14, %rdi
callq 0x93fe
cmpb $0x0, 0x21(%r15)
jne 0x657c
movl $0x1, %ebx
jmp 0x65b1
movl 0x90(%r15), %ebx
movl %edx, 0x90(%r15)
jmp 0x65b1
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_next
LUA_API int lua_next (lua_State *L, int idx) {
  StkId t;
  int more;
  lua_lock(L);
  t = index2adr(L, idx);
  api_check(L, ttistable(t));
  more = luaH_next(L, hvalue(t), L->top - 1);
  if (more) {
    api_incr_top(L);
  }
  else  /* no more elements */
    L->top -= 1;  /* remove key */
  lua_unlock(L);
  return more;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x566f
movq (%rax), %rsi
movq 0x10(%rbx), %rdx
addq $-0x10, %rdx
movq %rbx, %rdi
callq 0xd454
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movq 0x10(%rbx), %rdx
shll $0x5, %ecx
addq %rdx, %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_concat
LUA_API void lua_concat (lua_State *L, int n) {
  lua_lock(L);
  api_checknelems(L, n);
  if (n >= 2) {
    luaC_checkGC(L);
    luaV_concat(L, n, cast_int(L->top - L->base) - 1);
    L->top -= (n-1);
  }
  else if (n == 0) {  /* push empty string */
    setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
    api_incr_top(L);
  }
  /* else n == 1; nothing to do */
  lua_unlock(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x6645
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x661f
movq %rbx, %rdi
callq 0x93fe
movq 0x10(%rbx), %rdx
subq 0x18(%rbx), %rdx
shrq $0x4, %rdx
decl %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf190
decl %r14d
shlq $0x4, %r14
subq %r14, 0x10(%rbx)
jmp 0x666f
testl %r14d, %r14d
jne 0x666f
movq 0x10(%rbx), %r14
leaq 0x16b4d(%rip), %rsi     # 0x1d1a2
movq %rbx, %rdi
xorl %edx, %edx
callq 0xd282
movq %rax, (%r14)
movl $0x4, 0x8(%r14)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_getupvalue
LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
  const char *name;
  TValue *val;
  lua_lock(L);
  name = aux_upvalue(index2adr(L, funcindex), n, &val);
  if (name) {
    setobj2s(L, L->top, val);
    api_incr_top(L);
  }
  lua_unlock(L);
  return name;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x566f
movq %rsp, %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x6744
testq %rax, %rax
je 0x673d
movq (%rsp), %rcx
movq 0x10(%rbx), %rdx
movq (%rcx), %rsi
movq %rsi, (%rdx)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rdx)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: aux_upvalue
static const char *aux_upvalue (StkId fi, int n, TValue **val) {
  Closure *f;
  if (!ttisfunction(fi)) return NULL;
  f = clvalue(fi);
  if (f->c.isC) {
    if (!(1 <= n && n <= f->c.nupvalues)) return NULL;
    *val = &f->c.upvalue[n-1];
    return "";
  }
  else {
    Proto *p = f->l.p;
    if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
    *val = f->l.upvals[n-1]->v;
    return getstr(p->upvalues[n-1]);
  }
}

// Assembly:
cmpl $0x6, 0x8(%rdi)
jne 0x6784
movq (%rdi), %rax
cmpb $0x0, 0xa(%rax)
je 0x6777
testl %esi, %esi
jle 0x6784
movzbl 0xb(%rax), %ecx
cmpl %esi, %ecx
jb 0x6784
decl %esi
shlq $0x4, %rsi
addq %rsi, %rax
addq $0x28, %rax
movq %rax, (%rdx)
leaq 0x16a2c(%rip), %rax     # 0x1d1a2
retq
testl %esi, %esi
jle 0x6784
movq 0x20(%rax), %rcx
cmpl %esi, 0x48(%rcx)
jge 0x6787
xorl %eax, %eax
retq
decl %esi
movq 0x28(%rax,%rsi,8), %rax
movq 0x10(%rax), %rax
movq %rax, (%rdx)
movq 0x38(%rcx), %rax
movq (%rax,%rsi,8), %rax
addq $0x18, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_setupvalue
LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
  const char *name;
  TValue *val;
  StkId fi;
  lua_lock(L);
  fi = index2adr(L, funcindex);
  api_checknelems(L, 1);
  name = aux_upvalue(fi, n, &val);
  if (name) {
    L->top--;
    setobj(L, val, L->top);
    luaC_barrier(L, clvalue(fi), L->top);
  }
  lua_unlock(L);
  return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x566f
movq %rax, %r15
movq %rsp, %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x6744
movq %rax, %r14
testq %rax, %rax
je 0x680c
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq (%rsp), %rcx
movq -0x10(%rax), %rdx
movq %rdx, (%rcx)
movl -0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rax
cmpl $0x4, 0x8(%rax)
jl 0x680c
movq (%rax), %rdx
testb $0x3, 0x9(%rdx)
je 0x680c
movq (%r15), %rsi
testb $0x4, 0x9(%rsi)
je 0x680c
movq %rbx, %rdi
callq 0x998e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldebug.c
// Function: lua_getstack
LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
  int status;
  CallInfo *ci;
  lua_lock(L);
  for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
    level--;
    if (f_isLua(ci))  /* Lua function? */
      level -= ci->tailcalls;  /* skip lost tail calls */
  }
  if (level == 0 && ci > L->base_ci) {  /* level found? */
    status = 1;
    ar->i_ci = cast_int(ci - L->base_ci);
  }
  else if (level < 0) {  /* level is of a lost tail call? */
    status = 1;
    ar->i_ci = 0;
  }
  else status = 0;  /* no such level */
  lua_unlock(L);
  return status;
}

// Assembly:
movq 0x28(%rdi), %rax
testl %esi, %esi
jle 0x687d
movq 0x50(%rdi), %rcx
cmpq %rcx, %rax
jbe 0x689c
decl %esi
movq 0x8(%rax), %r8
movq (%r8), %r8
cmpb $0x0, 0xa(%r8)
jne 0x6875
subl 0x24(%rax), %esi
addq $-0x28, %rax
testl %esi, %esi
jg 0x685d
xorl %ecx, %ecx
testl %esi, %esi
jne 0x6893
subq 0x50(%rdi), %rax
jbe 0x689c
shrq $0x3, %rax
imull $0xcccccccd, %eax, %ecx # imm = 0xCCCCCCCD
movl %ecx, 0x74(%rdx)
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldebug.c
// Function: lua_getlocal
LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
  CallInfo *ci = L->base_ci + ar->i_ci;
  const char *name = findlocal(L, ci, n);
  lua_lock(L);
  if (name)
      luaA_pushobject(L, ci->base + (n - 1));
  lua_unlock(L);
  return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movslq 0x74(%rsi), %rax
leaq (%rax,%rax,4), %r14
shlq $0x3, %r14
addq 0x50(%rdi), %r14
movq %r14, %rsi
callq 0x68f3
movq %rax, %r15
testq %rax, %rax
je 0x68e5
movq (%r14), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
callq 0x53b8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldebug.c
// Function: findlocal
static const char *findlocal (lua_State *L, CallInfo *ci, int n) {
  const char *name;
  Proto *fp = getluaproto(ci);
  if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)
    return name;  /* is a local variable in a Lua function */
  else {
    StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;
    if (limit - ci->base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
      return "(*temporary)";
    else
      return NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
cmpl $0x6, 0x8(%rax)
jne 0x6916
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
je 0x6955
leaq 0x10(%r15), %rax
leaq 0x30(%r14), %rcx
cmpq %r14, 0x28(%r15)
cmoveq %rax, %rcx
movq (%rcx), %rax
subq (%r14), %rax
sarq $0x4, %rax
movslq %ebx, %rcx
xorl %edx, %edx
cmpq %rcx, %rax
leaq 0x14bbe(%rip), %rax     # 0x1b4fd
cmovlq %rdx, %rax
testl %ebx, %ebx
cmovleq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x6916
movq %r15, %rdi
movq %r14, %rsi
callq 0x78d6
movq %r12, %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x9047
testq %rax, %rax
jne 0x6949
jmp 0x6916
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldebug.c
// Function: luaG_typeerror
void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
  const char *name = NULL;
  const char *t = luaT_typenames[ttype(o)];
  const char *kind = (isinstack(L->ci, o)) ?
                         getobjname(L, L->ci, cast_int(o - L->base), &name) :
                         NULL;
  if (kind)
    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
                op, kind, name, t);
  else
    luaG_runerror(L, "attempt to %s a %s value", op, t);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
movslq 0x8(%rsi), %rax
leaq 0x1ecea(%rip), %rcx     # 0x26160
movq (%rcx,%rax,8), %r14
movq 0x28(%rdi), %rsi
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
cmpq %rcx, %rax
jae 0x74d7
cmpq %rdx, %rax
je 0x7495
addq $0x10, %rax
jmp 0x7485
subq 0x18(%r15), %rdx
shrq $0x4, %rdx
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
callq 0x74f7
testq %rax, %rax
je 0x74d7
movq 0x8(%rsp), %r8
leaq 0x13fa5(%rip), %rsi     # 0x1b460
movq %r15, %rdi
movq %rbx, %rdx
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7672
leaq 0x13fa5(%rip), %rsi     # 0x1b483
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7672
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldebug.c
// Function: luaG_ordererror
int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
  const char *t1 = luaT_typenames[ttype(p1)];
  const char *t2 = luaT_typenames[ttype(p2)];
  if (t1[2] == t2[2])
    luaG_runerror(L, "attempt to compare two %s values", t1);
  else
    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
  return 0;
}

// Assembly:
pushq %rax
movq %rdx, %rax
movslq 0x8(%rsi), %rcx
leaq 0x1e95f(%rip), %rsi     # 0x26160
movq (%rsi,%rcx,8), %rdx
movslq 0x8(%rax), %rax
movq (%rsi,%rax,8), %rcx
movb 0x2(%rdx), %al
cmpb 0x2(%rcx), %al
jne 0x7825
leaq 0x13ca2(%rip), %rsi     # 0x1b4be
xorl %eax, %eax
callq 0x7672
jmp 0x7833
leaq 0x13cb3(%rip), %rsi     # 0x1b4df
xorl %eax, %eax
callq 0x7672
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldebug.c
// Function: currentpc
static int currentpc (lua_State *L, CallInfo *ci) {
  if (!isLua(ci)) return -1;  /* function is not a Lua function? */
  if (ci == L->ci)
    ci->savedpc = L->savedpc;
  return pcRel(ci->savedpc, ci_func(ci)->l.p);
}

// Assembly:
movq 0x8(%rsi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x6, 0x8(%rdx)
jne 0x78ee
movq (%rdx), %rcx
cmpb $0x0, 0xa(%rcx)
je 0x78ef
retq
cmpq %rsi, 0x28(%rdi)
je 0x78fb
movq 0x18(%rsi), %rax
jmp 0x7906
movq 0x30(%rdi), %rax
movq %rax, 0x18(%rsi)
movq (%rdx), %rcx
movq 0x20(%rcx), %rcx
subq 0x18(%rcx), %rax
shrq $0x2, %rax
decl %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldebug.c
// Function: checkArgMode
static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {
  switch (mode) {
    case OpArgN: check(r == 0); break;
    case OpArgU: break;
    case OpArgR: checkreg(pt, r); break;
    case OpArgK:
      check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);
      break;
  }
  return 1;
}

// Assembly:
cmpl $0x3, %edx
je 0x792a
cmpl $0x2, %edx
je 0x7930
testl %edx, %edx
jne 0x7938
testl %esi, %esi
je 0x7938
xorl %eax, %eax
retq
btl $0x8, %esi
jb 0x793e
movzbl 0x73(%rdi), %eax
cmpl %esi, %eax
jle 0x7927
movl $0x1, %eax
retq
andl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
cmpl 0x4c(%rdi), %esi
jge 0x7927
jmp 0x7938
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_seterrorobj
void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
  switch (errcode) {
    case LUA_ERRMEM: {
      setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
      break;
    }
    case LUA_ERRERR: {
      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
      break;
    }
    case LUA_ERRSYNTAX:
    case LUA_ERRRUN: {
      setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
      break;
    }
  }
  L->top = oldtop + 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leal -0x2(%rsi), %eax
cmpl $0x2, %eax
jb 0x7976
cmpl $0x5, %esi
je 0x7986
cmpl $0x4, %esi
jne 0x79a5
leaq 0x136aa(%rip), %rsi     # 0x1b019
movl $0x11, %edx
jmp 0x7992
movq 0x10(%r14), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rbx)
movl -0x8(%rax), %eax
jmp 0x79a2
leaq 0x13bbd(%rip), %rsi     # 0x1b54a
movl $0x17, %edx
movq %r14, %rdi
callq 0xd282
movq %rax, (%rbx)
movl $0x4, %eax
movl %eax, 0x8(%rbx)
addq $0x10, %rbx
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_throw
void luaD_throw (lua_State *L, int errcode) {
  if (L->errorJmp) {
    L->errorJmp->status = errcode;
    LUAI_THROW(L, L->errorJmp);
  }
  else {
    L->status = cast_byte(errcode);
    if (G(L)->panic) {
      resetstack(L, errcode);
      lua_unlock(L);
      G(L)->panic(L);
    }
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
testq %rdi, %rdi
jne 0x7a3a
movb %bpl, 0xa(%rbx)
movq 0x20(%rbx), %rax
cmpq $0x0, 0x98(%rax)
je 0x7a30
leaq 0xa8(%rbx), %r14
movq 0x50(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%rax), %rsi
movq %rsi, 0x18(%rbx)
movq %rbx, %rdi
callq 0x8e9c
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x794c
movzwl 0x62(%rbx), %eax
movw %ax, 0x60(%rbx)
movb $0x1, 0x65(%rbx)
movq %rbx, %rdi
callq 0x86ae
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq 0x20(%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
movl $0x1, %edi
callq 0x44d0
movl %ebp, 0xd0(%rdi)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x4410
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_reallocstack
void luaD_reallocstack (lua_State *L, int newsize) {
  TValue *oldstack = L->stack;
  int realsize = newsize + 1 + EXTRA_STACK;
  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
  luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
  L->stacksize = realsize;
  L->stack_last = L->stack+newsize;
  correctstack(L, oldstack);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq 0x40(%rdi), %r14
leal 0x6(%r15), %ebp
cmpl $-0x7, %esi
jl 0x7af0
movslq 0x58(%rbx), %rdx
shlq $0x4, %rdx
movslq %ebp, %rcx
shlq $0x4, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa1f6
jmp 0x7af8
movq %rbx, %rdi
callq 0xa242
movq %rax, 0x40(%rbx)
movl %ebp, 0x58(%rbx)
movslq %r15d, %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x38(%rbx)
movq 0x10(%rbx), %rdx
movq 0x98(%rbx), %rcx
subq %r14, %rdx
addq %rax, %rdx
movq %rdx, 0x10(%rbx)
testq %rcx, %rcx
je 0x7b45
movq 0x10(%rcx), %rax
subq %r14, %rax
addq 0x40(%rbx), %rax
movq (%rcx), %rdx
movq %rax, 0x10(%rcx)
movq %rdx, %rcx
testq %rdx, %rdx
jne 0x7b27
movq 0x40(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x50(%rbx), %rdx
cmpq %rcx, %rdx
ja 0x7b80
movq 0x10(%rdx), %rsi
subq %r14, %rsi
addq %rax, %rsi
movq %rsi, 0x10(%rdx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdi
subq %r14, %rsi
addq %rax, %rsi
movq %rsi, (%rdx)
subq %r14, %rdi
addq %rax, %rdi
movq %rdi, 0x8(%rdx)
addq $0x28, %rdx
jmp 0x7b4d
movq 0x18(%rbx), %rcx
subq %r14, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_reallocCI
void luaD_reallocCI (lua_State *L, int newsize) {
  CallInfo *oldci = L->base_ci;
  luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
  L->size_ci = newsize;
  L->ci = (L->ci - oldci) + L->base_ci;
  L->end_ci = L->base_ci + L->size_ci - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x50(%rdi), %r14
cmpl $-0x1, %esi
jl 0x7bd6
movslq 0x5c(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movslq %ebp, %r15
leaq (,%r15,8), %rax
leaq (%rax,%rax,4), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa1f6
jmp 0x7be1
movq %rbx, %rdi
callq 0xa242
movslq %ebp, %r15
movq %rax, 0x50(%rbx)
movl %ebp, 0x5c(%rbx)
movq 0x28(%rbx), %rcx
subq %r14, %rcx
addq %rax, %rcx
movq %rcx, 0x28(%rbx)
leaq (%r15,%r15,4), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0x28, %rax
movq %rax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_callhook
void luaD_callhook (lua_State *L, int event, int line) {
  lua_Hook hook = L->hook;
  if (hook && L->allowhook) {
    ptrdiff_t top = savestack(L, L->top);
    ptrdiff_t ci_top = savestack(L, L->ci->top);
    lua_Debug ar;
    ar.event = event;
    ar.currentline = line;
    if (event == LUA_HOOKTAILRET)
      ar.i_ci = 0;  /* tail call; no debug information about it */
    else
      ar.i_ci = cast_int(L->ci - L->base_ci);
    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
    L->ci->top = L->top + LUA_MINSTACK;
    lua_assert(L->ci->top <= L->stack_last);
    L->allowhook = 0;  /* cannot call hooks inside a hook */
    lua_unlock(L);
    (*hook)(L, &ar);
    lua_lock(L);
    lua_assert(!L->allowhook);
    L->allowhook = 1;
    L->ci->top = restorestack(L, ci_top);
    L->top = restorestack(L, top);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq 0x70(%rdi), %r14
testq %r14, %r14
je 0x7ce7
movq %rdi, %rbx
cmpb $0x0, 0x65(%rdi)
je 0x7ce7
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x40(%rbx), %rdi
movq 0x10(%rcx), %r15
movl %esi, (%rsp)
movl %edx, 0x28(%rsp)
xorl %edx, %edx
cmpl $0x4, %esi
je 0x7c7a
movq %rcx, %rdx
subq 0x50(%rbx), %rdx
shrq $0x3, %rdx
imull $0xcccccccd, %edx, %edx # imm = 0xCCCCCCCD
movq %rax, %r12
subq %rdi, %r12
subq %rdi, %r15
movl %edx, 0x74(%rsp)
movq 0x38(%rbx), %rdx
subq %rax, %rdx
cmpq $0x140, %rdx            # imm = 0x140
jg 0x7cb6
movl 0x58(%rbx), %eax
leal 0x14(%rax), %ecx
leal (%rax,%rax), %esi
cmpl $0x14, %eax
cmovll %ecx, %esi
movq %rbx, %rdi
callq 0x7aba
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
addq $0x140, %rax            # imm = 0x140
movq %rax, 0x10(%rcx)
movb $0x0, 0x65(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq *%r14
movb $0x1, 0x65(%rbx)
movq 0x28(%rbx), %rax
movq 0x40(%rbx), %rcx
addq %rcx, %r15
movq %r15, 0x10(%rax)
addq %rcx, %r12
movq %r12, 0x10(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: growCI
static CallInfo *growCI (lua_State *L) {
  if (L->size_ci > LUAI_MAXCALLS)  /* overflow while handling overflow? */
    luaD_throw(L, LUA_ERRERR);
  else {
    luaD_reallocCI(L, 2*L->size_ci);
    if (L->size_ci > LUAI_MAXCALLS)
      luaG_runerror(L, "stack overflow");
  }
  return ++L->ci;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x5c(%rdi), %esi
cmpl $0x4e21, %esi           # imm = 0x4E21
jge 0x82b6
addl %esi, %esi
movq %rbx, %rdi
callq 0x7b99
cmpl $0x4e21, 0x5c(%rbx)     # imm = 0x4E21
jl 0x82a8
leaq 0x132c6(%rip), %rsi     # 0x1b564
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7672
movq 0x28(%rbx), %rax
addq $0x28, %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
movq %rbx, %rdi
movl $0x5, %esi
callq 0x79b5
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_poscall
int luaD_poscall (lua_State *L, StkId firstResult) {
  StkId res;
  int wanted, i;
  CallInfo *ci;
  if (L->hookmask & LUA_MASKRET)
    firstResult = callrethooks(L, firstResult);
  ci = L->ci--;
  res = ci->func;  /* res == final position of 1st result */
  wanted = ci->nresults;
  L->base = (ci - 1)->base;  /* restore base */
  L->savedpc = (ci - 1)->savedpc;  /* restore savedpc */
  /* move results to correct place */
  for (i = wanted; i != 0 && firstResult < L->top; i--)
    setobjs2s(L, res++, firstResult++);
  while (i-- > 0)
    setnilvalue(res++);
  L->top = res;
  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testb $0x2, 0x64(%rdi)
je 0x8326
movq 0x40(%rbx), %r15
movq %rbx, %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7c26
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
jne 0x831f
jmp 0x8319
movq 0x28(%rbx), %rax
subl $0x1, 0x24(%rax)
jb 0x831f
movq %rbx, %rdi
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7c26
testb $0x2, 0x64(%rbx)
jne 0x82fd
subq %r15, %r14
addq 0x40(%rbx), %r14
movq 0x28(%rbx), %rcx
leaq -0x28(%rcx), %rax
movq %rax, 0x28(%rbx)
movq -0x28(%rcx), %rsi
movq 0x8(%rcx), %rdx
movl 0x20(%rcx), %eax
movq %rsi, 0x18(%rbx)
movq -0x10(%rcx), %rcx
movq %rcx, 0x30(%rbx)
testl %eax, %eax
je 0x839a
leal 0x1(%rax), %ecx
xorl %edi, %edi
cmpq 0x10(%rbx), %r14
jae 0x8379
leaq 0x10(%rdx), %rsi
movq (%r14), %r8
movq %r8, (%rdx)
movl 0x8(%r14), %r8d
movl %r8d, 0x8(%rdx)
incl %edi
addq $0x10, %r14
movq %rsi, %rdx
cmpl %edi, %eax
jne 0x8352
jmp 0x839d
movl %eax, %esi
subl %edi, %esi
testl %esi, %esi
jle 0x839a
subl %edi, %ecx
movq %rdx, %rsi
movl $0x0, 0x8(%rsi)
addq $0x10, %rsi
decl %ecx
cmpl $0x1, %ecx
ja 0x8386
jmp 0x839d
movq %rdx, %rsi
movq %rsi, 0x10(%rbx)
incl %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_call
void luaD_call (lua_State *L, StkId func, int nResults) {
  if (++L->nCcalls >= LUAI_MAXCCALLS) {
    if (L->nCcalls == LUAI_MAXCCALLS)
      luaG_runerror(L, "C stack overflow");
    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
  }
  if (luaD_precall(L, func, nResults) == PCRLUA)  /* is a Lua function? */
    luaV_execute(L, 1);  /* call it */
  L->nCcalls--;
  luaC_checkGC(L);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x60(%rdi), %eax
incl %eax
movw %ax, 0x60(%rdi)
movzwl %ax, %eax
cmpl $0xc8, %eax
jb 0x83e4
jne 0x83dd
leaq 0x13191(%rip), %rsi     # 0x1b562
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7672
jmp 0x83e4
cmpl $0xe1, %eax
jae 0x8425
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7cf3
testl %eax, %eax
jne 0x8402
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf3ef
decw 0x60(%rbx)
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jae 0x8419
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x93fe
movq %rbx, %rdi
movl $0x5, %esi
callq 0x79b5
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: lua_resume
LUA_API int lua_resume (lua_State *L, int nargs) {
  int status;
  lua_lock(L);
  if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
      return resume_error(L, "cannot resume non-suspended coroutine");
  if (L->nCcalls >= LUAI_MAXCCALLS)
    return resume_error(L, "C stack overflow");
  luai_userstateresume(L, nargs);
  lua_assert(L->errfunc == 0);
  L->baseCcalls = ++L->nCcalls;
  status = luaD_rawrunprotected(L, resume, L->top - nargs);
  if (status != 0) {  /* error? */
    L->status = cast_byte(status);  /* mark thread as `dead' */
    luaD_seterrorobj(L, status, L->top);
    L->ci->top = L->top;
  }
  else {
    lua_assert(L->nCcalls == L->baseCcalls);
    status = L->status;
  }
  --L->nCcalls;
  lua_unlock(L);
  return status;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0xa(%rdi), %eax
cmpl $0x1, %eax
je 0x8458
testl %eax, %eax
jne 0x844f
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x8458
leaq 0x1311d(%rip), %rsi     # 0x1b573
jmp 0x846a
movzwl 0x60(%rbx), %eax
cmpl $0xc8, %eax
jb 0x8479
leaq 0x130f8(%rip), %rsi     # 0x1b562
movq %rbx, %rdi
callq 0x84d7
movl $0x2, %ebp
jmp 0x84ce
incl %eax
movw %ax, 0x60(%rbx)
movw %ax, 0x62(%rbx)
movq 0x10(%rbx), %rdx
movslq %esi, %rax
shlq $0x4, %rax
subq %rax, %rdx
leaq 0xaf(%rip), %rsi        # 0x8547
movq %rbx, %rdi
callq 0x7a4e
testl %eax, %eax
je 0x84c6
movl %eax, %ebp
movb %bpl, 0xa(%rbx)
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x794c
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rax, 0x10(%rcx)
jmp 0x84ca
movzbl 0xa(%rbx), %ebp
decw 0x60(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: resume_error
static int resume_error (lua_State *L, const char *msg) {
  L->top = L->ci->base;
  setsvalue2s(L, L->top, luaS_new(L, msg));
  incr_top(L);
  lua_unlock(L);
  return LUA_ERRRUN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq (%rax), %r15
movq %r15, 0x10(%rdi)
movq %rsi, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd282
movq %rax, (%r15)
movl $0x4, 0x8(%r15)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0x8539
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
leal (%rax,%rax), %esi
testl %eax, %eax
cmovlel %ecx, %esi
movq %rbx, %rdi
callq 0x7aba
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: resume
static void resume (lua_State *L, void *ud) {
  StkId firstArg = cast(StkId, ud);
  CallInfo *ci = L->ci;
  if (L->status == 0) {  /* start coroutine? */
    lua_assert(ci == L->base_ci && firstArg > L->base);
    if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)
      return;
  }
  else {  /* resuming from previous yield */
    lua_assert(L->status == LUA_YIELD);
    L->status = 0;
    if (!f_isLua(ci)) {  /* `common' yield? */
      /* finish interrupted execution of `OP_CALL' */
      lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
                 GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
      if (luaD_poscall(L, firstArg))  /* complete it... */
        L->top = L->ci->top;  /* and correct top if not multiple results */
    }
    else  /* yielded inside a hook: just continue its execution */
      L->base = L->ci->base;
  }
  luaV_execute(L, cast_int(L->ci - L->base_ci));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xa(%rdi)
je 0x8580
movq 0x28(%rbx), %rcx
movb $0x0, 0xa(%rbx)
movq 0x8(%rcx), %rax
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
je 0x8597
movq %rbx, %rdi
callq 0x82c3
movq 0x28(%rbx), %rcx
testl %eax, %eax
je 0x85a4
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rbx)
jmp 0x85a4
addq $-0x10, %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7cf3
testl %eax, %eax
je 0x85a0
popq %rbx
retq
movq (%rcx), %rax
movq %rax, 0x18(%rbx)
jmp 0x85a4
movq 0x28(%rbx), %rcx
subq 0x50(%rbx), %rcx
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %esi # imm = 0xCCCCCCCD
movq %rbx, %rdi
popq %rbx
jmp 0xf3ef
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: lua_yield
LUA_API int lua_yield (lua_State *L, int nresults) {
  luai_userstateyield(L, nresults);
  lua_lock(L);
  if (L->nCcalls > L->baseCcalls)
    luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
  L->base = L->top - nresults;  /* protect stack slots below */
  L->status = LUA_YIELD;
  lua_unlock(L);
  return -1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movzwl 0x60(%rdi), %eax
cmpw 0x62(%rdi), %ax
jbe 0x85de
leaq 0x12fc5(%rip), %rsi     # 0x1b599
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7672
movq 0x10(%rbx), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
subq %rcx, %rax
movq %rax, 0x18(%rbx)
movb $0x1, 0xa(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_pcall
int luaD_pcall (lua_State *L, Pfunc func, void *u,
                ptrdiff_t old_top, ptrdiff_t ef) {
  int status;
  unsigned short oldnCcalls = L->nCcalls;
  ptrdiff_t old_ci = saveci(L, L->ci);
  lu_byte old_allowhooks = L->allowhook;
  ptrdiff_t old_errfunc = L->errfunc;
  L->errfunc = ef;
  status = luaD_rawrunprotected(L, func, u);
  if (status != 0) {  /* an error occurred? */
    StkId oldtop = restorestack(L, old_top);
    luaF_close(L, oldtop);  /* close eventual pending closures */
    luaD_seterrorobj(L, status, oldtop);
    L->nCcalls = oldnCcalls;
    L->ci = restoreci(L, old_ci);
    L->base = L->ci->base;
    L->savedpc = L->ci->savedpc;
    L->allowhook = old_allowhooks;
    restore_stack_limit(L);
  }
  L->errfunc = old_errfunc;
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movzwl 0x60(%rdi), %eax
movw %ax, 0x6(%rsp)
movq 0x28(%rdi), %r13
movq 0x50(%rdi), %r12
movb 0x65(%rdi), %al
movb %al, 0x5(%rsp)
movq 0xb0(%rdi), %r15
movq %r8, 0xb0(%rdi)
callq 0x7a4e
movl %eax, %ebp
testl %eax, %eax
je 0x8696
subq %r12, %r13
addq 0x40(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8e9c
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x794c
movzwl 0x6(%rsp), %eax
movw %ax, 0x60(%rbx)
movq 0x50(%rbx), %rax
leaq (%rax,%r13), %rcx
movq %rcx, 0x28(%rbx)
movq (%rax,%r13), %rcx
movq %rcx, 0x18(%rbx)
movq 0x18(%rax,%r13), %rax
movq %rax, 0x30(%rbx)
movb 0x5(%rsp), %al
movb %al, 0x65(%rbx)
movq %rbx, %rdi
callq 0x86ae
movq %r15, 0xb0(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/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
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x20(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x18(%r14)
movq 0x10(%rdi), %rcx
movq 0xb0(%rdi), %r8
subq 0x40(%rdi), %rcx
leaq 0x27(%rip), %rsi        # 0x877f
movq %r14, %rdx
callq 0x8600
movl %eax, %ebp
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10727
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x87ab
movq %rbx, %rdi
callq 0x93fe
leaq 0x8(%r14), %rdx
movq (%r14), %rsi
movq 0x20(%r14), %rcx
movq %rbx, %rdi
callq 0xa858
movq %rax, %r14
movzbl 0x70(%rax), %esi
movq 0x78(%rbx), %rdx
movq %rbx, %rdi
callq 0x8d25
movq %rax, %r15
movq %r14, 0x20(%rax)
cmpb $0x0, 0x70(%r14)
je 0x87fc
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x8da1
movq %rax, 0x28(%r15,%r12,8)
incq %r12
movzbl 0x70(%r14), %eax
cmpq %rax, %r12
jb 0x87e2
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 0x8835
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
leal (%rax,%rax), %esi
testl %eax, %eax
cmovlel %ecx, %esi
movq %rbx, %rdi
callq 0x7aba
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xe9b0
movl $0xc, %edx
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 0x88bd
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_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x8c53
movq %rdi, %r14
movq 0x10(%rdi), %rax
incq %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x8c76
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
testl %eax, %eax
jne 0x8c76
addq $0x18, %r14
movq (%rsp), %rdx
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %r14, %rsi
jmp 0x8c70
movq $0x0, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x8c76
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa1f6
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movl $0x6, %edx
callq 0x9a82
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_O3/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, %r15
movl %esi, %ebx
movq %rdi, %r12
leal 0x28(,%rbx,8), %eax
movslq %eax, %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
movl $0x6, %edx
callq 0x9a82
movb $0x0, 0xa(%r14)
movq %r15, 0x18(%r14)
movb %bl, 0xb(%r14)
testl %ebx, %ebx
je 0x8d92
leal -0x1(%rbx), %eax
movslq %eax, %rcx
shlq $0x3, %rcx
shlq $0x3, %rax
subq %rax, %rcx
leaq (%rcx,%r14), %rdi
addq $0x28, %rdi
movl %ebx, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x41b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/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
movl $0x28, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0xa, %edx
callq 0x9a82
leaq 0x18(%r14), %rax
movq %rax, 0x10(%r14)
movl $0x0, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8e22
cmpq %rbx, 0x10(%rax)
jb 0x8e22
movq %rax, %r15
jne 0x8df7
movb 0x9(%rax), %cl
movb 0x20(%r14), %dl
notb %dl
andb %cl, %dl
testb $0x3, %dl
je 0x8e6c
xorb $0x3, %cl
movb %cl, 0x9(%rax)
jmp 0x8e6c
movl $0x28, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
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_O3/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 0x98(%rdi), %rsi
testq %rsi, %rsi
je 0x8f1f
movq %rdi, %r14
movq 0x20(%rdi), %r15
cmpq %rbx, 0x10(%rsi)
jb 0x8f1f
movq (%rsi), %rax
movq %rax, 0x98(%r14)
movb 0x20(%r15), %al
notb %al
andb 0x9(%rsi), %al
testb $0x3, %al
je 0x8ede
movq %r14, %rdi
callq 0x8e72
jmp 0x8f13
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 0x9a9d
movq 0x98(%r14), %rsi
testq %rsi, %rsi
jne 0x8eb7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x78, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x9, %edx
callq 0x9a82
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movq $0x0, 0x60(%r14)
movl $0x0, 0x70(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa1f6
movq 0x20(%rbx), %rsi
movslq 0x58(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movq 0x10(%rbx), %rsi
movslq 0x4c(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movq 0x28(%rbx), %rsi
movslq 0x54(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movq 0x30(%rbx), %rsi
movslq 0x5c(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movq 0x38(%rbx), %rsi
movslq 0x48(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movl $0x78, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa1f6
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x20(%rdi), %r12
movq 0xb0(%r12), %rbp
movq (%rbp), %r13
testq %r13, %r13
je 0x9150
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movzbl 0x9(%r13), %ecx
testb $0x8, %cl
jne 0x9130
movl %ecx, %eax
andl $0x3, %eax
orl %ebx, %eax
je 0x9130
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x9129
testb $0x4, 0xa(%rdi)
jne 0x9129
movq 0x20(%r14), %rax
movq 0x138(%rax), %rdx
movl $0x2, %esi
callq 0xe204
movb 0x9(%r13), %cl
testq %rax, %rax
je 0x9129
movq (%r13), %rax
movq 0x20(%r13), %rdx
addq %rdx, %r15
addq $0x28, %r15
orb $0x8, %cl
movb %cl, 0x9(%r13)
movq %rax, (%rbp)
movq 0x50(%r12), %rax
testq %rax, %rax
je 0x9142
movq (%rax), %rax
movq %rax, (%r13)
movq 0x50(%r12), %rax
movq %r13, (%rax)
jmp 0x9146
orb $0x8, %cl
movb %cl, 0x9(%r13)
movq %r13, %rbp
movq (%r13), %r13
testq %r13, %r13
jne 0x90b4
jmp 0x9153
movq %r13, (%r13)
movq %r13, 0x50(%r12)
movq %rbp, %r13
jmp 0x9130
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq