LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: check_next
static int check_next (LexState *ls, const char *set) {
  if (!strchr(set, ls->current))
    return 0;
  save_and_next(ls);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq %rsi, %rdi
movl %ebp, %esi
callq 0x4160
testq %rax, %rax
je 0x13d22
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13978
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x13d26
callq 0x106d8
jmp 0x13d35
xorl %eax, %eax
jmp 0x13d3c
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: read_numeral
static void read_numeral (LexState *ls, SemInfo *seminfo) {
  lua_assert(isdigit(ls->current));
  do {
    save_and_next(ls);
  } while (isdigit(ls->current) || ls->current == '.');
  if (check_next(ls, "Ee"))  /* `E'? */
    check_next(ls, "+-");  /* optional exponent sign */
  while (isalnum(ls->current) || ls->current == '_')
    save_and_next(ls);
  save(ls, '\0');
  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
    trydecpoint(ls, seminfo); /* try to update decimal point separator */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13978
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x13d6f
callq 0x106d8
movl %eax, %ebp
jmp 0x13d7e
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movl %ebp, (%rbx)
callq 0x4580
cmpl $0x2e, %ebp
je 0x13d52
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0x13d52
leaq 0x85a9(%rip), %rsi      # 0x1c34e
movq %rbx, %rdi
callq 0x13cf0
testl %eax, %eax
je 0x13dc0
leaq 0x8599(%rip), %rsi      # 0x1c351
movq %rbx, %rdi
callq 0x13cf0
movslq (%rbx), %rsi
cmpq $0x5f, %rsi
je 0x13dd5
movq (%r15), %rax
movzwl (%rax,%rsi,2), %eax
andl $0x8, %eax
je 0x13e12
movq %rbx, %rdi
callq 0x13978
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x13df0
callq 0x106d8
movl %eax, %esi
jmp 0x13dff
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %esi
movl %esi, (%rbx)
cmpl $0x5f, %esi
je 0x13dd5
movq (%r15), %rax
movslq %esi, %rcx
movzwl (%rax,%rcx,2), %eax
jmp 0x13dd0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13978
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x13e46
movb 0x58(%rbx), %cl
cmpb $0x2e, -0x1(%rdi,%rax)
jne 0x13e3a
movb %cl, -0x1(%rdi,%rax)
decq %rax
jne 0x13e2f
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0xa31e
testl %eax, %eax
jne 0x13e9d
callq 0x40f0
testq %rax, %rax
je 0x13e63
movq (%rax), %rax
movb (%rax), %al
jmp 0x13e65
movb $0x2e, %al
movb 0x58(%rbx), %cl
movb %al, 0x58(%rbx)
movq 0x48(%rbx), %rdx
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
je 0x13e91
cmpb %cl, -0x1(%rdi,%rdx)
jne 0x13e85
movb %al, -0x1(%rdi,%rdx)
decq %rdx
jne 0x13e7b
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0xa31e
testl %eax, %eax
je 0x13ea8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%rbx), %rdx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x13ecb
movb 0x58(%rbx), %cl
movq (%rdx), %rdx
cmpb %cl, -0x1(%rdx,%rax)
jne 0x13ec6
movb $0x2e, -0x1(%rdx,%rax)
decq %rax
jne 0x13ebb
leaq 0x8482(%rip), %rsi      # 0x1c354
movq %rbx, %rdi
movl $0x11c, %edx            # imm = 0x11C
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12fda
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_ipairs
static int luaB_ipairs (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
  lua_pushvalue(L, 1);  /* state, */
  lua_pushinteger(L, 0);  /* and initial value */
  return 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x10c7f
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x582a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x582a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5c40
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_pairs
static int luaB_pairs (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
  lua_pushvalue(L, 1);  /* state, */
  lua_pushnil(L);  /* and initial value */
  return 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x10c7f
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x582a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x582a
movq %rbx, %rdi
callq 0x5c17
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_newproxy
static int luaB_newproxy (lua_State *L) {
  lua_settop(L, 1);
  lua_newuserdata(L, 0);  /* create proxy */
  if (lua_toboolean(L, 1) == 0)
    return 1;  /* no metatable */
  else if (lua_isboolean(L, 1)) {
    lua_newtable(L);  /* create a new metatable `m' ... */
    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
    lua_pushboolean(L, 1);
    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
  }
  else {
    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
    if (lua_getmetatable(L, 1)) {
      lua_rawget(L, lua_upvalueindex(1));
      validproxy = lua_toboolean(L, -1);
      lua_pop(L, 1);  /* remove value */
    }
    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
    lua_getmetatable(L, 1);  /* metatable is valid; get it */
  }
  lua_setmetatable(L, 2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x54e9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x669d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a62
testl %eax, %eax
je 0x1426f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x584a
movq %rbx, %rdi
cmpl $0x1, %eax
jne 0x14206
xorl %esi, %esi
xorl %edx, %edx
callq 0x5fa8
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x582a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5e7d
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x6127
jmp 0x14262
movl $0x1, %esi
callq 0x5ff9
testl %eax, %eax
je 0x14241
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x5f47
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a62
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
testl %ebp, %ebp
jne 0x14255
leaq 0x83ff(%rip), %rdx      # 0x1c647
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10820
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5ff9
movq %rbx, %rdi
movl $0x2, %esi
callq 0x61fe
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_assert
static int luaB_assert (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_toboolean(L, 1))
    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
  return lua_gettop(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x10cb3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a62
testl %eax, %eax
je 0x142a3
movq %rbx, %rdi
popq %rbx
jmp 0x54dc
leaq 0x81be(%rip), %rdx      # 0x1c468
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x10acb
leaq 0x8eac(%rip), %rsi      # 0x1d16c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x108d7
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_collectgarbage
static int luaB_collectgarbage (lua_State *L) {
  static const char *const opts[] = {"stop", "restart", "collect",
    "count", "step", "setpause", "setstepmul", NULL};
  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
  int o = luaL_checkoption(L, 1, "collect", opts);
  int ex = luaL_optint(L, 2, 0);
  int res = lua_gc(L, optsnum[o], ex);
  switch (optsnum[o]) {
    case LUA_GCCOUNT: {
      int b = lua_gc(L, LUA_GCCOUNTB, 0);
      lua_pushnumber(L, res + ((lua_Number)b/1024));
      return 1;
    }
    case LUA_GCSTEP: {
      lua_pushboolean(L, res);
      return 1;
    }
    default: {
      lua_pushnumber(L, res);
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x81ab(%rip), %rdx      # 0x1c487
leaq 0x122fd(%rip), %rcx     # 0x265e0
movl $0x1, %esi
callq 0x10a3a
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x10dbc
movslq %ebp, %rcx
leaq 0x8088(%rip), %rdx      # 0x1c390
movl (%rdx,%rcx,4), %r14d
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x64f0
movl %eax, %ebp
cmpl $0x5, %r14d
je 0x1434c
cmpl $0x3, %r14d
jne 0x14358
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x64f0
cvtsi2sd %ebp, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0x8022(%rip), %xmm0     # 0x1c368
addsd %xmm1, %xmm0
jmp 0x1435c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5e7d
jmp 0x14364
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x5c2b
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_dofile
static int luaB_dofile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  int n = lua_gettop(L);
  if (luaL_loadfile(L, fname) != 0) lua_error(L);
  lua_call(L, 0, LUA_MULTRET);
  return lua_gettop(L) - n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x10acb
movq %rax, %r14
movq %rbx, %rdi
callq 0x54dc
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11560
testl %eax, %eax
je 0x143a7
movq %rbx, %rdi
callq 0x65b9
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6305
movq %rbx, %rdi
callq 0x54dc
subl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_getfenv
static int luaB_getfenv (lua_State *L) {
  getfunc(L, 1);
  if (lua_iscfunction(L, -1))  /* is a C function? */
    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
  else
    lua_getfenv(L, -1);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x14d8c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5884
movq %rbx, %rdi
testl %eax, %eax
je 0x1448e
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x582a
jmp 0x14498
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x604e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_load
static int luaB_load (lua_State *L) {
  int status;
  const char *cname = luaL_optstring(L, 2, "=(load)");
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
  status = lua_load(L, generic_reader, NULL, cname);
  return load_aux(L, status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x7fd9(%rip), %rdx      # 0x1c515
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x10acb
movq %rax, %r14
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x10c7f
movq %rbx, %rdi
movl $0x3, %esi
callq 0x54e9
leaq 0x8fb(%rip), %rsi       # 0x14e71
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x6477
testl %eax, %eax
je 0x145a1
movq %rbx, %rdi
callq 0x5c17
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x572e
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_loadstring
static int luaB_loadstring (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  const char *chunkname = luaL_optstring(L, 2, s);
  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x10b24
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x10acb
movq (%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rcx
callq 0x117dc
testl %eax, %eax
je 0x1460b
movq %rbx, %rdi
callq 0x5c17
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x572e
movl $0x2, %ebp
movl %ebp, %eax
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/lbaselib.c
// Function: luaB_pcall
static int luaB_pcall (lua_State *L) {
  int status;
  luaL_checkany(L, 1);
  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
  lua_pushboolean(L, (status == 0));
  lua_insert(L, 1);
  return lua_gettop(L);  /* return status + all results */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x10cb3
movq %rbx, %rdi
callq 0x54dc
leal -0x1(%rax), %esi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x633d
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x5e7d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x572e
movq %rbx, %rdi
popq %rbx
jmp 0x54dc
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_print
static int luaB_print (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    lua_pushvalue(L, -1);  /* function to be called */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tostring(L, -1);  /* get result */
    if (s == NULL)
      return luaL_error(L, LUA_QL("tostring") " must return a string to "
                           LUA_QL("print"));
    if (i>1) fputs("\t", stdout);
    fputs(s, stdout);
    lua_pop(L, 1);  /* pop result */
  }
  fputs("\n", stdout);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x54dc
movl %eax, %r14d
leaq 0x7f99(%rip), %rdx      # 0x1c61c
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x5eef
testl %r14d, %r14d
jle 0x1472f
negl %r14d
movl $0x1, %r15d
movq 0x12927(%rip), %rbp     # 0x26fd0
leaq 0x8198(%rip), %r12      # 0x1c848
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x582a
movq %rbx, %rdi
movl %r15d, %esi
callq 0x582a
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x6305
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x5a88
testq %rax, %rax
je 0x14756
movq %rax, %r13
cmpl $0x2, %r15d
jb 0x14703
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x41a0
movq (%rbp), %rsi
movq %r13, %rdi
callq 0x41a0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x146b0
movq 0x1289a(%rip), %rax     # 0x26fd0
movq (%rax), %rsi
leaq 0x7908(%rip), %rdi      # 0x1c048
callq 0x41a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7dff(%rip), %rsi      # 0x1c55c
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x108d7
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_setfenv
static int luaB_setfenv (lua_State *L) {
  luaL_checktype(L, 2, LUA_TTABLE);
  getfunc(L, 0);
  lua_pushvalue(L, 2);
  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
    /* change environment of current thread */
    lua_pushthread(L);
    lua_insert(L, -2);
    lua_setfenv(L, -2);
    return 0;
  }
  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
    luaL_error(L,
          LUA_QL("setfenv") " cannot change environment of given object");
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
movl $0x5, %edx
callq 0x10c7f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14d8c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x582a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58a3
testl %eax, %eax
je 0x14943
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a04
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14943
jp 0x14943
movq %rbx, %rdi
callq 0x5eab
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x572e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x628a
xorl %eax, %eax
jmp 0x14984
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5884
testl %eax, %eax
je 0x1496c
leaq 0x7c3f(%rip), %rsi      # 0x1c59a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x108d7
movl $0x1, %eax
jmp 0x14984
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x628a
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x14954
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_setmetatable
static int luaB_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  if (luaL_getmetafield(L, 1, "__metatable"))
    luaL_error(L, "cannot change a protected metatable");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %esi
callq 0x584a
movl %eax, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x10c7f
testl %ebp, %ebp
je 0x149c7
cmpl $0x5, %ebp
je 0x149c7
leaq 0x7c14(%rip), %rdx      # 0x1c5ce
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10820
leaq 0x7b3b(%rip), %rdx      # 0x1c509
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10dea
testl %eax, %eax
je 0x149f0
leaq 0x7bfe(%rip), %rsi      # 0x1c5e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x108d7
movq %rbx, %rdi
movl $0x2, %esi
callq 0x54e9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x61fe
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_tonumber
static int luaB_tonumber (lua_State *L) {
  int base = luaL_optint(L, 2, 10);
  if (base == 10) {  /* standard conversion */
    luaL_checkany(L, 1);
    if (lua_isnumber(L, 1)) {
      lua_pushnumber(L, lua_tonumber(L, 1));
      return 1;
    }
  }
  else {
    const char *s1 = luaL_checkstring(L, 1);
    char *s2;
    unsigned long n;
    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
    n = strtoul(s1, &s2, base);
    if (s1 != s2) {  /* at least one valid digit? */
      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
      if (*s2 == '\0') {  /* no invalid trailing characters? */
        lua_pushnumber(L, (lua_Number)n);
        return 1;
      }
    }
  }
  lua_pushnil(L);  /* else not a number */
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %edx
movl $0x2, %esi
callq 0x10dbc
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0xa, %r14d
jne 0x14a69
callq 0x10cb3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58a3
testl %eax, %eax
je 0x14ac8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a04
jmp 0x14af3
xorl %edx, %edx
callq 0x10b24
movq %rax, %r15
leal -0x2(%r14), %eax
cmpl $0x23, %eax
jb 0x14a90
leaq 0x7b85(%rip), %rdx      # 0x1c608
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10820
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x4470
movq (%r12), %r12
cmpq %r12, %r15
je 0x14ac8
movq %rax, %r14
callq 0x4580
movq (%rax), %rax
movzbl (%r12), %ecx
incq %r12
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x14ab5
testb %cl, %cl
je 0x14ad2
movq %rbx, %rdi
callq 0x5c17
jmp 0x14afb
movq %r14, %xmm1
punpckldq 0x6c91(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x6c99(%rip), %xmm1     # 0x1b780
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x5c2b
movl $0x1, %eax
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/lbaselib.c
// Function: luaB_tostring
static int luaB_tostring (lua_State *L) {
  luaL_checkany(L, 1);
  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
    return 1;  /* use its value */
  switch (lua_type(L, 1)) {
    case LUA_TNUMBER:
      lua_pushstring(L, lua_tostring(L, 1));
      break;
    case LUA_TSTRING:
      lua_pushvalue(L, 1);
      break;
    case LUA_TBOOLEAN:
      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
      break;
    case LUA_TNIL:
      lua_pushliteral(L, "nil");
      break;
    default:
      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
      break;
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x10cb3
leaq 0x7af6(%rip), %rdx      # 0x1c61a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10e4f
testl %eax, %eax
je 0x14b42
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x584a
cmpl $0x4, %eax
ja 0x14bd3
movl %eax, %eax
leaq 0x7813(%rip), %rcx      # 0x1c370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x70c2(%rip), %rsi      # 0x1bc2f
movl $0x3, %edx
movq %rbx, %rdi
callq 0x5c5a
jmp 0x14b35
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a88
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x14bb7
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a62
testl %eax, %eax
leaq 0x766a(%rip), %rax      # 0x1c213
leaq 0x767d(%rip), %rsi      # 0x1c22d
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x5cb1
jmp 0x14b35
movq %rbx, %rdi
movl $0x1, %esi
callq 0x582a
jmp 0x14b35
movq %rbx, %rdi
movl $0x1, %esi
callq 0x584a
movq %rbx, %rdi
movl %eax, %esi
callq 0x5868
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5bb5
leaq 0x7a24(%rip), %rsi      # 0x1c625
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x5d2f
jmp 0x14b35
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_unpack
static int luaB_unpack (lua_State *L) {
  int i, e, n;
  luaL_checktype(L, 1, LUA_TTABLE);
  i = luaL_optint(L, 2, 1);
  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
  if (i > e) return 0;  /* empty range */
  n = e - i + 1;  /* number of elements */
  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
    return luaL_error(L, "too many results to unpack");
  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
  while (i++ < e)  /* push arg[i + 1...e] */
    lua_rawgeti(L, 1, i);
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x10c7f
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10dbc
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x584a
movq %rbx, %rdi
testl %eax, %eax
jle 0x14c9b
movl $0x3, %esi
callq 0x10d74
jmp 0x14ca5
movl $0x1, %esi
callq 0x5af9
movq %rax, %r15
xorl %eax, %eax
movl %r15d, %ebp
subl %r14d, %ebp
jl 0x14d04
js 0x14d0f
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x53ce
testl %eax, %eax
je 0x14d0f
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x5f73
cmpl %r14d, %r15d
jle 0x14d02
negl %r15d
incl %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x5f73
leal (%r15,%r14), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x14cdf
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7916(%rip), %rsi      # 0x1c62c
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x108d7
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_xpcall
static int luaB_xpcall (lua_State *L) {
  int status;
  luaL_checkany(L, 2);
  lua_settop(L, 2);
  lua_insert(L, 1);  /* put error function under function to be called */
  status = lua_pcall(L, 0, LUA_MULTRET, 1);
  lua_pushboolean(L, (status == 0));
  lua_replace(L, 1);
  return lua_gettop(L);  /* return status + all results */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
callq 0x10cb3
movq %rbx, %rdi
movl $0x2, %esi
callq 0x54e9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x572e
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x633d
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x5e7d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x576b
movq %rbx, %rdi
popq %rbx
jmp 0x54dc
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: getfunc
static void getfunc (lua_State *L, int opt) {
  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
  else {
    lua_Debug ar;
    int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
    luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
    if (lua_getstack(L, level, &ar) == 0)
      luaL_argerror(L, 1, "invalid level");
    lua_getinfo(L, "f", &ar);
    if (lua_isnil(L, -1))
      luaL_error(L, "no function environment for tail call at level %d",
                    level);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x584a
cmpl $0x6, %eax
jne 0x14dc3
movq %rbx, %rdi
movl $0x1, %esi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x582a
testl %ebp, %ebp
je 0x14ddb
movl $0x1, %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10dbc
jmp 0x14de8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10d74
movq %rax, %r14
testl %r14d, %r14d
jns 0x14e04
leaq 0x76b7(%rip), %rdx      # 0x1c4ae
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10820
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x6851
testl %eax, %eax
jne 0x14e2c
leaq 0x76aa(%rip), %rdx      # 0x1c4c9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10820
leaq 0x7c38(%rip), %rsi      # 0x1ca6b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x69ca
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
testl %eax, %eax
jne 0x14e65
leaq 0x767f(%rip), %rsi      # 0x1c4d7
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x108d7
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: generic_reader
static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
  (void)ud;  /* to avoid warnings */
  luaL_checkstack(L, 2, "too many nested functions");
  lua_pushvalue(L, 1);  /* get function */
  lua_call(L, 0, 1);  /* call it */
  if (lua_isnil(L, -1)) {
    *size = 0;
    return NULL;
  }
  else if (lua_isstring(L, -1)) {
    lua_replace(L, 3);  /* save string in a reserved stack slot */
    return lua_tolstring(L, 3, size);
  }
  else luaL_error(L, "reader function must return a string");
  return NULL;  /* to avoid warnings */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x769b(%rip), %rdx      # 0x1c51d
movl $0x2, %esi
callq 0x10c49
movq %rbx, %rdi
movl $0x1, %esi
callq 0x582a
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x6305
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
testl %eax, %eax
je 0x14eee
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58d4
testl %eax, %eax
je 0x14ef7
movq %rbx, %rdi
movl $0x3, %esi
callq 0x576b
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5a88
movq $0x0, (%r14)
jmp 0x14f08
leaq 0x7639(%rip), %rsi      # 0x1c537
movq %rbx, %rdi
xorl %eax, %eax
callq 0x108d7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_cocreate
static int luaB_cocreate (lua_State *L) {
  lua_State *NL = lua_newthread(L);
  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
    "Lua function expected");
  lua_pushvalue(L, 1);  /* move function to top */
  lua_xmove(L, NL, 1);  /* move function from L to NL */
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x54a5
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x584a
cmpl $0x6, %eax
jne 0x14f44
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5884
testl %eax, %eax
je 0x14f58
leaq 0x7737(%rip), %rdx      # 0x1c682
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10820
movq %rbx, %rdi
movl $0x1, %esi
callq 0x582a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x5441
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_costatus
static int luaB_costatus (lua_State *L) {
  lua_State *co = lua_tothread(L, 1);
  luaL_argcheck(L, co, 1, "coroutine expected");
  lua_pushstring(L, statnames[costatus(L, co)]);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5ba0
testq %rax, %rax
je 0x1504f
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x15068
leaq 0x7642(%rip), %rdx      # 0x1c698
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10820
movq %rbx, %rdi
xorl %esi, %esi
callq 0x151a5
movl %eax, %eax
leaq 0x115aa(%rip), %rcx     # 0x26620
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x5cb1
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: auxresume
static int auxresume (lua_State *L, lua_State *co, int narg) {
  int status = costatus(L, co);
  if (!lua_checkstack(co, narg))
    luaL_error(L, "too many arguments to resume");
  if (status != CO_SUS) {
    lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
    return -1;  /* error flag */
  }
  lua_xmove(L, co, narg);
  lua_setlevel(L, co);
  status = lua_resume(co, narg);
  if (status == 0 || status == LUA_YIELD) {
    int nres = lua_gettop(co);
    if (!lua_checkstack(L, nres + 1))
      luaL_error(L, "too many results to resume");
    lua_xmove(co, L, nres);  /* move yielded values */
    return nres;
  }
  else {
    lua_xmove(co, L, 1);  /* move error message */
    return -1;  /* error flag */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x151a5
movl %eax, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x53ce
testl %eax, %eax
jne 0x150f7
leaq 0x75be(%rip), %rsi      # 0x1c6ab
movq %rbx, %rdi
xorl %eax, %eax
callq 0x108d7
cmpl $0x1, %r15d
jne 0x15160
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5441
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5489
movq %r14, %rdi
movl %ebp, %esi
callq 0x8432
cmpl $0x1, %eax
ja 0x15181
movq %r14, %rdi
callq 0x54dc
movl %eax, %r15d
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x53ce
testl %eax, %eax
jne 0x15150
leaq 0x759d(%rip), %rsi      # 0x1c6e3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x108d7
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x5441
jmp 0x15197
movl %r15d, %eax
leaq 0x114b6(%rip), %rcx     # 0x26620
movq (%rcx,%rax,8), %rdx
leaq 0x7553(%rip), %rsi      # 0x1c6c8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5d2f
jmp 0x15191
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5441
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
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/lbaselib.c
// Function: costatus
static int costatus (lua_State *L, lua_State *co) {
  if (L == co) return CO_RUN;
  switch (lua_status(co)) {
    case LUA_YIELD:
      return CO_SUS;
    case 0: {
      lua_Debug ar;
      if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
        return CO_NOR;  /* it is running */
      else if (lua_gettop(co) == 0)
          return CO_DEAD;
      else
        return CO_SUS;  /* initial state */
    }
    default:  /* some error occured */
      return CO_DEAD;
  }
}

// Assembly:
cmpq %rsi, %rdi
je 0x151f8
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x64eb
cmpl $0x1, %eax
je 0x15200
testl %eax, %eax
jne 0x151fb
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6851
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jg 0x15200
movq %rbx, %rdi
callq 0x54dc
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal 0x1(,%rcx,2), %eax
jmp 0x15200
xorl %eax, %eax
retq
movl $0x3, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: db_gethook
static int db_gethook (lua_State *L) {
  int arg;
  lua_State *L1 = getthread(L, &arg);
  char buff[5];
  int mask = lua_gethookmask(L1);
  lua_Hook hook = lua_gethook(L1);
  if (hook != NULL && hook != hookf)  /* external hook? */
    lua_pushliteral(L, "external hook");
  else {
    gethooktable(L);
    lua_pushlightuserdata(L, L1);
    lua_rawget(L, -2);   /* get hook */
    lua_remove(L, -2);  /* remove hook table */
  }
  lua_pushstring(L, unmakemask(mask, buff));
  lua_pushinteger(L, lua_gethookcount(L1));
  return 3;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
callq 0x15ce7
movq %rax, %r14
movq %rax, %rdi
callq 0x6848
movl %eax, %ebp
movq %r14, %rdi
callq 0x6843
testq %rax, %rax
sete %cl
leaq 0xa39(%rip), %rdx       # 0x15d2d
cmpq %rdx, %rax
sete %al
orb %cl, %al
jne 0x15314
leaq 0x747e(%rip), %rsi      # 0x1c783
movl $0xd, %edx
movq %rbx, %rdi
callq 0x5c5a
jmp 0x15341
movq %rbx, %rdi
callq 0x15dc9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e97
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5f47
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5640
xorl %eax, %eax
testb $0x1, %bpl
je 0x15353
movb $0x63, 0x7(%rsp)
movl $0x1, %eax
testb $0x2, %bpl
je 0x15362
movl %eax, %ecx
incl %eax
movb $0x72, 0x7(%rsp,%rcx)
testb $0x4, %bpl
je 0x15371
movl %eax, %ecx
incl %eax
movb $0x6c, 0x7(%rsp,%rcx)
movl %eax, %eax
movb $0x0, 0x7(%rsp,%rax)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x5cb1
movq %r14, %rdi
callq 0x684d
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5c40
movl $0x3, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: db_getlocal
static int db_getlocal (lua_State *L) {
  int arg;
  lua_State *L1 = getthread(L, &arg);
  lua_Debug ar;
  const char *name;
  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
    return luaL_argerror(L, arg+1, "level out of range");
  name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
  if (name) {
    lua_xmove(L1, L, 1);
    lua_pushstring(L, name);
    lua_pushvalue(L, -2);
    return 2;
  }
  else {
    lua_pushnil(L);
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x15ce7
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10d74
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x6851
testl %eax, %eax
je 0x15747
addl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10d74
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x689f
testq %rax, %rax
je 0x1575a
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5441
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5cb1
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x582a
movl $0x2, %eax
jmp 0x15767
leaq 0x70cf(%rip), %rdx      # 0x1c81d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10820
jmp 0x15767
movq %rbx, %rdi
callq 0x5c17
movl $0x1, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: db_setfenv
static int db_setfenv (lua_State *L) {
  luaL_checktype(L, 2, LUA_TTABLE);
  lua_settop(L, 2);
  if (lua_setfenv(L, 1) == 0)
    luaL_error(L, LUA_QL("setfenv")
                  " cannot change environment of given object");
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
movl $0x5, %edx
callq 0x10c7f
movq %rbx, %rdi
movl $0x2, %esi
callq 0x54e9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x628a
testl %eax, %eax
jne 0x15801
leaq 0x6da3(%rip), %rsi      # 0x1c59a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x108d7
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: db_sethook
static int db_sethook (lua_State *L) {
  int arg, mask, count;
  lua_Hook func;
  lua_State *L1 = getthread(L, &arg);
  if (lua_isnoneornil(L, arg+1)) {
    lua_settop(L, arg+1);
    func = NULL; mask = 0; count = 0;  /* turn off hooks */
  }
  else {
    const char *smask = luaL_checkstring(L, arg+2);
    luaL_checktype(L, arg+1, LUA_TFUNCTION);
    count = luaL_optint(L, arg+3, 0);
    func = hookf; mask = makemask(smask, count);
  }
  gethooktable(L);
  lua_pushlightuserdata(L, L1);
  lua_pushvalue(L, arg+1);
  lua_rawset(L, -3);  /* set new hook */
  lua_pop(L, 1);  /* remove hook table */
  lua_sethook(L1, func, mask, count);  /* set hooks */
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r15
movq %r15, %rsi
callq 0x15ce7
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x584a
testl %eax, %eax
jle 0x158de
leal 0x2(%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10b24
movq %rax, %r12
movq %rbx, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x10c7f
addl $0x3, %r15d
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x10dbc
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movl $0x63, %esi
callq 0x4160
xorl %r13d, %r13d
testq %rax, %rax
setne %r13b
movq %r12, %rdi
movl $0x72, %esi
callq 0x4160
movq %r14, %r15
leal 0x2(%r13), %r14d
testq %rax, %rax
cmovel %r13d, %r14d
movq %r12, %rdi
movl $0x6c, %esi
callq 0x4160
leal 0x4(%r14), %ecx
testq %rax, %rax
cmovel %r14d, %ecx
movq %r15, %r14
movq 0x8(%rsp), %r15
leal 0x8(%rcx), %r12d
testl %r15d, %r15d
cmovlel %ecx, %r12d
leaq 0x451(%rip), %r13       # 0x15d2d
jmp 0x158f1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x54e9
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x15dc9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e97
movq %rbx, %rdi
movl %ebp, %esi
callq 0x582a
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x6127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x681c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: db_setmetatable
static int db_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  lua_settop(L, 2);
  lua_pushboolean(L, lua_setmetatable(L, 1));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
callq 0x584a
testl %eax, %eax
je 0x15a34
cmpl $0x5, %eax
je 0x15a34
leaq 0x6ba7(%rip), %rdx      # 0x1c5ce
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10820
movq %rbx, %rdi
movl $0x2, %esi
callq 0x54e9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x61fe
movq %rbx, %rdi
movl %eax, %esi
callq 0x5e7d
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: hookf
static void hookf (lua_State *L, lua_Debug *ar) {
  static const char *const hooknames[] =
    {"call", "return", "line", "count", "tail return"};
  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
  lua_rawget(L, LUA_REGISTRYINDEX);
  lua_pushlightuserdata(L, L);
  lua_rawget(L, -2);
  if (lua_isfunction(L, -1)) {
    lua_pushstring(L, hooknames[(int)ar->event]);
    if (ar->currentline >= 0)
      lua_pushinteger(L, ar->currentline);
    else lua_pushnil(L);
    lua_assert(lua_getinfo(L, "lS", ar));
    lua_call(L, 2, 0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6b66(%rip), %rsi      # 0x1c8a4
callq 0x5e97
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5f47
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x5e97
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5f47
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
cmpl $0x6, %eax
jne 0x15da6
movslq (%r14), %rax
leaq 0x6b0c(%rip), %rcx      # 0x1c890
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x5cb1
movslq 0x28(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
js 0x15dae
callq 0x5c40
jmp 0x15db3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5c17
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6305
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: gethooktable
static void gethooktable (lua_State *L) {
  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
  lua_rawget(L, LUA_REGISTRYINDEX);
  if (!lua_istable(L, -1)) {
    lua_pop(L, 1);
    lua_createtable(L, 0, 1);
    lua_pushlightuserdata(L, (void *)&KEY_HOOK);
    lua_pushvalue(L, -2);
    lua_rawset(L, LUA_REGISTRYINDEX);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6ad0(%rip), %rsi      # 0x1c8a4
callq 0x5e97
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5f47
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
cmpl $0x5, %eax
jne 0x15dfa
popq %rbx
retq
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x5fa8
leaq 0x6a87(%rip), %rsi      # 0x1c8a4
movq %rbx, %rdi
callq 0x5e97
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x582a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
popq %rbx
jmp 0x6127
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: auxupvalue
static int auxupvalue (lua_State *L, int get) {
  const char *name;
  int n = luaL_checkint(L, 2);
  luaL_checktype(L, 1, LUA_TFUNCTION);
  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
  if (name == NULL) return 0;
  lua_pushstring(L, name);
  lua_insert(L, -(get+1));
  return get + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x2, %esi
callq 0x10d74
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x10c7f
movq %r14, %rdi
movl $0x1, %esi
callq 0x5884
xorl %ebp, %ebp
testl %eax, %eax
jne 0x15f0a
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
testl %ebx, %ebx
je 0x15ee6
callq 0x6705
jmp 0x15eeb
callq 0x67a2
testq %rax, %rax
je 0x15f0a
movq %r14, %rdi
movq %rax, %rsi
callq 0x5cb1
leal 0x1(%rbx), %ebp
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x572e
movl %ebp, %eax
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/liolib.c
// Function: luaopen_io
LUALIB_API int luaopen_io (lua_State *L) {
  createmeta(L);
  /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
  newfenv(L, io_fclose);
  lua_replace(L, LUA_ENVIRONINDEX);
  /* open library */
  luaL_register(L, LUA_IOLIBNAME, iolib);
  /* create (and set) default files */
  newfenv(L, io_noclose);  /* close function for default files */
  createstdfile(L, stdin, IO_INPUT, "stdin");
  createstdfile(L, stdout, IO_OUTPUT, "stdout");
  createstdfile(L, stderr, 0, "stderr");
  lua_pop(L, 1);  /* pop environment for default files */
  lua_getfield(L, -1, "popen");
  newfenv(L, io_pclose);  /* create environment for 'popen' */
  lua_setfenv(L, -2);  /* set fenv for 'popen' */
  lua_pop(L, 1);  /* pop 'popen' */
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6996(%rip), %rsi      # 0x1c8b9
callq 0x10b5e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x582a
leaq 0x5d44(%rip), %rdx      # 0x1bc80
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x60cb
leaq 0x108a0(%rip), %rdx     # 0x267f0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10ebd
leaq 0x120(%rip), %rsi       # 0x16081
movq %rbx, %rdi
callq 0x16043
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x576b
leaq 0x5242(%rip), %rsi      # 0x1b1bf
leaq 0x107ac(%rip), %rdx     # 0x26730
movq %rbx, %rdi
callq 0x10ebd
leaq 0x131(%rip), %rsi       # 0x160c4
movq %rbx, %rdi
callq 0x16043
movq 0x11036(%rip), %rax     # 0x26fd8
movq (%rax), %rsi
leaq 0x5271(%rip), %rcx      # 0x1b21d
movq %rbx, %rdi
movl $0x1, %edx
callq 0x160e8
movq 0x11010(%rip), %rax     # 0x26fd0
movq (%rax), %rsi
leaq 0x68db(%rip), %rcx      # 0x1c8a5
movq %rbx, %rdi
movl $0x2, %edx
callq 0x160e8
movq 0x1101a(%rip), %rax     # 0x26ff8
movq (%rax), %rsi
leaq 0x68c4(%rip), %rcx      # 0x1c8ac
movq %rbx, %rdi
xorl %edx, %edx
callq 0x160e8
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
leaq 0x68ad(%rip), %rdx      # 0x1c8b3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5eef
leaq 0x13c(%rip), %rsi       # 0x16156
movq %rbx, %rdi
callq 0x16043
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x628a
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_fclose
static int io_fclose (lua_State *L) {
  FILE **p = tofilep(L);
  int ok = (fclose(*p) == 0);
  *p = NULL;
  return pushresult(L, ok, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x682a(%rip), %rdx      # 0x1c8b9
movl $0x1, %esi
callq 0x10bcd
movq %rax, %r14
movq (%rax), %rdi
callq 0x4130
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq $0x0, (%r14)
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x163ff
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: createstdfile
static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {
  *newfile(L) = f;
  if (k > 0) {
    lua_pushvalue(L, -1);
    lua_rawseti(L, LUA_ENVIRONINDEX, k);
  }
  lua_pushvalue(L, -2);  /* copy environment */
  lua_setfenv(L, -2);  /* set it */
  lua_setfield(L, -3, fname);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0x16d4d
movq %r15, (%rax)
testl %ebp, %ebp
jle 0x16122
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x582a
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebp, %edx
callq 0x618f
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x582a
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x628a
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x60cb
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_pclose
static int io_pclose (lua_State *L) {
  FILE **p = tofilep(L);
  int ok = lua_pclose(L, *p);
  *p = NULL;
  return pushresult(L, ok, NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6758(%rip), %rdx      # 0x1c8b9
movl $0x1, %esi
callq 0x10bcd
movq $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0x163ff
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_close
static int io_close (lua_State *L) {
  if (lua_isnone(L, 1))
    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);
  tofile(L);  /* make sure argument is a file */
  return aux_close(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x584a
cmpl $-0x1, %eax
jne 0x161a4
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x2, %edx
callq 0x5f73
movq %rbx, %rdi
callq 0x1638b
movq %rbx, %rdi
popq %rbx
jmp 0x163ca