LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_getmetatable
LUA_API int lua_getmetatable (lua_State *L, int objindex) {
  const TValue *obj;
  Table *mt = NULL;
  int res;
  lua_lock(L);
  obj = index2adr(L, objindex);
  switch (ttype(obj)) {
    case LUA_TTABLE:
      mt = hvalue(obj)->metatable;
      break;
    case LUA_TUSERDATA:
      mt = uvalue(obj)->metatable;
      break;
    default:
      mt = G(L)->mt[ttype(obj)];
      break;
  }
  if (mt == NULL)
    res = 0;
  else {
    sethvalue(L, L->top, mt);
    api_incr_top(L);
    res = 1;
  }
  lua_unlock(L);
  return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x526a
movslq 0x8(%rax), %rcx
cmpq $0x7, %rcx
je 0x5bc8
cmpl $0x5, %ecx
jne 0x5bd1
movq (%rax), %rax
addq $0x10, %rax
jmp 0x5bdf
movq 0x20(%rbx), %rax
leaq (%rax,%rcx,8), %rax
addq $0xe0, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x5bff
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x5, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
pushq $0x1
popq %rax
jmp 0x5c01
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_getfenv
LUA_API void lua_getfenv (lua_State *L, int idx) {
  StkId o;
  lua_lock(L);
  o = index2adr(L, idx);
  api_checkvalidindex(L, o);
  switch (ttype(o)) {
    case LUA_TFUNCTION:
      sethvalue(L, L->top, clvalue(o)->c.env);
      break;
    case LUA_TUSERDATA:
      sethvalue(L, L->top, uvalue(o)->env);
      break;
    case LUA_TTHREAD:
      setobj2s(L, L->top,  gt(thvalue(o)));
      break;
    default:
      setnilvalue(L->top);
      break;
  }
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x526a
movl 0x8(%rax), %ecx
cmpl $0x8, %ecx
je 0x5c31
cmpl $0x7, %ecx
je 0x5c1e
cmpl $0x6, %ecx
jne 0x5c47
movq 0x10(%rbx), %rcx
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, (%rcx)
pushq $0x5
popq %rax
jmp 0x5c4d
movq (%rax), %rax
movq 0x10(%rbx), %rcx
movq 0x78(%rax), %rdx
movq %rdx, (%rcx)
movl 0x80(%rax), %eax
jmp 0x5c4d
movq 0x10(%rbx), %rcx
xorl %eax, %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_settable
LUA_API void lua_settable (lua_State *L, int idx) {
  StkId t;
  lua_lock(L);
  api_checknelems(L, 2);
  t = index2adr(L, idx);
  api_checkvalidindex(L, t);
  luaV_settable(L, t, L->top - 2, L->top - 1);
  L->top -= 2;  /* pop index and value */
  lua_unlock(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x526a
movq 0x10(%rbx), %rcx
leaq -0x20(%rcx), %rdx
addq $-0x10, %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xda47
addq $-0x20, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_setfield
LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
  StkId t;
  TValue key;
  lua_lock(L);
  api_checknelems(L, 1);
  t = index2adr(L, idx);
  api_checkvalidindex(L, t);
  setsvalue(L, &key, luaS_new(L, k));
  luaV_settable(L, t, &key, L->top - 1);
  L->top--;  /* pop value */
  lua_unlock(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x526a
movq %rax, %r15
movq %r14, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc466
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x4, 0x8(%rdx)
movq 0x10(%rbx), %rcx
addq $-0x10, %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xda47
addq $-0x10, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_rawset
LUA_API void lua_rawset (lua_State *L, int idx) {
  StkId t;
  lua_lock(L);
  api_checknelems(L, 2);
  t = index2adr(L, idx);
  api_check(L, ttistable(t));
  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
  luaC_barriert(L, hvalue(t), L->top-1);
  L->top -= 2;
  lua_unlock(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x526a
movq %rax, %r14
movq 0x10(%rbx), %r15
movq (%rax), %rsi
leaq -0x20(%r15), %rdx
movq %rbx, %rdi
callq 0xccb1
movq -0x10(%r15), %rcx
movq %rcx, (%rax)
movl -0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x5d34
movq -0x10(%rax), %rcx
testb $0x3, 0x9(%rcx)
je 0x5d34
movq (%r14), %rsi
testb $0x4, 0x9(%rsi)
je 0x5d34
movq %rbx, %rdi
callq 0x9143
movq 0x10(%rbx), %rax
addq $-0x20, %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_rawseti
LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
  StkId o;
  lua_lock(L);
  api_checknelems(L, 1);
  o = index2adr(L, idx);
  api_check(L, ttistable(o));
  setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
  luaC_barriert(L, hvalue(o), L->top-1);
  L->top--;
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x526a
movq %rax, %r14
movq 0x10(%rbx), %r15
movq (%rax), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0xcf9d
movq -0x10(%r15), %rcx
movq %rcx, (%rax)
movl -0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x5d9e
movq -0x10(%rax), %rcx
testb $0x3, 0x9(%rcx)
je 0x5d9e
movq (%r14), %rsi
testb $0x4, 0x9(%rsi)
je 0x5d9e
movq %rbx, %rdi
callq 0x9143
movq 0x10(%rbx), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rbx)
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/lapi.c
// Function: lua_setmetatable
LUA_API int lua_setmetatable (lua_State *L, int objindex) {
  TValue *obj;
  Table *mt;
  lua_lock(L);
  api_checknelems(L, 1);
  obj = index2adr(L, objindex);
  api_checkvalidindex(L, obj);
  if (ttisnil(L->top - 1))
    mt = NULL;
  else {
    api_check(L, ttistable(L->top - 1));
    mt = hvalue(L->top - 1);
  }
  switch (ttype(obj)) {
    case LUA_TTABLE: {
      hvalue(obj)->metatable = mt;
      if (mt)
        luaC_objbarriert(L, hvalue(obj), mt);
      break;
    }
    case LUA_TUSERDATA: {
      uvalue(obj)->metatable = mt;
      if (mt)
        luaC_objbarrier(L, rawuvalue(obj), mt);
      break;
    }
    default: {
      G(L)->mt[ttype(obj)] = mt;
      break;
    }
  }
  L->top--;
  lua_unlock(L);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x526a
movq 0x10(%rbx), %rcx
cmpl $0x0, -0x8(%rcx)
je 0x5dca
movq -0x10(%rcx), %rdx
jmp 0x5dcc
xorl %edx, %edx
movslq 0x8(%rax), %rcx
cmpq $0x7, %rcx
je 0x5e00
cmpl $0x5, %ecx
jne 0x5e25
movq (%rax), %rcx
movq %rdx, 0x10(%rcx)
testq %rdx, %rdx
je 0x5e31
testb $0x3, 0x9(%rdx)
je 0x5e31
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0x5e31
movq %rbx, %rdi
callq 0x9143
jmp 0x5e31
movq (%rax), %rcx
movq %rdx, 0x10(%rcx)
testq %rdx, %rdx
je 0x5e31
testb $0x3, 0x9(%rdx)
je 0x5e31
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0x5e31
movq %rbx, %rdi
callq 0x9066
jmp 0x5e31
movq 0x20(%rbx), %rax
movq %rdx, 0xe0(%rax,%rcx,8)
addq $-0x10, 0x10(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_setfenv
LUA_API int lua_setfenv (lua_State *L, int idx) {
  StkId o;
  int res = 1;
  lua_lock(L);
  api_checknelems(L, 1);
  o = index2adr(L, idx);
  api_checkvalidindex(L, o);
  api_check(L, ttistable(L->top - 1));
  switch (ttype(o)) {
    case LUA_TFUNCTION:
      clvalue(o)->c.env = hvalue(L->top - 1);
      break;
    case LUA_TUSERDATA:
      uvalue(o)->env = hvalue(L->top - 1);
      break;
    case LUA_TTHREAD:
      sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));
      break;
    default:
      res = 0;
      break;
  }
  if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
  L->top--;
  lua_unlock(L);
  return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x526a
movl 0x8(%rax), %ecx
cmpl $0x8, %ecx
je 0x5e6b
cmpl $0x7, %ecx
je 0x5e5a
xorl %ebp, %ebp
cmpl $0x6, %ecx
jne 0x5ea6
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rcx
movq (%rax), %rdx
movq %rcx, 0x18(%rdx)
jmp 0x5e84
movq (%rax), %rcx
movq 0x10(%rbx), %rdx
movq -0x10(%rdx), %rdx
movq %rdx, 0x78(%rcx)
movl $0x5, 0x80(%rcx)
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rdx
pushq $0x1
popq %rbp
testb $0x3, 0x9(%rdx)
je 0x5ea6
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0x5ea6
movq %rbx, %rdi
callq 0x9066
addq $-0x10, 0x10(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_call
LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
  StkId func;
  lua_lock(L);
  api_checknelems(L, nargs+1);
  checkresults(L, nargs, nresults);
  func = L->top - (nargs+1);
  luaD_call(L, func, nresults);
  adjustresults(L, nresults);
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
notl %esi
movslq %esi, %rsi
shlq $0x4, %rsi
addq 0x10(%rdi), %rsi
callq 0x7d4b
cmpl $-0x1, %ebp
jne 0x5ee5
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x5ee5
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_pcall
LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
  struct CallS c;
  int status;
  ptrdiff_t func;
  lua_lock(L);
  api_checknelems(L, nargs+1);
  checkresults(L, nargs, nresults);
  if (errfunc == 0)
    func = 0;
  else {
    StkId o = index2adr(L, errfunc);
    api_checkvalidindex(L, o);
    func = savestack(L, o);
  }
  c.func = L->top - (nargs+1);  /* function to be called */
  c.nresults = nresults;
  status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
  adjustresults(L, nresults);
  lua_unlock(L);
  return status;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
testl %ecx, %ecx
je 0x5f16
movq %rbx, %rdi
movl %ecx, %esi
callq 0x526a
movq %rax, %r8
movq 0x40(%rbx), %rax
subq %rax, %r8
jmp 0x5f1d
movq 0x40(%rbx), %rax
xorl %r8d, %r8d
notl %r14d
movslq %r14d, %rcx
shlq $0x4, %rcx
addq 0x10(%rbx), %rcx
movq %rsp, %rdx
movq %rcx, (%rdx)
movl %ebp, 0x8(%rdx)
subq %rax, %rcx
leaq 0x28(%rip), %rsi        # 0x5f66
movq %rbx, %rdi
callq 0x7f89
cmpl $-0x1, %ebp
jne 0x5f5d
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rdx
cmpq 0x10(%rdx), %rcx
jb 0x5f5d
movq %rcx, 0x10(%rdx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_cpcall
LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
  struct CCallS c;
  int status;
  lua_lock(L);
  c.func = func;
  c.ud = ud;
  status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);
  lua_unlock(L);
  return status;
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq 0x10(%rdi), %rcx
subq 0x40(%rdi), %rcx
leaq 0x10(%rip), %rsi        # 0x5fa3
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x7f89
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: f_Ccall
static void f_Ccall (lua_State *L, void *ud) {
  struct CCallS *c = cast(struct CCallS *, ud);
  Closure *cl;
  cl = luaF_newCclosure(L, 0, getcurrenv(L));
  cl->c.f = c->func;
  setclvalue(L, L->top, cl);  /* push function */
  api_incr_top(L);
  setpvalue(L->top, c->ud);  /* push only argument */
  api_incr_top(L);
  luaD_call(L, L->top - 2, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x5fc4
movq 0x8(%rax), %rax
movq (%rax), %rax
addq $0x18, %rax
jmp 0x5fc8
leaq 0x78(%rbx), %rax
movq (%rax), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x84d4
movq (%r14), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x6, 0x8(%rcx)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x10(%rax)
movl $0x2, 0x18(%rax)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x10, %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7d4b
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_load
LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
                      const char *chunkname) {
  ZIO z;
  int status;
  lua_lock(L);
  if (!chunkname) chunkname = "?";
  luaZ_init(L, &z, reader, data);
  status = luaD_protectedparser(L, &z, chunkname);
  lua_unlock(L);
  return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
testq %rcx, %rcx
leaq 0x147f6(%rip), %r14     # 0x1a838
cmovneq %rcx, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
movq %rax, %rcx
callq 0xf316
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8062
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_dump
LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
  int status;
  TValue *o;
  lua_lock(L);
  api_checknelems(L, 1);
  o = L->top - 1;
  if (isLfunction(o))
    status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);
  else
    status = 1;
  lua_unlock(L);
  return status;
}

// Assembly:
movq 0x10(%rdi), %rax
cmpl $0x6, -0x8(%rax)
jne 0x6082
movq -0x10(%rax), %rax
cmpb $0x0, 0xa(%rax)
je 0x6086
pushq $0x1
popq %rax
retq
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x20(%rax), %rsi
xorl %r8d, %r8d
jmp 0x817c
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x7, %esi
ja 0x615b
movq %rdi, %r14
movq 0x20(%rdi), %r15
movl %esi, %eax
leaq 0x131e3(%rip), %rcx     # 0x192a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $-0x3, 0x70(%r15)
jmp 0x610a
movl $0x3ff, %ebx            # imm = 0x3FF
andl 0x78(%r15), %ebx
jmp 0x615e
movq %r14, %rdi
callq 0x8f60
jmp 0x610a
movq 0x78(%r15), %rbx
shrq $0xa, %rbx
jmp 0x615e
movl 0x94(%r15), %ebx
movl %edx, 0x94(%r15)
jmp 0x615e
movq 0x78(%r15), %rax
movq %rax, 0x70(%r15)
xorl %ebx, %ebx
jmp 0x615e
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)
pushq $0x1
popq %rbp
movq 0x70(%r15), %rax
cmpq 0x78(%r15), %rax
ja 0x615e
movq %r14, %rdi
callq 0x8b89
cmpb $0x0, 0x21(%r15)
jne 0x612e
movl %ebp, %ebx
jmp 0x615e
movl 0x90(%r15), %ebx
movl %edx, 0x90(%r15)
jmp 0x615e
pushq $-0x1
popq %rbx
movl %ebx, %eax
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/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 0x526a
movq (%rax), %rsi
movq 0x10(%rbx), %rdx
addq $-0x10, %rdx
movq %rbx, %rdi
callq 0xc624
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_O2/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 0x61f7
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x61d1
movq %rbx, %rdi
callq 0x8b89
movq 0x10(%rbx), %rdx
subq 0x18(%rbx), %rdx
shrq $0x4, %rdx
decl %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0xdea8
decl %r14d
shlq $0x4, %r14
subq %r14, 0x10(%rbx)
jmp 0x6221
testl %r14d, %r14d
jne 0x6221
movq 0x10(%rbx), %r14
leaq 0x14f73(%rip), %rsi     # 0x1b17a
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc466
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_O2/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 0x526a
movq %rsp, %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x62f6
testq %rax, %rax
je 0x62ef
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_O2/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 0x6336
movq (%rdi), %rax
cmpb $0x0, 0xa(%rax)
je 0x6329
testl %esi, %esi
jle 0x6336
movzbl 0xb(%rax), %ecx
cmpl %esi, %ecx
jb 0x6336
decl %esi
shlq $0x4, %rsi
addq %rsi, %rax
addq $0x28, %rax
movq %rax, (%rdx)
leaq 0x14e52(%rip), %rax     # 0x1b17a
retq
testl %esi, %esi
jle 0x6336
movq 0x20(%rax), %rcx
cmpl %esi, 0x48(%rcx)
jge 0x6339
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_O2/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 0x526a
movq %rax, %r15
movq %rsp, %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x62f6
movq %rax, %r14
testq %rax, %rax
je 0x63be
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 0x63be
movq (%rax), %rdx
testb $0x3, 0x9(%rdx)
je 0x63be
movq (%r15), %rsi
testb $0x4, 0x9(%rsi)
je 0x63be
movq %rbx, %rdi
callq 0x9066
movq %r14, %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/ldebug.c
// Function: lua_sethook
LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
  if (func == NULL || mask == 0) {  /* turn off hooks? */
    mask = 0;
    func = NULL;
  }
  L->hook = func;
  L->basehookcount = count;
  resethookcount(L);
  L->hookmask = cast_byte(mask);
  return 1;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %r8d
cmovneq %rsi, %r8
testq %rsi, %rsi
movq %r8, 0x70(%rdi)
movl %ecx, 0x68(%rdi)
cmovel %eax, %edx
movl %ecx, 0x6c(%rdi)
movb %dl, 0x64(%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rcx
movq 0x28(%rdi), %rax
movq %rax, %r8
testl %esi, %esi
jle 0x6430
cmpq 0x50(%rdi), %r8
jbe 0x6454
decl %esi
movq 0x8(%r8), %rdx
movq (%rdx), %rdx
cmpb $0x0, 0xa(%rdx)
jne 0x6426
subl 0x24(%r8), %esi
addq $-0x28, %r8
addq $-0x28, %rax
jmp 0x6409
xorl %edx, %edx
testl %esi, %esi
jne 0x644d
movq 0x50(%rdi), %rdx
cmpq %rdx, %r8
jbe 0x6454
subq %rdx, %rax
pushq $0x28
popq %rsi
cqto
idivq %rsi
movq %rax, %rdx
movl %edx, 0x74(%rcx)
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0x28, %rax, %r15
addq 0x50(%rdi), %r15
movq %r15, %rsi
callq 0x64a7
movq %rax, %r14
testq %rax, %rax
je 0x6499
movq (%r15), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
callq 0x50cc
movq %r14, %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/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 %rsi, %rdi
callq 0x73a1
testq %rax, %rax
je 0x64e3
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x73bc
movq %r12, %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x8810
testq %rax, %rax
jne 0x6516
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 0x12fd1(%rip), %rax     # 0x194dd
cmovlq %rdx, %rax
testl %ebx, %ebx
cmovleq %rdx, %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/ldebug.c
// Function: lua_setlocal
LUA_API const char *lua_setlocal (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)
      setobjs2s(L, ci->base + (n - 1), L->top - 1);
  L->top--;  /* pop value */
  lua_unlock(L);
  return name;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movslq 0x74(%rsi), %rax
imulq $0x28, %rax, %r14
addq 0x50(%rdi), %r14
movq %r14, %rsi
callq 0x64a7
testq %rax, %rax
je 0x6562
movq 0x10(%rbx), %rcx
movq (%r14), %rdx
movslq %ebp, %rsi
shlq $0x4, %rsi
movq -0x10(%rcx), %rdi
movq %rdi, -0x10(%rdx,%rsi)
movl -0x8(%rcx), %ecx
movl %ecx, -0x8(%rdx,%rsi)
addq $-0x10, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
movq %rsi, %rdx
movq %rdi, %r15
movslq 0x8(%rsi), %rax
leaq 0x1f1ea(%rip), %rcx     # 0x26160
movq (%rcx,%rax,8), %r14
movq 0x28(%rdi), %rsi
movq (%rsi), %rcx
movq 0x10(%rsi), %rax
cmpq %rax, %rcx
jae 0x6fd8
leaq 0x10(%rcx), %rdi
cmpq %rdx, %rcx
movq %rdi, %rcx
jne 0x6f85
subq 0x18(%r15), %rdx
shrq $0x4, %rdx
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
callq 0x6ff8
testq %rax, %rax
je 0x6fd8
movq 0x8(%rsp), %r8
leaq 0x12484(%rip), %rsi     # 0x19440
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 0x7165
leaq 0x12484(%rip), %rsi     # 0x19463
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7165
// File: /workspace/github_c_makefile_star2_O2/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 0x1ee8c(%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 0x72f8
leaq 0x121af(%rip), %rsi     # 0x1949e
xorl %eax, %eax
callq 0x7165
jmp 0x7306
leaq 0x121c0(%rip), %rsi     # 0x194bf
xorl %eax, %eax
callq 0x7165
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rax
cmpl $0x6, 0x8(%rdx)
jne 0x73d2
movq (%rdx), %rcx
cmpb $0x0, 0xa(%rcx)
je 0x73d3
retq
cmpq %rsi, 0x28(%rdi)
je 0x73df
movq 0x18(%rsi), %rax
jmp 0x73ea
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_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldebug.c
// Function: currentline
static int currentline (lua_State *L, CallInfo *ci) {
  int pc = currentpc(L, ci);
  if (pc < 0)
    return -1;  /* only active lua functions have current-line information */
  else
    return getline(ci_func(ci)->l.p, pc);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x73bc
testl %eax, %eax
js 0x7421
movq 0x8(%rbx), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0x7426
movl %eax, %eax
movl (%rcx,%rax,4), %eax
jmp 0x7428
pushq $-0x1
popq %rax
jmp 0x7428
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x743f
cmpl $0x2, %edx
je 0x7445
testl %edx, %edx
jne 0x744d
testl %esi, %esi
je 0x744d
xorl %eax, %eax
retq
btl $0x8, %esi
jb 0x7451
movzbl 0x73(%rdi), %eax
cmpl %esi, %eax
jle 0x743c
pushq $0x1
popq %rax
retq
andl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
cmpl 0x4c(%rdi), %esi
jge 0x743c
jmp 0x744d
// File: /workspace/github_c_makefile_star2_O2/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 0x74b3
cmpl $0x5, %esi
je 0x74c3
cmpl $0x4, %esi
jne 0x74de
leaq 0x11b6a(%rip), %rsi     # 0x19019
pushq $0x11
jmp 0x74cc
movq 0x10(%r14), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rbx)
movl -0x8(%rax), %eax
jmp 0x74db
leaq 0x12060(%rip), %rsi     # 0x1952a
pushq $0x17
popq %rdx
movq %r14, %rdi
callq 0xc466
movq %rax, (%rbx)
pushq $0x4
popq %rax
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_O2/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 0x7571
movb %bpl, 0xa(%rbx)
movq 0x20(%rbx), %rax
cmpq $0x0, 0x98(%rax)
je 0x7569
leaq 0xa8(%rbx), %r14
movq 0x50(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%rax), %rsi
movq %rsi, 0x18(%rbx)
movq %rbx, %rdi
callq 0x867b
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x748c
movzwl 0x62(%rbx), %eax
movw %ax, 0x60(%rbx)
movb $0x1, 0x65(%rbx)
movq %rbx, %rdi
callq 0x8037
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq 0x20(%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
pushq $0x1
popq %rdi
callq 0x44c0
movl %ebp, 0xd0(%rdi)
addq $0x8, %rdi
pushq $0x1
popq %rsi
callq 0x4400
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldo.c
// Function: luaD_rawrunprotected
int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
  struct lua_longjmp lj;
  lj.status = 0;
  lj.previous = L->errorJmp;  /* chain new error handler */
  L->errorJmp = &lj;
  LUAI_TRY(L, &lj,
    (*f)(L, ud);
  );
  L->errorJmp = lj.previous;  /* restore old error handler */
  return lj.status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movl $0x0, 0xd0(%rax)
movq 0xa8(%rdi), %rcx
movq %rcx, (%rax)
movq %rax, 0xa8(%rdi)
leaq 0x10(%rsp), %rdi
callq 0x4260
testl %eax, %eax
jne 0x75cf
movq %rbx, %rdi
movq %r15, %rsi
callq *%r14
movq 0x8(%rsp), %rax
movq %rax, 0xa8(%rbx)
movl 0xd8(%rsp), %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7625
movslq 0x58(%rbx), %rdx
shlq $0x4, %rdx
movslq %ebp, %rcx
shlq $0x4, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x97a6
jmp 0x762d
movq %rbx, %rdi
callq 0x97f0
movq %rax, 0x40(%rbx)
movl %ebp, 0x58(%rbx)
movslq %r15d, %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x38(%rbx)
movq 0x10(%rbx), %rcx
subq %r14, %rcx
addq %rax, %rcx
movq %rcx, 0x10(%rbx)
leaq 0x98(%rbx), %rcx
movq (%rcx), %rcx
movq 0x40(%rbx), %rax
testq %rcx, %rcx
je 0x7673
movq 0x10(%rcx), %rdx
subq %r14, %rdx
addq %rdx, %rax
movq %rax, 0x10(%rcx)
jmp 0x7657
movq 0x28(%rbx), %rcx
movq 0x50(%rbx), %rdx
cmpq %rcx, %rdx
ja 0x76ae
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 0x767b
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_O2/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 0x76f8
movslq 0x5c(%rbx), %rax
imulq $0x28, %rax, %rdx
movslq %ebp, %r15
imulq $0x28, %r15, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x97a6
jmp 0x7703
movq %rbx, %rdi
callq 0x97f0
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)
imulq $0x28, %r15, %rcx
addq %rcx, %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_O2/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 0x77fa
movq %rdi, %rbx
cmpb $0x0, 0x65(%rdi)
je 0x77fa
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rdi
movq 0x40(%rbx), %r8
movq 0x10(%rdi), %r15
movl %esi, (%rsp)
movl %edx, 0x28(%rsp)
xorl %eax, %eax
cmpl $0x4, %esi
je 0x7799
movq %rdi, %rax
subq 0x50(%rbx), %rax
pushq $0x28
popq %rsi
cqto
idivq %rsi
movq %rcx, %r12
subq %r8, %r12
subq %r8, %r15
movl %eax, 0x74(%rsp)
movq 0x38(%rbx), %rax
subq %rcx, %rax
cmpq $0x140, %rax            # imm = 0x140
jg 0x77c8
pushq $0x14
popq %rsi
movq %rbx, %rdi
callq 0x7732
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rdi
addq $0x140, %rcx            # imm = 0x140
movq %rcx, 0x10(%rdi)
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_O2/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 0x7c70
addl %esi, %esi
movq %rbx, %rdi
callq 0x76c7
cmpl $0x4e21, 0x5c(%rbx)     # imm = 0x4E21
jl 0x7c62
leaq 0x118ec(%rip), %rsi     # 0x19544
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7165
movq 0x28(%rbx), %rax
addq $0x28, %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x74ee
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testb $0x2, 0x64(%rdi)
je 0x7cb9
movq 0x40(%rbx), %r12
pushq $0x1
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7747
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
je 0x7d21
subq %r12, %r14
addq 0x40(%rbx), %r14
movq 0x28(%rbx), %rdx
leaq -0x28(%rdx), %rax
movq %rax, 0x28(%rbx)
movq -0x28(%rdx), %rsi
movq 0x8(%rdx), %rcx
movl 0x20(%rdx), %eax
movq %rsi, 0x18(%rbx)
movq -0x10(%rdx), %rdx
movq %rdx, 0x30(%rbx)
movl %eax, %edx
movl %eax, %esi
subl $0x1, %esi
jb 0x7d0e
cmpq 0x10(%rbx), %r14
jae 0x7d0e
movq (%r14), %rdx
movq %rdx, (%rcx)
movl 0x8(%r14), %edx
movl %edx, 0x8(%rcx)
addq $0x10, %rcx
addq $0x10, %r14
movl %esi, %edx
jmp 0x7ce0
decl %edx
andl $0x0, 0x8(%rcx)
addq $0x10, %rcx
testl %edx, %edx
jg 0x7d04
movq %rcx, 0x10(%rbx)
incl %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rbp
pushq $-0x1
popq %r15
testb $0x2, 0x64(%rbx)
je 0x7cb2
movq 0x28(%rbx), %rax
subl $0x1, 0x24(%rax)
jb 0x7cb2
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x7747
jmp 0x7d28
// File: /workspace/github_c_makefile_star2_O2/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)
cmpw $0xc8, %ax
jb 0x7d81
jne 0x7d7b
leaq 0x117d3(%rip), %rsi     # 0x19542
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7165
jmp 0x7d81
cmpw $0xe1, %ax
jae 0x7dc0
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7806
testl %eax, %eax
jne 0x7d9d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xe122
decw 0x60(%rbx)
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jae 0x7db4
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b89
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x74ee
// File: /workspace/github_c_makefile_star2_O2/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 0x7df1
testl %eax, %eax
jne 0x7de8
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x7df1
leaq 0x11764(%rip), %rsi     # 0x19553
jmp 0x7e02
movzwl 0x60(%rbx), %eax
cmpw $0xc8, %ax
jb 0x7e0f
leaq 0x11740(%rip), %rsi     # 0x19542
movq %rbx, %rdi
callq 0x7e6d
pushq $0x2
popq %rbp
jmp 0x7e64
incl %eax
movw %ax, 0x60(%rbx)
movw %ax, 0x62(%rbx)
movq 0x10(%rbx), %rdx
movslq %esi, %rax
shlq $0x4, %rax
subq %rax, %rdx
leaq 0xa4(%rip), %rsi        # 0x7ed2
movq %rbx, %rdi
callq 0x7583
testl %eax, %eax
je 0x7e5c
movl %eax, %ebp
movb %bpl, 0xa(%rbx)
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x748c
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rax, 0x10(%rcx)
jmp 0x7e60
movzbl 0xa(%rbx), %ebp
decw 0x60(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc466
movq %rax, (%r15)
movl $0x4, 0x8(%r15)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0x7ec4
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x7732
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7f0d
movq 0x28(%rbx), %rax
movb $0x0, 0xa(%rbx)
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
cmpb $0x0, 0xa(%rcx)
je 0x7f22
movq %rbx, %rdi
callq 0x7c7b
movl %eax, %ecx
movq 0x28(%rbx), %rax
testl %ecx, %ecx
je 0x7f2f
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x7f2f
addq $-0x10, %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7806
testl %eax, %eax
je 0x7f2b
popq %rbx
retq
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
jmp 0x7f2f
movq 0x28(%rbx), %rax
subq 0x50(%rbx), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0xe122
// File: /workspace/github_c_makefile_star2_O2/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 0x7f69
leaq 0x1161a(%rip), %rsi     # 0x19579
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7165
movq 0x10(%rbx), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
subq %rcx, %rax
movq %rax, 0x18(%rbx)
movb $0x1, 0xa(%rbx)
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7583
movl %eax, %ebp
testl %eax, %eax
je 0x801f
subq %r12, %r13
addq 0x40(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x867b
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x748c
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 0x8037
movq %r15, 0xb0(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq