LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_setmetatable
static int luaB_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  if (luaL_getmetafield(L, 1, "__metatable"))
    luaL_error(L, "cannot change a protected metatable");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq 0x10(%rax), %rcx
cmpq 0x10(%rdi), %rcx
setae %dl
cmpq 0xe9464(%rip), %rcx     # 0x150fd0
sete %cl
orb %dl, %cl
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jne 0x67b7b
movl 0x18(%rax), %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
testl %ebp, %ebp
je 0x67b96
cmpl $0x5, %ebp
jne 0x67c01
leaq 0x86a01(%rip), %rdx     # 0xee59e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5b497
testl %eax, %eax
jne 0x67bf0
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
addq $0x20, %rax
cmpq %rax, %rcx
jae 0x67bd3
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x67bbf
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x86a82(%rip), %rsi     # 0xee679
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
leaq 0x86a5b(%rip), %rdx     # 0xee663
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_tonumber
static int luaB_tonumber (lua_State *L) {
  int base = luaL_optint(L, 2, 10);
  if (base == 10) {  /* standard conversion */
    luaL_checkany(L, 1);
    if (lua_isnumber(L, 1)) {
      lua_pushnumber(L, lua_tonumber(L, 1));
      return 1;
    }
  }
  else {
    const char *s1 = luaL_checkstring(L, 1);
    char *s2;
    unsigned long n;
    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
    n = strtoul(s1, &s2, base);
    if (s1 != s2) {  /* at least one valid digit? */
      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
      if (*s2 == '\0') {  /* no invalid trailing characters? */
        lua_pushnumber(L, (lua_Number)n);
        return 1;
      }
    }
  }
  lua_pushnil(L);  /* else not a number */
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %edx
movl $0x2, %esi
callq 0x5b45e
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0xa, %r14d
jne 0x67c70
callq 0x5b35e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57cb2
testl %eax, %eax
je 0x67cc6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57fbe
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0x67d04
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
leal -0x2(%r14), %eax
cmpl $0x23, %eax
jae 0x67d21
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0xb1c0
cmpq (%r12), %r15
je 0x67cc6
movq %rax, %r14
callq 0xb6e0
movq (%rax), %rcx
movq (%rsp), %rax
decq %rax
movzbl 0x1(%rax), %edx
incq %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x67cb0
movq %rax, (%rsp)
testb %dl, %dl
je 0x67cdb
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
jmp 0x67d10
movq %r14, %xmm0
punpckldq 0x79798(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x797a0(%rip), %xmm0    # 0xe1490
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq 0x10(%rbx), %rax
movsd %xmm1, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x86975(%rip), %rdx     # 0xee69d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_tostring
static int luaB_tostring (lua_State *L) {
  luaL_checkany(L, 1);
  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
    return 1;  /* use its value */
  switch (lua_type(L, 1)) {
    case LUA_TNUMBER:
      lua_pushstring(L, lua_tostring(L, 1));
      break;
    case LUA_TSTRING:
      lua_pushvalue(L, 1);
      break;
    case LUA_TBOOLEAN:
      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
      break;
    case LUA_TNIL:
      lua_pushliteral(L, "nil");
      break;
    default:
      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
      break;
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5b35e
leaq 0x86962(%rip), %rdx     # 0xee6af
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5b512
testl %eax, %eax
je 0x67d6b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
cmpq %rcx, %rax
leaq 0x85993(%rip), %rdx     # 0xed710
cmovaeq %rdx, %rax
cmpq %rdx, %rax
je 0x67d8b
movl 0x8(%rax), %edx
jmp 0x67d90
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x4, %edx
ja 0x67e1c
movl %edx, %edx
leaq 0x85816(%rip), %rsi     # 0xed5b8
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
leaq 0x865fa(%rip), %rsi     # 0xee3ac
movl $0x3, %edx
movq %rbx, %rdi
jmp 0x67e94
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x58042
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
jmp 0x67d5e
movl 0x8(%rax), %ecx
testl %ecx, %ecx
je 0x67e73
cmpl $0x1, %ecx
jne 0x67e7c
cmpl $0x0, (%rax)
leaq 0x8ce16(%rip), %rax     # 0xf4c0f
leaq 0xa3b72(%rip), %r14     # 0x10b972
cmoveq %rax, %r14
jmp 0x67e83
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
jmp 0x67d5e
cmpq 0xe91ad(%rip), %rax     # 0x150fd0
je 0x67e2a
movl 0x8(%rax), %eax
jmp 0x67e2f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x67e43
cltq
leaq 0xe6db3(%rip), %rcx     # 0x14ebf0
movq (%rcx,%rax,8), %r14
jmp 0x67e4a
leaq 0x7f806(%rip), %r14     # 0xe7650
movq %rbx, %rdi
movl $0x1, %esi
callq 0x582ec
leaq 0x8685c(%rip), %rsi     # 0xee6ba
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x58880
jmp 0x67d5e
leaq 0x8cd95(%rip), %r14     # 0xf4c0f
jmp 0x67e83
leaq 0xa3aef(%rip), %r14     # 0x10b972
movq %r14, %rdi
callq 0xb260
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x58391
jmp 0x67d5e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_unpack
static int luaB_unpack (lua_State *L) {
  int i, e, n;
  luaL_checktype(L, 1, LUA_TTABLE);
  i = luaL_optint(L, 2, 1);
  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
  if (i > e) return 0;  /* empty range */
  n = e - i + 1;  /* number of elements */
  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
    return luaL_error(L, "too many results to unpack");
  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
  while (i++ < e)  /* push arg[i + 1...e] */
    lua_rawgeti(L, 1, i);
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b45e
movq %rax, %r14
movq 0x18(%rbx), %rax
leaq 0x20(%rax), %rcx
cmpq 0x10(%rbx), %rcx
setae %dl
cmpq 0xe909b(%rip), %rcx     # 0x150fd0
sete %cl
orb %dl, %cl
jne 0x67f51
cmpl $0x0, 0x28(%rax)
jle 0x67f51
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
jmp 0x67f5e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58111
movq %rax, %r15
xorl %eax, %eax
movl %r15d, %ebp
subl %r14d, %ebp
jl 0x67fbd
js 0x67fc8
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5763c
testl %eax, %eax
je 0x67fc8
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x58cf6
cmpl %r14d, %r15d
jle 0x67fbb
negl %r15d
incl %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x58cf6
leal (%r15,%r14), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x67f98
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x866f2(%rip), %rsi     # 0xee6c1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_xpcall
static int luaB_xpcall (lua_State *L) {
  int status;
  luaL_checkany(L, 2);
  lua_settop(L, 2);
  lua_insert(L, 1);  /* put error function under function to be called */
  status = lua_pcall(L, 0, LUA_MULTRET, 1);
  lua_pushboolean(L, (status == 0));
  lua_replace(L, 1);
  return lua_gettop(L);  /* return status + all results */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
callq 0x5b35e
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
addq $0x20, %rax
cmpq %rax, %rcx
jae 0x6800c
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x67ff8
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57a06
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x59536
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq 0x10(%rbx), %rax
movl %ecx, (%rax)
movl $0x1, 0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
leaq 0x10(%rax), %rdx
movq %rdx, 0x10(%rbx)
cmpq %rdx, %rcx
jb 0x68061
leaq 0x856af(%rip), %rcx     # 0xed710
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rbx)
subq 0x18(%rbx), %rax
shrq $0x4, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rax, %rcx
setae %dl
cmpq 0xe8f2e(%rip), %rcx     # 0x150fd0
sete %dil
orb %dl, %dil
jne 0x680c4
cmpl $0x6, 0x8(%rcx)
jne 0x680c4
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
jmp 0x6812c
testl %esi, %esi
je 0x680dc
movl $0x1, %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5b45e
jmp 0x680e9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5b41f
movq %rax, %r14
testl %r14d, %r14d
js 0x68134
movq %rsp, %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5a0bf
testl %eax, %eax
je 0x6813d
leaq 0x79d3b(%rip), %rsi     # 0xe1e45
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5a270
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq 0xe8eac(%rip), %rcx     # 0x150fd0
je 0x6812c
cmpl $0x0, -0x8(%rax)
je 0x68151
addq $0x78, %rsp
popq %rbx
popq %r14
retq
leaq 0x86408(%rip), %rdx     # 0xee543
jmp 0x68144
leaq 0x8641a(%rip), %rdx     # 0xee55e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
leaq 0x86414(%rip), %rsi     # 0xee56c
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8643b(%rip), %rdx     # 0xee5b2
movl $0x2, %esi
callq 0x5b2dd
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpq %rax, %rcx
leaq 0x8557d(%rip), %r15     # 0xed710
cmovaeq %r15, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x594c2
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r15, %rcx
je 0x68229
cmpl $0x0, -0x8(%rax)
je 0x6821a
cmpq 0xe8dfa(%rip), %rcx     # 0x150fd0
je 0x68229
movl -0x8(%rax), %ecx
addl $-0x5, %ecx
cmpl $-0x2, %ecx
jb 0x68229
movq 0x18(%rbx), %rcx
addq $0x20, %rcx
cmpq %rax, %rcx
jb 0x681f3
movq %r15, %rcx
movq -0x10(%rax), %rdx
movq %rdx, (%rcx)
movl -0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $-0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x58042
movq $0x0, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8639c(%rip), %rsi     # 0xee5cc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 %rbx
movq %rdi, %rbx
callq 0x57725
movq 0x18(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
jae 0x682bf
cmpq 0xe8d7c(%rip), %rcx     # 0x150fd0
je 0x682bf
cmpl $0x6, 0x8(%rcx)
jne 0x682bf
cmpl $0x6, 0x8(%rcx)
jne 0x6826b
movq (%rcx), %rcx
cmpb $0x0, 0xa(%rcx)
jne 0x682bf
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
cmpq %rcx, %rdx
jb 0x6827f
leaq 0x85491(%rip), %rdx     # 0xed710
movq (%rdx), %rsi
movq %rsi, (%rcx)
movl 0x8(%rdx), %edx
movl %edx, 0x8(%rcx)
movq 0x10(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rbx)
cmpq %rbx, %rax
je 0x682b8
movq %rcx, 0x10(%rbx)
movq 0x10(%rax), %rdx
leaq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rax)
movq (%rcx), %rax
movq %rax, (%rdx)
movl 0x8(%rcx), %eax
movl %eax, 0x8(%rdx)
movl $0x1, %eax
popq %rbx
retq
leaq 0x86443(%rip), %rdx     # 0xee709
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lapi.c
// Function: luaB_corunning
LUA_API int lua_pushthread (lua_State *L) {
  lua_lock(L);
  setthvalue(L, L->top, L);
  api_incr_top(L);
  lua_unlock(L);
  return (G(L)->mainthread == L);
}

// Assembly:
movq 0x10(%rdi), %rax
movq %rdi, (%rax)
movl $0x8, 0x8(%rax)
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rcx
leaq 0x10(%rax), %rdx
movq %rdx, 0x10(%rdi)
cmpq %rdi, 0xb0(%rcx)
jne 0x683a9
movl $0x0, 0x18(%rax)
addq $0x20, %rax
movq %rax, 0x10(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_costatus
static int luaB_costatus (lua_State *L) {
  lua_State *co = lua_tothread(L, 1);
  luaL_argcheck(L, co, 1, "coroutine expected");
  lua_pushstring(L, statnames[costatus(L, co)]);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
jb 0x683c4
leaq 0x8534c(%rip), %rax     # 0xed710
cmpl $0x8, 0x8(%rax)
jne 0x683cf
movq (%rax), %rsi
jmp 0x683d1
xorl %esi, %esi
testq %rsi, %rsi
je 0x683fa
movq %rbx, %rdi
callq 0x6854e
movl %eax, %eax
leaq 0xe7239(%rip), %rcx     # 0x14f620
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x58568
movl $0x1, %eax
popq %rbx
retq
leaq 0x8631e(%rip), %rdx     # 0xee71f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 0x6854e
movl %eax, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x5763c
testl %eax, %eax
je 0x68534
cmpl $0x1, %r15d
jne 0x684cf
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x576c1
movzwl 0x60(%rbx), %eax
movw %ax, 0x60(%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x5a651
cmpl $0x1, %eax
ja 0x684f6
movq 0x10(%r14), %r15
subq 0x18(%r14), %r15
shrq $0x4, %r15
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x5763c
testl %eax, %eax
je 0x68545
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x576c1
jmp 0x68526
movl %r15d, %eax
leaq 0xe7147(%rip), %rcx     # 0x14f620
movq (%rcx,%rax,8), %rdx
leaq 0x8626b(%rip), %rsi     # 0xee74f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x58880
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x68526
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpq %rbx, %r14
je 0x68526
movq 0x10(%r14), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movq 0x10(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movq -0x10(%rax), %rdx
movq %rdx, (%rcx)
movl -0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x861f7(%rip), %rsi     # 0xee732
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
leaq 0x8621e(%rip), %rsi     # 0xee76a
jmp 0x6853b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 occurred */
      return CO_DEAD;
  }
}

// Assembly:
cmpq %rsi, %rdi
je 0x6858a
movzbl 0xa(%rsi), %eax
cmpl $0x1, %eax
je 0x68592
testl %eax, %eax
jne 0x6858d
movq 0x28(%rsi), %rcx
movl $0x2, %eax
cmpq 0x50(%rsi), %rcx
ja 0x68592
movq 0x10(%rsi), %rax
subq 0x18(%rsi), %rax
shrq $0x4, %rax
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal 0x1(,%rcx,2), %eax
retq
xorl %eax, %eax
retq
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq %rdi, %r15
cmpq 0xe896f(%rip), %rax     # 0x150fd0
je 0x68678
movq %rbx, %r15
cmpq 0x10(%rbx), %rax
jae 0x68678
cmpl $0x8, 0x8(%rax)
movq %rbx, %r15
jne 0x68678
movq (%rax), %r15
movzbl 0x64(%r15), %ebp
movq 0x70(%r15), %rax
testq %rax, %rax
sete %cl
leaq 0xc7e(%rip), %rdx       # 0x6930c
cmpq %rdx, %rax
sete %al
orb %cl, %al
jne 0x686ae
leaq 0x86175(%rip), %rsi     # 0xee814
movl $0xd, %edx
movq %rbx, %rdi
callq 0x58391
jmp 0x686f6
movq %rbx, %rdi
callq 0x69410
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movl $0x2, 0x8(%rax)
movq 0x10(%rbx), %r14
leaq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq -0x10(%r14), %rdi
movq %r14, %rsi
callq 0x58c18
movq (%rax), %rcx
movq %rcx, (%r14)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57916
xorl %eax, %eax
testb $0x1, %bpl
je 0x68708
movb $0x63, 0x3(%rsp)
movl $0x1, %eax
testb $0x2, %bpl
je 0x68717
movl %eax, %ecx
incl %eax
movb $0x72, 0x3(%rsp,%rcx)
testb $0x4, %bpl
je 0x68726
movl %eax, %ecx
incl %eax
movb $0x6c, 0x3(%rsp,%rcx)
movl %eax, %eax
movb $0x0, 0x3(%rsp,%rax)
leaq 0x3(%rsp), %r14
movq %r14, %rdi
callq 0xb260
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x58391
movq 0x10(%rbx), %rax
cvtsi2sdl 0x68(%r15), %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 $0x78, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
xorl %r15d, %r15d
cmpq 0xe84aa(%rip), %rax     # 0x150fd0
je 0x68b42
cmpq 0x10(%rbx), %rax
jae 0x68b42
cmpl $0x8, 0x8(%rax)
movq %rbx, %r14
jne 0x68b45
movq (%rax), %r14
movl $0x1, %r15d
jmp 0x68b45
movq %rbx, %r14
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5b41f
movq %rsp, %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x5a0bf
testl %eax, %eax
je 0x68c0b
orl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5b41f
movq %rsp, %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x5a111
testq %rax, %rax
je 0x68be8
movq %rax, %r15
cmpq %rbx, %r14
je 0x68bb6
movq 0x10(%r14), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movq 0x10(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movq -0x10(%rax), %rdx
movq %rdx, (%rcx)
movl -0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq %r15, %rdi
callq 0xb260
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x58391
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rcx
movq %rcx, (%rax)
movl -0x18(%rax), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rcx
movl $0x2, %eax
jmp 0x68bf8
movq 0x10(%rbx), %rcx
movl $0x0, 0x8(%rcx)
movl $0x1, %eax
addq $0x10, %rcx
movq %rcx, 0x10(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x85c90(%rip), %rdx     # 0xee8a2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lapi.c
// Function: db_getregistry
LUA_API void lua_pushvalue (lua_State *L, int idx) {
  lua_lock(L);
  setobj2s(L, L->top, index2adr(L, idx));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0xa0(%rcx), %rdx
movq %rdx, (%rax)
movl 0xa8(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldblib.c
// Function: db_setfenv
static int db_setfenv (lua_State *L) {
  luaL_checktype(L, 2, LUA_TTABLE);
  lua_settop(L, 2);
  if (lua_setfenv(L, 1) == 0)
    luaL_error(L, LUA_QL("setfenv")
                  " cannot change environment of given object");
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
movl $0x5, %edx
callq 0x5b30c
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
addq $0x20, %rax
cmpq %rax, %rcx
jae 0x68cbd
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x68ca9
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x593ec
testl %eax, %eax
je 0x68cd9
movl $0x1, %eax
popq %rbx
retq
leaq 0x8594f(%rip), %rsi     # 0xee62f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
movq 0x18(%rdi), %rax
xorl %r14d, %r14d
cmpq 0xe82c7(%rip), %rax     # 0x150fd0
je 0x68d25
cmpq 0x10(%rbx), %rax
jae 0x68d25
cmpl $0x8, 0x8(%rax)
movq %rbx, %r12
jne 0x68d28
movq (%rax), %r12
movl $0x1, %r14d
jmp 0x68d28
movq %rbx, %r12
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57945
cmpq 0xe8293(%rip), %rax     # 0x150fd0
je 0x68dec
cmpl $0x0, 0x8(%rax)
jle 0x68dec
leal 0x2(%r14), %esi
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x5b30c
addl $0x3, %r14d
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x5b45e
movq %rax, %r14
movq %r15, %rdi
movl $0x63, %esi
callq 0xb210
xorl %r13d, %r13d
testq %rax, %rax
setne %r13b
movq %r15, %rdi
movl $0x72, %esi
callq 0xb210
leal 0x2(%r13), %r15d
testq %rax, %rax
cmovel %r13d, %r15d
movq 0x10(%rsp), %rdi
movl $0x6c, %esi
callq 0xb210
leal 0x4(%r15), %ecx
testq %rax, %rax
cmovel %r15d, %ecx
leal 0x8(%rcx), %r15d
testl %r14d, %r14d
cmovlel %ecx, %r15d
leaq 0x522(%rip), %r13       # 0x6930c
jmp 0x68e26
movl %ebp, %eax
shll $0x4, %eax
addq 0x18(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
jae 0x68e12
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x68dfe
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
xorl %r13d, %r13d
movb $0x1, %al
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x69410
movq 0x10(%rbx), %rax
movq %r12, (%rax)
movl $0x2, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57945
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x59193
addq $-0x10, 0x10(%rbx)
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %ecx
cmovneq %r13, %rcx
movq %rcx, 0x70(%r12)
movl %r14d, 0x68(%r12)
movl %r14d, 0x6c(%r12)
cmpb $0x0, 0x8(%rsp)
cmovnel %eax, %r15d
movb %r15b, 0x64(%r12)
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_O1/genometools[P]genometools/src/external/lua-5.1.5/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
movq 0x18(%rdi), %rax
leaq 0x10(%rax), %rcx
cmpq 0x10(%rdi), %rcx
setae %dl
cmpq 0xe7ff1(%rip), %rcx     # 0x150fd0
sete %cl
orb %dl, %cl
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jne 0x68fee
movl 0x18(%rax), %ecx
testl %ecx, %ecx
je 0x68ff7
cmpl $0x5, %ecx
jne 0x6904c
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
addq $0x20, %rax
cmpq %rax, %rcx
jae 0x6901c
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x69008
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59337
movq 0x10(%rbx), %rax
movl %ebp, (%rax)
movl %ebp, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x85610(%rip), %rdx     # 0xee663
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
leaq 0x8459c(%rip), %rcx     # 0xed8c0
movq %rcx, (%rax)
movl $0x2, %ebp
movl %ebp, 0x8(%rax)
movq 0x10(%rdi), %r15
movq 0x20(%rdi), %rax
leaq 0x10(%r15), %rcx
movq %rcx, 0x10(%rdi)
movq 0xa0(%rax), %rdi
movq %r15, %rsi
callq 0x58c18
movq (%rax), %rcx
movq %rcx, (%r15)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r15)
movq 0x10(%rbx), %rax
movq %rbx, (%rax)
movl %ebp, 0x8(%rax)
movq 0x10(%rbx), %r15
leaq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movq -0x10(%r15), %rdi
movq %r15, %rsi
callq 0x58c18
movq (%rax), %rcx
movq %rcx, (%r15)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r15)
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq 0xe7c37(%rip), %rcx     # 0x150fd0
je 0x693de
cmpl $0x6, -0x8(%rax)
jne 0x693de
movslq (%r14), %rax
leaq 0x84501(%rip), %rcx     # 0xed8ac
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x58568
movl 0x28(%r14), %eax
movq 0x10(%rbx), %rsi
testl %eax, %eax
js 0x693e9
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsi)
movl $0x3, 0x8(%rsi)
movq 0x10(%rbx), %rsi
jmp 0x693f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x8(%rsi)
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x20, %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x594c2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
leaq 0x8449d(%rip), %r15     # 0xed8c0
movq %r15, (%rax)
movl $0x2, 0x8(%rax)
movq 0x10(%rdi), %r14
movq 0x20(%rdi), %rax
leaq 0x10(%r14), %rcx
movq %rcx, 0x10(%rdi)
movq 0xa0(%rax), %rdi
movq %r14, %rsi
callq 0x58c18
movq (%rax), %rcx
movq %rcx, (%r14)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r14)
movq 0x10(%rbx), %rcx
leaq -0x10(%rcx), %rax
cmpq 0xe7b68(%rip), %rax     # 0x150fd0
je 0x69476
cmpl $0x5, -0x8(%rcx)
jne 0x69476
popq %rbx
popq %r14
popq %r15
retq
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x58da0
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movl $0x2, 0x8(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x18(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
popq %rbx
popq %r14
popq %r15
jmp 0x59193
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldblib.c
// Function: auxupvalue
static int auxupvalue (lua_State *L, int get) {
  const char *name;
  int n = luaL_checkint(L, 2);
  luaL_checktype(L, 1, LUA_TFUNCTION);
  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
  if (name == NULL) return 0;
  lua_pushstring(L, name);
  lua_insert(L, -(get+1));
  return get + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x5b30c
movq 0x18(%r14), %rax
cmpq 0x10(%r14), %rax
jb 0x69574
leaq 0x8419c(%rip), %rax     # 0xed710
cmpl $0x6, 0x8(%rax)
jne 0x69583
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
jne 0x695cd
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
testl %ebx, %ebx
je 0x69599
callq 0x59f58
jmp 0x6959e
callq 0x59ff5
movq %rax, %r15
testq %rax, %rax
je 0x695cd
movq %r15, %rdi
callq 0xb260
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x58391
leal 0x1(%rbx), %ebp
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x57a06
jmp 0x695cf
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
movq 0x18(%rdi), %rax
cmpq 0xe79e5(%rip), %rax     # 0x150fd0
je 0x695f9
cmpq 0x10(%rbx), %rax
jae 0x695f9
cmpl $-0x1, 0x8(%rax)
jne 0x6960b
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x2, %edx
callq 0x58cf6
movq %rbx, %rdi
callq 0x69800
movq %rbx, %rdi
popq %rbx
jmp 0x69831
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 0x69800
movq %rax, %r14
leaq 0x852fc(%rip), %rdx     # 0xee98b
leaq 0xe604a(%rip), %rcx     # 0x14f6e0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b0d4
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5b45e
movslq %ebp, %rcx
leaq 0x84206(%rip), %rdx     # 0xed8c4
movl (%rdx,%rcx,4), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xb700
testl %eax, %eax
je 0x696e0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x69862
movq %r14, %rdi
callq 0xb030
movq 0x10(%rbx), %rcx
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rcx)
movl $0x3, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 0x8517b(%rip), %rdx     # 0xee914
movl $0x1, %esi
callq 0x5b252
cmpq $0x0, (%rax)
je 0x697b1
movq %rbx, %rdi
callq 0x69831
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 0x85154(%rip), %rdx     # 0xee914
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdx
testq %rdx, %rdx
je 0x697e5
leaq 0x851c9(%rip), %rsi     # 0xee9a2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x58880
jmp 0x697f9
leaq 0x851a8(%rip), %rsi     # 0xee994
movl $0xd, %edx
movq %rbx, %rdi
callq 0x58391
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 %rbx
movq %rdi, %rbx
leaq 0x85109(%rip), %rdx     # 0xee914
movl $0x1, %esi
callq 0x5b252
cmpq $0x0, (%rax)
je 0x69820
movq (%rax), %rax
popq %rbx
retq
leaq 0x85106(%rip), %rsi     # 0xee92d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0xb060
movq 0x10(%rbx), %rcx
testl %ebp, %ebp
je 0x69888
movl $0x1, (%rcx)
movl $0x1, %eax
jmp 0x698e3
movl (%rax), %ebp
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
movq %rcx, 0x10(%rbx)
movl %ebp, %edi
callq 0xb1d0
testq %r14, %r14
je 0x698be
leaq 0x9ee25(%rip), %rsi     # 0x1086d1
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x58880
jmp 0x698d2
leaq 0x85284(%rip), %rsi     # 0xeeb49
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x58880
movq 0x10(%rbx), %rcx
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rcx)
movl $0x3, %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0xb(%rax)
jne 0x6996c
leaq 0x83da6(%rip), %rax     # 0xed710
jmp 0x69970
addq $0x28, %rax
xorl %ecx, %ecx
cmpl $0x7, 0x8(%rax)
movq (%rax), %rax
movl $0x28, %edx
cmovneq %rcx, %rdx
movq (%rax,%rdx), %r14
testq %r14, %r14
je 0x69a43
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69a74
movl %eax, %ebp
movq %r14, %rdi
callq 0xbc30
testl %eax, %eax
jne 0x69a54
movl $0x1, %eax
testl %ebp, %ebp
jne 0x69a3e
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rdx
cmpb $0x2, 0xb(%rdx)
jae 0x699d3
leaq 0x83d3f(%rip), %rdx     # 0xed710
jmp 0x699d7
addq $0x38, %rdx
movl 0x8(%rdx), %eax
testl %eax, %eax
je 0x69a3e
cmpl $0x1, %eax
jne 0x699e8
cmpl $0x0, (%rdx)
je 0x69a3c
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
cmpq %rax, %rdx
jae 0x69a09
movl $0x0, 0x8(%rdx)
addq $0x10, %rdx
cmpq %rax, %rdx
jb 0x699f5
movq %rdx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
movq (%rcx), %rcx
cmpb $0x0, 0xb(%rcx)
jne 0x69a1f
leaq 0x83cf3(%rip), %rcx     # 0xed710
jmp 0x69a23
addq $0x28, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
callq 0x69831
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x84f08(%rip), %rsi     # 0xee952
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x850e2(%rip), %rsi     # 0xeeb49
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %rdi, -0x8(%r15)
movq %r15, -0x18(%r15)
movl $0x0, -0x10(%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5ba5e
testl %eax, %eax
je 0x69ab7
movq %r12, %rdi
callq 0x5ba94
movq %r15, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %rbx, %rdx
callq 0xb9f0
testq %rax, %rax
je 0x69b16
movq %r15, %rdi
callq 0xb260
testq %rax, %rax
je 0x69b0d
cmpb $0xa, 0x1f(%rsp,%rax)
jne 0x69b0d
decq %rax
addq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x5ba5e
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x59be2
movl $0x1, 0x10(%rsp)
movl $0x1, %ebp
jmp 0x69b4a
addq %rax, 0x8(%rsp)
movb $0x1, %al
jmp 0x69b4c
movq %r12, %rdi
callq 0x5ba5e
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x59be2
movl $0x1, 0x10(%rsp)
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58111
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
xorl %eax, %eax
testb %al, %al
jne 0x69aa3
movl %ebp, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
leaq 0x18(%rsp), %r12
movq %rdi, -0x8(%r12)
movq %r12, -0x18(%r12)
movl $0x0, -0x10(%r12)
movl $0x2000, %r13d          # imm = 0x2000
movq %rsp, %rbp
movq %rbp, %rdi
callq 0x5ba5e
testl %eax, %eax
je 0x69dc4
movq %rbp, %rdi
callq 0x5ba94
cmpq %r14, %r13
cmovaeq %r14, %r13
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0xb940
addq %rax, (%rsp)
subq %rax, %r14
cmpq %r13, %rax
jne 0x69def
testq %r14, %r14
jne 0x69db0
movq %rsp, %r15
movq %r15, %rdi
callq 0x5ba5e
movq 0x10(%r15), %rdi
movl 0x8(%r15), %esi
callq 0x59be2
movl $0x1, 0x8(%r15)
testq %r14, %r14
je 0x69e2e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58111
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x69e33
movl $0x1, %eax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
movq %rdi, %rbx
movq 0x10(%rdi), %r12
subq 0x18(%rdi), %r12
shrq $0x4, %r12
decl %r12d
je 0x69ef9
movl %edx, %ebp
movq %rsi, %r14
movl $0x1, %r13d
leaq 0x83896(%rip), %r15     # 0xed710
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57945
cmpq %r15, %rax
je 0x69eba
cmpl $0x3, 0x8(%rax)
jne 0x69eba
testl %r13d, %r13d
je 0x69eed
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57fbe
movq %r14, %rdi
leaq 0x8451b(%rip), %rsi     # 0xee3c3
movb $0x1, %al
callq 0xb8d0
xorl %r13d, %r13d
testl %eax, %eax
setg %r13b
jmp 0x69ef0
movq %rbx, %rdi
movl %ebp, %esi
movq %rsp, %rdx
callq 0x5b1b3
testl %r13d, %r13d
je 0x69eed
movq (%rsp), %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rcx
callq 0xbcb0
xorl %r13d, %r13d
cmpq (%rsp), %rax
sete %r13b
jmp 0x69ef0
xorl %r13d, %r13d
incl %ebp
decl %r12d
jne 0x69e7a
jmp 0x69eff
movl $0x1, %r13d
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x69862
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
movq 0x18(%rdi), %rax
cmpq 0xe7060(%rip), %rax     # 0x150fd0
je 0x69fc8
cmpq 0x10(%rbx), %rax
jae 0x69fc8
cmpl $0x0, 0x8(%rax)
jle 0x69fc8
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a34a
movq %rax, %r15
leaq 0x84f06(%rip), %rsi     # 0xeeea8
movq %r14, %rdi
callq 0xb720
movq %rax, (%r15)
testq %rax, %rax
je 0x69ffc
movq 0x10(%rbx), %rsi
subq 0x18(%rbx), %rsi
shrq $0x4, %rsi
movq %rbx, %rdi
movl $0x1, %edx
jmp 0x69fec
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x1, %edx
callq 0x58cf6
movq %rbx, %rdi
callq 0x69800
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x698f0
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6a391
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
leaq 0x84e80(%rip), %rdx     # 0xeeea8
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x5b14f
movq %rax, %r15
movq %rbx, %rdi
callq 0x6a34a
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0xb720
movq %rax, (%r12)
testq %rax, %rax
je 0x6a06a
movl $0x1, %eax
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 0x69862
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
leaq 0x84df6(%rip), %rdx     # 0xeeea8
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x5b14f
movq %rbx, %rdi
callq 0x6a34a
leaq 0x848ff(%rip), %rsi     # 0xee9cf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61