LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0xa, %edx
callq 0x1af90
movl %eax, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jne 0x21049
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1ae40
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x70c0
cmpl $0x0, %eax
je 0x21044
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7350
movq -0x38(%rbp), %rdi
callq 0x7830
movl $0x1, -0x4(%rbp)
jmp 0x2113c
jmp 0x2112c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x20(%rbp)
movl $0x2, %eax
cmpl -0x14(%rbp), %eax
jg 0x21074
movb $0x1, %al
cmpl $0x24, -0x14(%rbp)
movb %al, -0x39(%rbp)
jle 0x21092
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0xb564(%rip), %rdx      # 0x2c5e8
callq 0x1a7b0
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0x5470
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x2112a
jmp 0x210b5
callq 0x5570
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x210e3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x210b5
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x21128
movq -0x10(%rbp), %rdi
movaps 0xa716(%rip), %xmm1     # 0x2b810
movq -0x30(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xa715(%rip), %xmm1     # 0x2b820
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x7830
movl $0x1, -0x4(%rbp)
jmp 0x2113c
jmp 0x2112a
jmp 0x2112c
movq -0x10(%rbp), %rdi
callq 0x7800
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1ae40
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0xb480(%rip), %rdx      # 0x2c5fa
callq 0x1b070
cmpl $0x0, %eax
je 0x21190
movl $0x1, -0x4(%rbp)
jmp 0x212a9
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6fe0
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x2124e
movq -0x18(%rbp), %rax
leaq 0xb198(%rip), %rcx      # 0x2c350
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x7950
jmp 0x212a2
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6f80
jmp 0x212a2
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7440
movq -0x28(%rbp), %rdi
movl %eax, %ecx
leaq 0xafc6(%rip), %rsi      # 0x2c1e8
leaq 0xafd9(%rip), %rax      # 0x2c202
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x7950
jmp 0x212a2
movq -0x10(%rbp), %rdi
leaq 0xaa15(%rip), %rsi      # 0x2bc57
movl $0x3, %edx
callq 0x78d0
jmp 0x212a2
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6fe0
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x7030
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7760
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0xb36a(%rip), %rsi      # 0x2c605
movb $0x0, %al
callq 0x7a10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x1af90
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x6fe0
cmpl $0x0, %eax
jg 0x2137b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7560
movl %eax, -0x20(%rbp)
jmp 0x2138c
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x1af30
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x213a3
movl $0x0, -0x4(%rbp)
jmp 0x21417
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x213c6
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6810
cmpl $0x0, %eax
jne 0x213dd
movq -0x10(%rbp), %rdi
leaq 0xb23b(%rip), %rsi      # 0x2c60c
movb $0x0, %al
callq 0x1a8b0
movl %eax, -0x4(%rbp)
jmp 0x21417
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0x1, %esi
callq 0x7ea0
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl -0x18(%rbp), %eax
jge 0x21411
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0x1, %esi
callq 0x7ea0
jmp 0x213ee
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1ae40
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6ab0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6d40
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x8700
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
cmpl $0x0, -0xc(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x7c50
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6df0
movq -0x8(%rbp), %rdi
callq 0x6a80
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6fe0
cmpl $0x6, %eax
jne 0x214d8
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6f80
jmp 0x215c5
cmpl $0x0, -0xc(%rbp)
je 0x214f9
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x1af90
movl %eax, -0x90(%rbp)
jmp 0x2150d
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1af30
movl %eax, -0x90(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0x8c(%rbp)
movb $0x1, %al
cmpl $0x0, -0x8c(%rbp)
movb %al, -0x91(%rbp)
jge 0x2154b
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xaf54(%rip), %rdx      # 0x2c48e
callq 0x1a7b0
cmpl $0x0, %eax
setne %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
movq -0x8(%rbp), %rdi
movl -0x8c(%rbp), %esi
leaq -0x88(%rbp), %rdx
callq 0x9180
cmpl $0x0, %eax
jne 0x21581
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xaf2d(%rip), %rdx      # 0x2c4a9
callq 0x1a7b0
movq -0x8(%rbp), %rdi
leaq 0xb4af(%rip), %rsi      # 0x2ca3b
leaq -0x88(%rbp), %rdx
callq 0x9480
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x0, %eax
jne 0x215c3
movq -0x8(%rbp), %rdi
movl -0x8c(%rbp), %edx
leaq 0xaefb(%rip), %rsi      # 0x2c4b7
movb $0x0, %al
callq 0x1a8b0
jmp 0x215c5
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: load_aux
static int load_aux (lua_State *L, int status) {
  if (status == 0)  /* OK? */
    return 1;
  else {
    lua_pushnil(L);
    lua_insert(L, -2);  /* put before error message */
    return 2;  /* return nil plus error message */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x215ee
movl $0x1, -0x4(%rbp)
jmp 0x2160c
movq -0x10(%rbp), %rdi
callq 0x7800
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d40
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0xaeb9(%rip), %rdx      # 0x2c4fd
callq 0x1ad70
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6f80
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x8680
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x0, %eax
jne 0x2168f
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x216e4
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7120
cmpl $0x0, %eax
je 0x216c8
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x6df0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x3, %esi
callq 0x74a0
movq %rax, -0x8(%rbp)
jmp 0x216e4
movq -0x10(%rbp), %rdi
leaq 0xae44(%rip), %rsi      # 0x2c517
movb $0x0, %al
callq 0x1a8b0
jmp 0x216dc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6fe0
cmpl $0x6, %eax
jne 0x21736
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7070
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x21754
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xaf1c(%rip), %rdx      # 0x2c662
callq 0x1a7b0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6f80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x68f0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7710
movq %rax, -0x10(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jne 0x218e8
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xad9e(%rip), %rdx      # 0x2c678
callq 0x1a7b0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21ac0
movq -0x20(%rbp), %rdi
movslq %eax, %rcx
leaq 0x14cd2(%rip), %rax     # 0x365e0
movq (%rax,%rcx,8), %rsi
callq 0x7950
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21ac0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6810
cmpl $0x0, %eax
jne 0x219e6
movq -0x10(%rbp), %rdi
leaq 0xacac(%rip), %rsi      # 0x2c68b
movb $0x0, %al
callq 0x1a8b0
cmpl $0x1, -0x20(%rbp)
je 0x21a19
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rcx
leaq 0x14be5(%rip), %rax     # 0x365e0
movq (%rax,%rcx,8), %rdx
leaq 0xaca2(%rip), %rsi      # 0x2c6a8
movb $0x0, %al
callq 0x7a10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21ab4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x68f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x69a0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xbff0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x21a51
cmpl $0x1, -0x20(%rbp)
jne 0x21a9b
movq -0x18(%rbp), %rdi
callq 0x6a80
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
callq 0x6810
cmpl $0x0, %eax
jne 0x21a83
movq -0x10(%rbp), %rdi
leaq 0xac47(%rip), %rsi      # 0x2c6c3
movb $0x0, %al
callq 0x1a8b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x68f0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21ab4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x68f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x21ae6
movl $0x0, -0x4(%rbp)
jmp 0x21b5a
movq -0x18(%rbp), %rdi
callq 0x8a20
movl %eax, %ecx
movl %ecx, -0x94(%rbp)
testl %eax, %eax
je 0x21b13
jmp 0x21afd
movl -0x94(%rbp), %eax
subl $0x1, %eax
jne 0x21b53
jmp 0x21b0a
movl $0x1, -0x4(%rbp)
jmp 0x21b5a
movq -0x18(%rbp), %rdi
xorl %esi, %esi
leaq -0x90(%rbp), %rdx
callq 0x9180
cmpl $0x0, %eax
jle 0x21b33
movl $0x2, -0x4(%rbp)
jmp 0x21b5a
movq -0x18(%rbp), %rdi
callq 0x6a80
cmpl $0x0, %eax
jne 0x21b4a
movl $0x3, -0x4(%rbp)
jmp 0x21b5a
movl $0x1, -0x4(%rbp)
jmp 0x21b5a
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq 0x153a2(%rip), %rax     # 0x36ff8
movq (%rax), %rsi
leaq 0xaae0(%rip), %rdi      # 0x2c740
callq 0x51b0
leaq -0x110(%rbp), %rdi
movq 0x15365(%rip), %rax     # 0x36fd8
movq (%rax), %rdx
movl $0xfa, %esi
callq 0x5260
cmpq $0x0, %rax
je 0x21c9e
leaq -0x110(%rbp), %rdi
leaq 0xaab8(%rip), %rsi      # 0x2c74c
callq 0x52a0
cmpl $0x0, %eax
jne 0x21ca9
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x5150
movq -0x120(%rbp), %rdi
movq -0x118(%rbp), %rsi
movq %rax, %rdx
leaq 0xaa6c(%rip), %rcx      # 0x2c752
callq 0x1be30
cmpl $0x0, %eax
jne 0x21d04
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x8700
cmpl $0x0, %eax
je 0x21d3e
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq %rax, %rdi
movq 0x152d8(%rip), %rax     # 0x36ff8
movq (%rax), %rsi
callq 0x51b0
movq 0x152c9(%rip), %rax     # 0x36ff8
movq (%rax), %rsi
leaq 0xa30b(%rip), %rdi      # 0x2c044
callq 0x51b0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x6ab0
jmp 0x21c4f
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x22960
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9140
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9120
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x21df1
leaq 0xbec(%rip), %rax       # 0x229c0
cmpq %rax, -0x30(%rbp)
je 0x21df1
movq -0x8(%rbp), %rdi
leaq 0xa97e(%rip), %rsi      # 0x2c763
movl $0xd, %edx
callq 0x78d0
jmp 0x21e23
movq -0x8(%rbp), %rdi
callq 0x22a80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7ca0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7e30
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b40
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %edi
leaq -0x1d(%rbp), %rsi
callq 0x22b10
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x7950
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9160
movq -0x38(%rbp), %rdi
movslq %eax, %rsi
callq 0x7880
movl $0x3, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x22960
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x1af30
movq -0xa8(%rbp), %rdi
movl %eax, %esi
leaq -0x98(%rbp), %rdx
callq 0x9180
cmpl $0x0, %eax
jne 0x22202
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
leaq 0xa608(%rip), %rdx      # 0x2c7fd
callq 0x1a7b0
movl %eax, -0x4(%rbp)
jmp 0x2228b
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x2, %esi
callq 0x1af30
movq -0xb0(%rbp), %rdi
movl %eax, %edx
leaq -0x98(%rbp), %rsi
callq 0x9270
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
je 0x2227b
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x68f0
movq -0x10(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x7950
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6f80
movl $0x2, -0x4(%rbp)
jmp 0x2228b
movq -0x10(%rbp), %rdi
callq 0x7800
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6ab0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8560
cmpl $0x0, %eax
jne 0x22392
movq -0x8(%rbp), %rdi
leaq 0xa1ef(%rip), %rsi      # 0x2c57a
movb $0x0, %al
callq 0x1a8b0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x22960
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x6fe0
cmpl $0x0, %eax
jg 0x223f8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x6ab0
movq $0x0, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
jmp 0x22453
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl $0x6, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1af90
movl %eax, -0x14(%rbp)
leaq 0x580(%rip), %rax       # 0x229c0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x22d60
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22a80
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7ca0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x8280
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x90b0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6fe0
movl %eax, -0xc(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x22601
movb $0x1, %al
cmpl $0x5, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x22601
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x9fbb(%rip), %rdx      # 0x2c5ae
callq 0x1a7b0
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6ab0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8420
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x7c50
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9e94(%rip), %rsi      # 0x2c86f
callq 0x7ca0
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x7e30
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x7ca0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7e30
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x6, %eax
jne 0x22a6d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x13cc2(%rip), %rax     # 0x366f0
movq (%rax,%rcx,8), %rsi
callq 0x7950
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jl 0x22a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x7880
jmp 0x22a5d
movq -0x8(%rbp), %rdi
callq 0x7800
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8680
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9dd8(%rip), %rsi      # 0x2c86f
callq 0x7ca0
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x7e30
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x5, %eax
je 0x22b07
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x7f20
movq -0x8(%rbp), %rdi
leaq 0x9d89(%rip), %rsi      # 0x2c86f
callq 0x7ca0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x8280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x1af30
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1adb0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7070
cmpl $0x0, %eax
je 0x22cdf
movl $0x0, -0x4(%rbp)
jmp 0x22d52
cmpl $0x0, -0x14(%rbp)
je 0x22cfc
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
movl $0x1, %esi
callq 0x8e40
movq %rax, -0x30(%rbp)
jmp 0x22d11
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
movl $0x1, %esi
callq 0x8fd0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x22d29
movl $0x0, -0x4(%rbp)
jmp 0x22d52
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7950
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
callq 0x6d40
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22f00
movq -0x8(%rbp), %rdi
leaq 0x1a0(%rip), %rsi       # 0x22fb0
callq 0x22f60
movq -0x8(%rbp), %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x6df0
movq -0x8(%rbp), %rdi
leaq 0x8391(%rip), %rsi      # 0x2b1bf
leaq 0x138eb(%rip), %rdx     # 0x36720
callq 0x1b100
movq -0x8(%rbp), %rdi
leaq 0x1cb(%rip), %rsi       # 0x23010
callq 0x22f60
movq -0x8(%rbp), %rdi
movq 0x14183(%rip), %rax     # 0x36fd8
movq (%rax), %rsi
movl $0x1, %edx
leaq 0x83bc(%rip), %rcx      # 0x2b220
callq 0x23050
movq -0x8(%rbp), %rdi
movq 0x1415c(%rip), %rax     # 0x36fd0
movq (%rax), %rsi
movl $0x2, %edx
leaq 0x99ed(%rip), %rcx      # 0x2c870
callq 0x23050
movq -0x8(%rbp), %rdi
movq 0x14165(%rip), %rax     # 0x36ff8
movq (%rax), %rsi
xorl %edx, %edx
leaq 0x99d8(%rip), %rcx      # 0x2c877
callq 0x23050
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x99bc(%rip), %rdx      # 0x2c87e
callq 0x7d90
movq -0x8(%rbp), %rdi
leaq 0x20e(%rip), %rsi       # 0x230e0
callq 0x22f60
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8560
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: createmeta
static void createmeta (lua_State *L) {
  luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
  lua_pushvalue(L, -1);  /* push metatable */
  lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
  luaL_register(L, NULL, flib);  /* file methods */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x996d(%rip), %rsi      # 0x2c884
callq 0x1ac30
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x8d6e(%rip), %rdx      # 0x2bca8
callq 0x81e0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x13892(%rip), %rdx     # 0x367e0
callq 0x1b100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x98b8(%rip), %rdx      # 0x2c884
callq 0x1acc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5140
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x23520
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x242d0
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x14(%rbp)
jle 0x230a4
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x8350
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8560
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x81e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x9788(%rip), %rdx      # 0x2c884
callq 0x1acc0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x23520
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6fe0
cmpl $-0x1, %eax
jne 0x23162
movq -0x8(%rbp), %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x2, %edx
callq 0x7ea0
movq -0x8(%rbp), %rdi
callq 0x23480
movq -0x8(%rbp), %rdi
callq 0x234d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23480
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x969c(%rip), %rdx      # 0x2c905
leaq 0x13610(%rip), %rcx     # 0x36880
callq 0x1aa80
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1af90
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x1c(%rbp), %rcx
leaq 0x96eb(%rip), %rax      # 0x2c98c
movl (%rax,%rcx,4), %edx
callq 0x53d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x232c6
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x23520
movl %eax, -0x4(%rbp)
jmp 0x232ea
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x52e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x7880
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x9498(%rip), %rdx      # 0x2c884
callq 0x1acc0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x23408
movq -0x8(%rbp), %rdi
callq 0x234d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x9458(%rip), %rdx      # 0x2c884
callq 0x1acc0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x23456
movq -0x8(%rbp), %rdi
leaq 0x94c7(%rip), %rsi      # 0x2c911
movl $0xd, %edx
callq 0x78d0
jmp 0x2346c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x94ba(%rip), %rsi      # 0x2c91f
movb $0x0, %al
callq 0x7a10
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x93e8(%rip), %rdx      # 0x2c884
callq 0x1acc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x234c1
movq -0x8(%rbp), %rdi
leaq 0x93e9(%rip), %rsi      # 0x2c8a3
movb $0x0, %al
callq 0x1a8b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x5060
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2355a
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7c50
movl $0x1, -0x4(%rbp)
jmp 0x235d6
movq -0x10(%rbp), %rdi
callq 0x7800
cmpq $0x0, -0x20(%rbp)
je 0x2359d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x5510
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x8a79(%rip), %rsi      # 0x2c00d
movb $0x0, %al
callq 0x7a10
jmp 0x235c2
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %edi
callq 0x5510
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x9d25(%rip), %rsi      # 0x2d2e0
movb $0x0, %al
callq 0x7a10
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x7880
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x76a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2366a
movq -0x10(%rbp), %rdi
leaq 0x9265(%rip), %rsi      # 0x2c8c8
movb $0x0, %al
callq 0x1a8b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23710
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x50d0
cmpl $0x0, %eax
je 0x236b6
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x5060
movl (%rax), %edi
callq 0x5510
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x9c36(%rip), %rsi      # 0x2d2e0
movb $0x0, %al
callq 0x1a8b0
movl %eax, -0x4(%rbp)
jmp 0x23701
cmpl $0x0, -0x1c(%rbp)
je 0x236c5
movl $0x1, -0x4(%rbp)
jmp 0x23701
movq -0x10(%rbp), %rdi
movl $0xffffd8ec, %esi       # imm = 0xFFFFD8EC
callq 0x7440
cmpl $0x0, %eax
je 0x236fa
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6ab0
movq -0x10(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x6f80
movq -0x10(%rbp), %rdi
callq 0x234d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2030(%rbp), %rsi
callq 0x1b530
leaq -0x2030(%rbp), %rdi
callq 0x1b680
movq %rax, -0x2040(%rbp)
movq -0x2040(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x2000, %esi           # imm = 0x2000
callq 0x5260
cmpq $0x0, %rax
jne 0x2378f
leaq -0x2030(%rbp), %rdi
callq 0x1b640
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7560
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x23811
movq -0x2040(%rbp), %rdi
callq 0x5150
movq %rax, -0x2038(%rbp)
cmpq $0x0, -0x2038(%rbp)
je 0x237c7
movq -0x2040(%rbp), %rax
movq -0x2038(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x237de
movq -0x2038(%rbp), %rax
addq -0x2030(%rbp), %rax
movq %rax, -0x2030(%rbp)
jmp 0x2380c
movq -0x2038(%rbp), %rax
subq $0x1, %rax
addq -0x2030(%rbp), %rax
movq %rax, -0x2030(%rbp)
leaq -0x2030(%rbp), %rdi
callq 0x1b640
movl $0x1, -0x4(%rbp)
jmp 0x23811
jmp 0x23733
movl -0x4(%rbp), %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopl (%rax)