LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x577a
movq %rax, %r14
testq %rax, %rax
jne 0x1354b
leaq 0x7118(%rip), %rdx      # 0x1a658
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13692
movl %eax, %eax
leaq 0x130c1(%rip), %rcx     # 0x26620
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x5870
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13692
movl %eax, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x50e2
testl %eax, %eax
jne 0x135e8
leaq 0x708d(%rip), %rsi      # 0x1a66b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
cmpl $0x1, %r15d
jne 0x13651
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5153
movq %rbx, %rdi
movq %r14, %rsi
callq 0x519c
movq %r14, %rdi
movl %ebp, %esi
callq 0x7dcb
cmpl $0x1, %eax
ja 0x13672
movq %r14, %rdi
callq 0x51ef
movl %eax, %r15d
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x50e2
testl %eax, %eax
jne 0x13641
leaq 0x706c(%rip), %rsi      # 0x1a6a3
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x5153
jmp 0x13684
movl %r15d, %eax
leaq 0x12fc5(%rip), %rcx     # 0x26620
movq (%rcx,%rax,8), %rdx
leaq 0x7022(%rip), %rsi      # 0x1a688
movq %rbx, %rdi
xorl %eax, %eax
callq 0x58eb
jmp 0x13680
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5153
pushq $-0x1
popq %r15
movl %r15d, %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/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 0x136ca
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x6098
cmpl $0x1, %eax
je 0x136d0
testl %eax, %eax
jne 0x136cd
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x63ff
testl %eax, %eax
jle 0x136d9
pushq $0x2
jmp 0x136cf
xorl %eax, %eax
retq
pushq $0x3
popq %rax
addq $0x80, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x51ef
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal 0x1(,%rcx,2), %eax
jmp 0x136d0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: db_debug
static int db_debug (lua_State *L) {
  for (;;) {
    char buffer[250];
    fputs("lua_debug> ", stderr);
    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
        strcmp(buffer, "cont\n") == 0)
      return 0;
    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
        lua_pcall(L, 0, 0, 0)) {
      fputs(lua_tostring(L, -1), stderr);
      fputs("\n", stderr);
    }
    lua_settop(L, 0);  /* remove eventual returns */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movq 0x13864(%rip), %rbp     # 0x26ff8
leaq 0x6f85(%rip), %rdi      # 0x1a720
movq 0x13836(%rip), %r14     # 0x26fd8
movq %rsp, %r15
movq (%rbp), %rsi
movq %rdi, %r13
callq 0x41a0
movq %r14, %r12
movq (%r14), %rdx
movq %r15, %rdi
movl $0xfa, %esi
callq 0x4240
testq %rax, %rax
je 0x13854
movq %r15, %rdi
leaq 0x6f55(%rip), %rsi      # 0x1a72c
pushq $0x6
popq %rdx
callq 0x4370
testl %eax, %eax
je 0x13854
movq %r15, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
leaq 0x6f37(%rip), %rcx      # 0x1a732
callq 0x102b8
testl %eax, %eax
jne 0x13816
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5eec
testl %eax, %eax
je 0x1383f
movq %rbx, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x5665
movq (%rbp), %rsi
movq %rax, %rdi
callq 0x41a0
movq (%rbp), %rsi
leaq 0x67ce(%rip), %rdi      # 0x1a008
callq 0x41a0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x51fc
movq %r12, %r14
movq %r13, %rdi
jmp 0x137a5
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %rsi
callq 0x141d2
movq %rax, %r14
movq %rax, %rdi
callq 0x63f6
movl %eax, %ebp
movq %r14, %rdi
callq 0x63f1
testq %rax, %rax
sete %cl
leaq 0x94d(%rip), %rdx       # 0x14211
cmpq %rdx, %rax
sete %al
orb %cl, %al
jne 0x138e2
leaq 0x6e6e(%rip), %rsi      # 0x1a743
pushq $0xd
popq %rdx
movq %rbx, %rdi
callq 0x5819
jmp 0x1390f
movq %rbx, %rdi
callq 0x142a7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a4e
pushq $-0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5afe
movq %rbx, %rdi
movl %r15d, %esi
callq 0x523b
xorl %eax, %eax
testb $0x1, %bpl
je 0x1391f
movb $0x63, 0xf(%rsp)
pushq $0x1
popq %rax
testb $0x2, %bpl
je 0x1392e
movl %eax, %ecx
incl %eax
movb $0x72, 0xf(%rsp,%rcx)
testb $0x4, %bpl
je 0x1393d
movl %eax, %ecx
incl %eax
movb $0x6c, 0xf(%rsp,%rcx)
movl %eax, %eax
movb $0x0, 0xf(%rsp,%rax)
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x5870
movq %r14, %rdi
callq 0x63fb
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x57ff
pushq $0x3
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x141d2
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf8fe
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x63ff
testl %eax, %eax
je 0x13c7b
addl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf8fe
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x6457
testq %rax, %rax
je 0x13c8e
movq %rax, %r15
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5153
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5870
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x541c
pushq $0x2
jmp 0x13c98
leaq 0x6b5b(%rip), %rdx      # 0x1a7dd
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf3d4
jmp 0x13c99
movq %rbx, %rdi
callq 0x57d9
pushq $0x1
popq %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xf800
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5e3b
testl %eax, %eax
jne 0x13d2c
leaq 0x6838(%rip), %rsi      # 0x1a55a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
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/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 0x141d2
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x543c
testl %eax, %eax
jle 0x13e04
leal 0x2(%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf6c0
movq %rax, %r12
pushq $0x6
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf800
addl $0x3, %r15d
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0xf939
movq %rax, 0x8(%rsp)
pushq $0x63
popq %rsi
movq %r12, %rdi
callq 0x4160
xorl %r13d, %r13d
testq %rax, %rax
setne %r13b
pushq $0x72
popq %rsi
movq %r12, %rdi
callq 0x4160
movq %r14, %r15
leal 0x2(%r13), %r14d
testq %rax, %rax
cmovel %r13d, %r14d
pushq $0x6c
popq %rsi
movq %r12, %rdi
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 0x40f(%rip), %r13       # 0x14211
jmp 0x13e17
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x142a7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a4e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x5cda
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x63cc
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_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x543c
testl %eax, %eax
je 0x13f4f
cmpl $0x5, %eax
je 0x13f4f
leaq 0x664a(%rip), %rdx      # 0x1a58e
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5db1
movq %rbx, %rdi
movl %eax, %esi
callq 0x5a34
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/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 0x6642(%rip), %rsi      # 0x1a864
callq 0x5a4e
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5afe
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x5a4e
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5afe
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
cmpl $0x6, %eax
jne 0x14286
movslq (%r14), %rax
leaq 0x65ec(%rip), %rcx      # 0x1a850
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x5870
movslq 0x28(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
js 0x1428e
callq 0x57ff
jmp 0x14293
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x57d9
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5eb4
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x65b0(%rip), %rsi      # 0x1a864
callq 0x5a4e
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5afe
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
cmpl $0x5, %eax
jne 0x142dd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b5f
leaq 0x6566(%rip), %rsi      # 0x1a864
movq %rbx, %rdi
callq 0x5a4e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5cda
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rsi
callq 0xf8fe
movq %rax, %r15
pushq $0x1
popq %rbp
pushq $0x6
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0xf800
movq %r14, %rdi
movl %ebp, %esi
callq 0x5474
xorl %ebp, %ebp
testl %eax, %eax
jne 0x1442a
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %r15d, %edx
testl %ebx, %ebx
je 0x14406
callq 0x62b7
jmp 0x1440b
callq 0x6354
testq %rax, %rax
je 0x1442a
movq %r14, %rdi
movq %rax, %rsi
callq 0x5870
leal 0x1(%rbx), %ebp
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x5329
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6430(%rip), %rsi      # 0x1a879
callq 0xf6ed
pushq $-0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x541c
leaq 0x57fc(%rip), %rdx      # 0x19c60
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c7e
leaq 0x12378(%rip), %rdx     # 0x267f0
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfa2b
leaq 0x118(%rip), %rsi       # 0x145a1
movq %rbx, %rdi
callq 0x14567
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x5360
leaq 0x4d1a(%rip), %rsi      # 0x191bf
leaq 0x12284(%rip), %rdx     # 0x26730
movq %rbx, %rdi
callq 0xfa2b
leaq 0x124(%rip), %rsi       # 0x145df
movq %rbx, %rdi
callq 0x14567
movq 0x12b0e(%rip), %rax     # 0x26fd8
movq (%rax), %rsi
leaq 0x4d49(%rip), %rcx      # 0x1921d
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %edx
callq 0x145ff
movq 0x12ae6(%rip), %rax     # 0x26fd0
movq (%rax), %rsi
leaq 0x6371(%rip), %rcx      # 0x1a865
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x145ff
movq 0x12af2(%rip), %rax     # 0x26ff8
movq (%rax), %rsi
leaq 0x635c(%rip), %rcx      # 0x1a86c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x145ff
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
leaq 0x6348(%rip), %rdx      # 0x1a873
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5aa6
leaq 0x129(%rip), %rsi       # 0x14666
movq %rbx, %rdi
callq 0x14567
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5e3b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
movl %r15d, %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/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 0x62ca(%rip), %rdx      # 0x1a879
pushq $0x1
popq %rsi
callq 0xf754
movq %rax, %r14
movq (%rax), %rdi
callq 0x4130
xorl %esi, %esi
testl %eax, %eax
sete %sil
andq $0x0, (%r14)
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x148f4
// File: /workspace/github_c_makefile_star2_O2/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 0x151bf
movq %r15, (%rax)
testl %ebp, %ebp
jle 0x14637
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x541c
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebp, %edx
callq 0x5d42
pushq $-0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x541c
movq %r14, %rdi
movl %ebp, %esi
callq 0x5e3b
pushq $-0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5c7e
// File: /workspace/github_c_makefile_star2_O2/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 0x6208(%rip), %rdx      # 0x1a879
pushq $0x1
popq %rsi
callq 0xf754
andq $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0x148f4
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x543c
cmpl $-0x1, %eax
jne 0x146ab
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x5b2a
movq %rbx, %rdi
callq 0x14880
movq %rbx, %rdi
popq %rbx
jmp 0x148bd
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: f_seek
static int f_seek (lua_State *L) {
  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
  static const char *const modenames[] = {"set", "cur", "end", NULL};
  FILE *f = tofile(L);
  int op = luaL_checkoption(L, 2, "cur", modenames);
  long offset = luaL_optlong(L, 3, 0);
  op = fseek(f, offset, mode[op]);
  if (op)
    return pushresult(L, 0, NULL);  /* error */
  else {
    lua_pushinteger(L, ftell(f));
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x14880
movq %rax, %r14
leaq 0x61c9(%rip), %rdx      # 0x1a8fa
leaq 0x12158(%rip), %rcx     # 0x26890
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf5ea
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf939
movslq %ebp, %rcx
leaq 0x6224(%rip), %rdx      # 0x1a980
movl (%rdx,%rcx,4), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x43c0
testl %eax, %eax
je 0x1477e
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x148f4
movq %r14, %rdi
callq 0x42c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x57ff
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_gc
static int io_gc (lua_State *L) {
  FILE *f = *tofilep(L);
  /* ignore closed files */
  if (f != NULL)
    aux_close(L);
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6058(%rip), %rdx      # 0x1a879
pushq $0x1
popq %rsi
callq 0xf754
cmpq $0x0, (%rax)
je 0x14837
movq %rbx, %rdi
callq 0x148bd
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_tostring
static int io_tostring (lua_State *L) {
  FILE *f = *tofilep(L);
  if (f == NULL)
    lua_pushliteral(L, "file (closed)");
  else
    lua_pushfstring(L, "file (%p)", f);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6033(%rip), %rdx      # 0x1a879
pushq $0x1
popq %rsi
callq 0xf754
movq (%rax), %rdx
testq %rdx, %rdx
je 0x14869
leaq 0x60b7(%rip), %rsi      # 0x1a914
movq %rbx, %rdi
xorl %eax, %eax
callq 0x58eb
jmp 0x1487b
leaq 0x6096(%rip), %rsi      # 0x1a906
pushq $0xd
popq %rdx
movq %rbx, %rdi
callq 0x5819
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: tofile
static FILE *tofile (lua_State *L) {
  FILE **f = tofilep(L);
  if (*f == NULL)
    luaL_error(L, "attempt to use a closed file");
  return *f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5feb(%rip), %rdx      # 0x1a879
pushq $0x1
popq %rsi
callq 0xf754
movq %rax, %r14
movq (%rax), %rax
testq %rax, %rax
jne 0x148b5
leaq 0x5ff0(%rip), %rsi      # 0x1a898
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: pushresult
static int pushresult (lua_State *L, int i, const char *filename) {
  int en = errno;  /* calls to Lua API may change this value */
  if (i) {
    lua_pushboolean(L, 1);
    return 1;
  }
  else {
    lua_pushnil(L);
    if (filename)
      lua_pushfstring(L, "%s: %s", filename, strerror(en));
    else
      lua_pushfstring(L, "%s", strerror(en));
    lua_pushinteger(L, en);
    return 3;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4070
testl %ebp, %ebp
je 0x1491b
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5a34
jmp 0x1496e
movslq (%rax), %r14
movq %rbx, %rdi
callq 0x57d9
movl %r14d, %edi
callq 0x4500
testq %r15, %r15
je 0x1494c
leaq 0x5697(%rip), %rsi      # 0x19fd1
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x58eb
jmp 0x14960
leaq 0x67f1(%rip), %rsi      # 0x1b144
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x58eb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57ff
pushq $0x3
popq %rbp
movl %ebp, %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/liolib.c
// Function: io_readline
static int io_readline (lua_State *L) {
  FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
  int sucess;
  if (f == NULL)  /* file is already closed? */
    luaL_error(L, "file is already closed");
  sucess = read_line(L, f);
  if (ferror(f))
    return luaL_error(L, "%s", strerror(errno));
  if (sucess) return 1;
  else {  /* EOF */
    if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
      lua_settop(L, 0);
      lua_pushvalue(L, lua_upvalueindex(1));
      aux_close(L);  /* close it */
    }
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x5755
movq (%rax), %r14
testq %r14, %r14
jne 0x149d6
leaq 0x5ef1(%rip), %rsi      # 0x1a8bd
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14a55
movl %eax, %ebp
movq %r14, %rdi
callq 0x40c0
testl %eax, %eax
je 0x14a13
callq 0x4070
movl (%rax), %edi
callq 0x4500
leaq 0x6742(%rip), %rsi      # 0x1b144
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xf48b
testl %ebp, %ebp
je 0x14a1c
pushq $0x1
popq %rbp
jmp 0x14a4e
movq %rbx, %rdi
movl $0xffffd8ec, %esi       # imm = 0xFFFFD8EC
callq 0x5641
xorl %ebp, %ebp
testl %eax, %eax
je 0x14a4e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x51fc
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x541c
movq %rbx, %rdi
callq 0x148bd
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: read_line
static int read_line (lua_State *L, FILE *f) {
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  for (;;) {
    size_t l;
    char *p = luaL_prepbuffer(&b);
    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
      luaL_pushresult(&b);  /* close buffer */
      return (lua_objlen(L, -1) > 0);  /* check whether read something */
    }
    l = strlen(p);
    if (l == 0 || p[l-1] != '\n')
      luaL_addsize(&b, l);
    else {
      luaL_addsize(&b, l - 1);  /* do not include `eol' */
      luaL_pushresult(&b);  /* close buffer */
      return 1;  /* read at least an `eol' */
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rsi
callq 0xfd2b
movq %r15, %rdi
callq 0xfdd0
movq %rax, %r12
movq %rax, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdx
callq 0x4240
testq %rax, %rax
je 0x14aaf
movq %r12, %rdi
callq 0x4140
testq %rax, %rax
je 0x14aa9
cmpb $0xa, -0x1(%r12,%rax)
je 0x14acf
addq %rax, (%rsp)
jmp 0x14a74
movq %rsp, %rdi
callq 0xfdb2
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x56d3
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x14ae0
decq %rax
movq %rsp, %rdi
addq %rax, (%rdi)
callq 0xfdb2
pushq $0x1
popq %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: read_chars
static int read_chars (lua_State *L, FILE *f, size_t n) {
  size_t rlen;  /* how much to read */
  size_t nr;  /* number of chars actually read */
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
  do {
    char *p = luaL_prepbuffer(&b);
    if (rlen > n) rlen = n;  /* cannot read more than asked */
    nr = fread(p, sizeof(char), rlen, f);
    luaL_addsize(&b, nr);
    n -= nr;  /* still have to read `n' chars */
  } while (n > 0 && nr == rlen);  /* until end of count or eof */
  luaL_pushresult(&b);  /* close buffer */
  return (n == 0 || lua_objlen(L, -1) > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rsi
callq 0xfd2b
movl $0x2000, %r13d          # imm = 0x2000
pushq $0x1
popq %rbp
movq %r12, %rdi
callq 0xfdd0
cmpq %r14, %r13
cmovaeq %r14, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x40d0
addq %rax, (%rsp)
subq %rax, %r14
cmpq %r13, %rax
jne 0x14d2e
testq %r14, %r14
jne 0x14cfd
movq %rsp, %rdi
callq 0xfdb2
testq %r14, %r14
je 0x14d53
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x56d3
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x14d56
pushq $0x1
popq %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: g_write
static int g_write (lua_State *L, FILE *f, int arg) {
  int nargs = lua_gettop(L) - 1;
  int status = 1;
  for (; nargs--; arg++) {
    if (lua_type(L, arg) == LUA_TNUMBER) {
      /* optimization: could be done exactly as for strings */
      status = status &&
          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
    }
    else {
      size_t l;
      const char *s = luaL_checklstring(L, arg, &l);
      status = status && (fwrite(s, sizeof(char), l, f) == l);
    }
  }
  return pushresult(L, status, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x51ef
movl %eax, %r15d
decl %r15d
pushq $0x1
popq %r12
movq %rsp, %r13
subl $0x1, %r15d
jb 0x14e05
movq %rbx, %rdi
movl %ebp, %esi
callq 0x543c
cmpl $0x3, %eax
jne 0x14dcd
testl %r12d, %r12d
je 0x14dfe
movq %rbx, %rdi
movl %ebp, %esi
callq 0x55e3
movq %r14, %rdi
leaq 0x5085(%rip), %rsi      # 0x19e40
movb $0x1, %al
callq 0x42b0
xorl %r12d, %r12d
testl %eax, %eax
setg %r12b
jmp 0x14e01
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0xf6c0
testl %r12d, %r12d
je 0x14dfe
movq (%rsp), %rdx
movq %rax, %rdi
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x44d0
xorl %r12d, %r12d
cmpq (%rsp), %rax
sete %r12b
jmp 0x14e01
xorl %r12d, %r12d
incl %ebp
jmp 0x14d8d
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x148f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_lines
static int io_lines (lua_State *L) {
  if (lua_isnoneornil(L, 1)) {  /* no arguments? */
    /* will iterate over default input */
    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
    return f_lines(L);
  }
  else {
    const char *filename = luaL_checkstring(L, 1);
    FILE **pf = newfile(L);
    *pf = fopen(filename, "r");
    if (*pf == NULL)
      fileerror(L, 1, filename);
    aux_lines(L, lua_gettop(L), 1);
    return 1;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x543c
testl %eax, %eax
jle 0x14ec6
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf6c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x151bf
movq %rax, %r15
leaq 0x6020(%rip), %rsi      # 0x1aeb4
movq %r14, %rdi
callq 0x4420
movq %rax, (%r15)
testq %rax, %rax
jne 0x14eaf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x151ff
movq %rbx, %rdi
callq 0x51ef
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x1497b
jmp 0x14ede
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x5b2a
movq %rbx, %rdi
callq 0x146e0
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_open
static int io_open (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  FILE **pf = newfile(L);
  *pf = fopen(filename, mode);
  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0xf6c0
movq %rax, %r14
leaq 0x5fae(%rip), %rdx      # 0x1aeb4
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xf667
movq %rax, %r15
movq %rbx, %rdi
callq 0x151bf
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4420
movq %rax, (%r12)
testq %rax, %rax
je 0x14f44
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x148f4
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_popen
static int io_popen (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  FILE **pf = newfile(L);
  *pf = lua_popen(L, filename, mode);
  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0xf6c0
movq %rax, %r14
leaq 0x5f27(%rip), %rdx      # 0x1aeb4
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xf667
movq %rbx, %rdi
callq 0x151bf
movq %rax, %r15
leaq 0x59a2(%rip), %rsi      # 0x1a94e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
andq $0x0, (%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x148f4
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_type
static int io_type (lua_State *L) {
  void *ud;
  luaL_checkany(L, 1);
  ud = lua_touserdata(L, 1);
  lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
  if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
    lua_pushnil(L);  /* not a file */
  else if (*((FILE **)ud) == NULL)
    lua_pushliteral(L, "closed file");
  else
    lua_pushliteral(L, "file");
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xf84a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5755
movq %rax, %r14
leaq 0x582b(%rip), %rdx      # 0x1a879
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5aa6
testq %r14, %r14
je 0x15092
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5bb0
testl %eax, %eax
je 0x15092
pushq $-0x2
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x54f5
testl %eax, %eax
je 0x15092
cmpq $0x0, (%r14)
je 0x1509c
leaq 0x5822(%rip), %rsi      # 0x1a8b0
pushq $0x4
jmp 0x150a5
movq %rbx, %rdi
callq 0x57d9
jmp 0x150ae
leaq 0x5806(%rip), %rsi      # 0x1a8a9
pushq $0xb
popq %rdx
movq %rbx, %rdi
callq 0x5819
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: getiofile
static FILE *getiofile (lua_State *L, int findex) {
  FILE *f;
  lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
  f = *(FILE **)lua_touserdata(L, -1);
  if (f == NULL)
    luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
  return f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %r14d, %edx
callq 0x5b2a
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5755
movq (%rax), %r15
testq %r15, %r15
jne 0x1511e
decl %r14d
leaq 0x5892(%rip), %rax      # 0x1a998
movslq (%rax,%r14,4), %rdx
addq %rax, %rdx
leaq 0x581f(%rip), %rsi      # 0x1a933
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: g_iofile
static int g_iofile (lua_State *L, int f, const char *mode) {
  if (!lua_isnoneornil(L, 1)) {
    const char *filename = lua_tostring(L, 1);
    if (filename) {
      FILE **pf = newfile(L);
      *pf = fopen(filename, mode);
      if (*pf == NULL)
        fileerror(L, 1, filename);
    }
    else {
      tofile(L);  /* check that it's a valid file handle */
      lua_pushvalue(L, 1);
    }
    lua_rawseti(L, LUA_ENVIRONINDEX, f);
  }
  /* return current value */
  lua_rawgeti(L, LUA_ENVIRONINDEX, f);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x543c
testl %eax, %eax
jle 0x151a7
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5665
testq %rax, %rax
je 0x15185
movq %rax, %r12
movq %r14, %rdi
callq 0x151bf
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x4420
movq %rax, (%r13)
testq %rax, %rax
jne 0x15198
movq %r14, %rdi
movq %r12, %rsi
callq 0x151ff
jmp 0x15198
movq %r14, %rdi
callq 0x14880
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x541c
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebx, %edx
callq 0x5d42
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5b2a
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: newfile
static FILE **newfile (lua_State *L) {
  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
  *pf = NULL;  /* file handle is currently `closed' */
  luaL_getmetatable(L, LUA_FILEHANDLE);
  lua_setmetatable(L, -2);
  return pf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x624f
movq %rax, %r14
andq $0x0, (%rax)
leaq 0x569d(%rip), %rdx      # 0x1a879
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5aa6
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5db1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lmathlib.c
// Function: luaopen_math
LUALIB_API int luaopen_math (lua_State *L) {
  luaL_register(L, LUA_MATHLIBNAME, mathlib);
  lua_pushnumber(L, PI);
  lua_setfield(L, -2, "pi");
  lua_pushnumber(L, HUGE_VAL);
  lua_setfield(L, -2, "huge");
#if defined(LUA_COMPAT_MOD)
  lua_getfield(L, -1, "fmod");
  lua_setfield(L, -2, "mod");
#endif
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4db5(%rip), %rsi      # 0x1a012
leaq 0x1166c(%rip), %rdx     # 0x268d0
callq 0xfa2b
movsd 0x572f(%rip), %xmm0     # 0x1a9a0
movq %rbx, %rdi
callq 0x57ea
leaq 0x5750(%rip), %rdx      # 0x1a9d0
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c7e
movsd 0x5713(%rip), %xmm0     # 0x1a9a8
movq %rbx, %rdi
callq 0x57ea
leaq 0x572f(%rip), %rdx      # 0x1a9d3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c7e
leaq 0x5723(%rip), %rdx      # 0x1a9d8
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5aa6
leaq 0x49d7(%rip), %rdx      # 0x19c9e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c7e
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/lmathlib.c
// Function: math_frexp
static int math_frexp (lua_State *L) {
  int e;
  lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
  lua_pushinteger(L, e);
  return 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xf87d
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x4250
movq %rbx, %rdi
callq 0x57ea
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x57ff
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lmathlib.c
// Function: math_modf
static int math_modf (lua_State *L) {
  double ip;
  double fp = modf(luaL_checknumber(L, 1), &ip);
  lua_pushnumber(L, ip);
  lua_pushnumber(L, fp);
  return 2;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xf87d
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4180
movsd %xmm0, 0x8(%rsp)
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x57ea
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x57ea
pushq $0x2
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lmathlib.c
// Function: math_random
static int math_random (lua_State *L) {
  /* the `%' avoids the (rare) case of r==1, and is needed also because on
     some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
  lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
  switch (lua_gettop(L)) {  /* check number of arguments */
    case 0: {  /* no arguments */
      lua_pushnumber(L, r);  /* Number between 0 and 1 */
      break;
    }
    case 1: {  /* only upper limit */
      int u = luaL_checkint(L, 1);
      luaL_argcheck(L, 1<=u, 1, "interval is empty");
      lua_pushnumber(L, floor(r*u)+1);  /* int between 1 and `u' */
      break;
    }
    case 2: {  /* lower and upper limits */
      int l = luaL_checkint(L, 1);
      int u = luaL_checkint(L, 2);
      luaL_argcheck(L, l<=u, 2, "interval is empty");
      lua_pushnumber(L, floor(r*(u-l+1))+l);  /* int between `l' and `u' */
      break;
    }
    default: return luaL_error(L, "wrong number of arguments");
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x4550
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
divsd 0x529a(%rip), %xmm0     # 0x1a9b8
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x51ef
cmpl $0x2, %eax
je 0x1578f
cmpl $0x1, %eax
je 0x1574c
testl %eax, %eax
jne 0x157f7
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
jmp 0x157e5
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf8fe
movq %rax, %r14
testl %r14d, %r14d
jg 0x15771
leaq 0x52ec(%rip), %rdx      # 0x1aa52
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
cvtsi2sd %r14d, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x4470
addsd 0x410b(%rip), %xmm0     # 0x19898
jmp 0x157e2
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf8fe
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8fe
movq %rax, %r15
subl %r14d, %r15d
jge 0x157c2
leaq 0x529b(%rip), %rdx      # 0x1aa52
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
incl %r15d
cvtsi2sd %r15d, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x4470
cvtsi2sd %r14d, %xmm1
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57ea
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5266(%rip), %rsi      # 0x1aa64
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf48b
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/loslib.c
// Function: getfield
static int getfield (lua_State *L, const char *key, int d) {
  int res;
  lua_getfield(L, -1, key);
  if (lua_isnumber(L, -1))
    res = (int)lua_tointeger(L, -1);
  else {
    if (d < 0)
      return luaL_error(L, "field " LUA_QS " missing in date table", key);
    res = d;
  }
  lua_pop(L, 1);
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
pushq $-0x1
popq %rbp
movl %ebp, %esi
movq %r15, %rdx
callq 0x5aa6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5493
testl %eax, %eax
je 0x15f1b
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5612
movq %rax, %r14
jmp 0x15f20
testl %r14d, %r14d
js 0x15f39
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4bd3(%rip), %rsi      # 0x1ab13
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf48b
nop
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: foreach
static int foreach (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checktype(L, 2, LUA_TFUNCTION);
  lua_pushnil(L);  /* first key */
  while (lua_next(L, 1)) {
    lua_pushvalue(L, 2);  /* function */
    lua_pushvalue(L, -3);  /* key */
    lua_pushvalue(L, -3);  /* value */
    lua_call(L, 2, 1);
    if (!lua_isnil(L, -1))
      return 1;
    lua_pop(L, 2);  /* remove value and result */
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
pushq $0x5
popq %rdx
movl %ebx, %esi
callq 0xf800
pushq $0x2
popq %rbp
pushq $0x6
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0xf800
movq %r14, %rdi
callq 0x57d9
pushq $-0x3
popq %r15
pushq $-0x1
popq %r12
movq %r14, %rdi
movl %ebx, %esi
callq 0x6175
testl %eax, %eax
je 0x160d7
movq %r14, %rdi
movl %ebp, %esi
callq 0x541c
movq %r14, %rdi
movl %r15d, %esi
callq 0x541c
movq %r14, %rdi
movl %r15d, %esi
callq 0x541c
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x5eb4
movq %r14, %rdi
movl %r12d, %esi
callq 0x543c
testl %eax, %eax
jne 0x160d9
movq %r14, %rdi
movl %r15d, %esi
callq 0x51fc
jmp 0x16081
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: foreachi
static int foreachi (lua_State *L) {
  int i;
  int n = aux_getn(L, 1);
  luaL_checktype(L, 2, LUA_TFUNCTION);
  for (i=1; i <= n; i++) {
    lua_pushvalue(L, 2);  /* function */
    lua_pushinteger(L, i);  /* 1st argument */
    lua_rawgeti(L, 1, i);  /* 2nd argument */
    lua_call(L, 2, 1);
    if (!lua_isnil(L, -1))
      return 1;
    lua_pop(L, 1);  /* remove nil result */
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xf800
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56d3
movq %rax, %r14
pushq $0x2
popq %r15
pushq $0x6
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf800
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
negq %r14
pushq $0x1
popq %r13
pushq $-0x1
popq %r12
leaq (%r14,%r13), %rax
cmpq $0x1, %rax
je 0x1618b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x541c
movq %rbx, %rdi
movq %r13, %rsi
callq 0x57ff
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x5b2a
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x5eb4
movq %rbx, %rdi
movl %r12d, %esi
callq 0x543c
testl %eax, %eax
jne 0x1618f
movq %rbx, %rdi
pushq $-0x2
popq %rsi
callq 0x51fc
incq %r13
jmp 0x16132
xorl %eax, %eax
jmp 0x16191
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq