LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/liolib.c
// Function: io_type
static int io_type (lua_State *L) {
  void *ud;
  luaL_checkany(L, 1);
  ud = lua_touserdata(L, 1);
  lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
  if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
    lua_pushnil(L);  /* not a file */
  else if (*((FILE **)ud) == NULL)
    lua_pushliteral(L, "closed file");
  else
    lua_pushliteral(L, "file");
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5b35e
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jb 0x6a157
leaq 0x835b9(%rip), %rax     # 0xed710
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x6a16d
cmpl $0x7, %ecx
jne 0x6a172
movq (%rax), %r14
addq $0x28, %r14
jmp 0x6a175
movq (%rax), %r14
jmp 0x6a175
xorl %r14d, %r14d
leaq 0x84798(%rip), %rdx     # 0xee914
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
testq %r14, %r14
je 0x6a1c9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58e77
testl %eax, %eax
je 0x6a1c9
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x57d6f
testl %eax, %eax
je 0x6a1c9
cmpq $0x0, (%r14)
je 0x6a1de
leaq 0x84783(%rip), %rsi     # 0xee945
movl $0x4, %edx
jmp 0x6a1ea
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
jmp 0x6a1f2
leaq 0x84759(%rip), %rsi     # 0xee93e
movl $0xb, %edx
movq %rbx, %rdi
callq 0x58391
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/liolib.c
// Function: getiofile
static FILE *getiofile (lua_State *L, int findex) {
  FILE *f;
  lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
  f = *(FILE **)lua_touserdata(L, -1);
  if (f == NULL)
    luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
  return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %r14d, %edx
callq 0x58cf6
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
cmpl $0x7, -0x8(%rax)
movq -0x10(%rax), %rax
movl $0x28, %edx
cmovneq %rcx, %rdx
movq (%rax,%rdx), %rax
testq %rax, %rax
je 0x6a25d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
decl %r14d
leaq 0x83675(%rip), %rax     # 0xed8dc
movslq (%rax,%r14,4), %rdx
addq %rax, %rdx
leaq 0x8473f(%rip), %rsi     # 0xee9b4
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: g_iofile
static int g_iofile (lua_State *L, int f, const char *mode) {
  if (!lua_isnoneornil(L, 1)) {
    const char *filename = lua_tostring(L, 1);
    if (filename) {
      FILE **pf = newfile(L);
      *pf = fopen(filename, mode);
      if (*pf == NULL)
        fileerror(L, 1, filename);
    }
    else {
      tofile(L);  /* check that it's a valid file handle */
      lua_pushvalue(L, 1);
    }
    lua_rawseti(L, LUA_ENVIRONINDEX, f);
  }
  /* return current value */
  lua_rawgeti(L, LUA_ENVIRONINDEX, f);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq 0xe6d38(%rip), %rax     # 0x150fd0
je 0x6a332
cmpq 0x10(%r14), %rax
jae 0x6a332
cmpl $0x0, 0x8(%rax)
jle 0x6a332
movq %rdx, %r15
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x58042
testq %rax, %rax
je 0x6a2f6
movq %rax, %r12
movq %r14, %rdi
callq 0x6a34a
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0xb720
movq %rax, (%r13)
testq %rax, %rax
jne 0x6a323
movq %r14, %rdi
movq %r12, %rsi
callq 0x6a391
movq %r14, %rdi
callq 0x69800
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
cmpq %rax, %rcx
jb 0x6a312
leaq 0x833fe(%rip), %rcx     # 0xed710
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebx, %edx
callq 0x59276
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x58cf6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/liolib.c
// Function: newfile
static FILE **newfile (lua_State *L) {
  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
  *pf = NULL;  /* file handle is currently `closed' */
  luaL_getmetatable(L, LUA_FILEHANDLE);
  lua_setmetatable(L, -2);
  return pf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
movq %rax, %r14
movq $0x0, (%rax)
leaq 0x845a8(%rip), %rdx     # 0xee914
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lmathlib.c
// Function: math_frexp
static int math_frexp (lua_State *L) {
  int e;
  lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
  lua_pushinteger(L, e);
  return 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5b394
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0xbc00
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
movl $0x3, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rdx
movq %rdx, 0x10(%rbx)
xorps %xmm0, %xmm0
cvtsi2sdl (%r14), %xmm0
movsd %xmm0, 0x10(%rax)
movl %ecx, 0x18(%rax)
addq $0x10, 0x10(%rbx)
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lmathlib.c
// Function: math_modf
static int math_modf (lua_State *L) {
  double ip;
  double fp = modf(luaL_checknumber(L, 1), &ip);
  lua_pushnumber(L, ip);
  lua_pushnumber(L, fp);
  return 2;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb180
cltq
movq %rax, %rcx
shlq $0x1e, %rcx
addq %rax, %rcx
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x3d, %rcx
addl %edx, %ecx
addl %ecx, %eax
shll $0x1f, %ecx
addl %eax, %ecx
cvtsi2sd %ecx, %xmm0
divsd 0x8300c(%rip), %xmm0    # 0xed990
movq 0x10(%rbx), %rax
movq %rax, %rcx
subq 0x18(%rbx), %rcx
shrq $0x4, %rcx
cmpl $0x2, %ecx
je 0x6a9f0
cmpl $0x1, %ecx
je 0x6a9b2
testl %ecx, %ecx
je 0x6a9ea
leaq 0x840d3(%rip), %rsi     # 0xeea7b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5b41f
testl %eax, %eax
jle 0x6aa58
cvtsi2sd %eax, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0xbac0
addsd 0x76f0a(%rip), %xmm0    # 0xe18f0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0x6aa3f
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5b41f
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
subl %r14d, %eax
jl 0x6aa6c
incl %eax
cvtsi2sd %eax, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0xbac0
xorps %xmm1, %xmm1
cvtsi2sd %r14d, %xmm1
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 %r14
retq
leaq 0x8400a(%rip), %rdx     # 0xeea69
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
leaq 0x83ff6(%rip), %rdx     # 0xeea69
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/loadlib.c
// Function: ll_seeall
static int ll_seeall (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  if (!lua_getmetatable(L, 1)) {
    lua_createtable(L, 0, 1); /* create new metatable */
    lua_pushvalue(L, -1);
    lua_setmetatable(L, 1);
  }
  lua_pushvalue(L, LUA_GLOBALSINDEX);
  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58e77
testl %eax, %eax
jne 0x6ac70
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x58da0
movq 0x10(%rbx), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59337
movq 0x10(%rbx), %rax
movq 0x78(%rbx), %rcx
movq %rcx, (%rax)
movl 0x80(%rbx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
leaq 0x8368e(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/loadlib.c
// Function: ll_loadfunc
static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
  void **reg = ll_register(L, path);
  if (*reg == NULL) *reg = ll_load(L, path);
  if (*reg == NULL)
    return ERRLIB;  /* unable to load library */
  else {
    lua_CFunction f = ll_sym(L, *reg, sym);
    if (f == NULL)
      return ERRFUNC;  /* unable to find function */
    lua_pushcfunction(L, f);
    return 0;  /* return function */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8d155(%rip), %rsi     # 0xf7e0e
leaq 0x83de4(%rip), %rdx     # 0xeeaa4
movq %r15, %rcx
xorl %eax, %eax
callq 0x58880
movl $0xa0, %esi
addq 0x20(%rbx), %rsi
movq 0x10(%rbx), %rcx
addq $-0x10, %rcx
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x58a83
movq 0x10(%rbx), %rcx
leaq -0x10(%rcx), %rax
cmpq 0xe62db(%rip), %rax     # 0x150fd0
je 0x6acfd
cmpl $0x0, -0x8(%rcx)
je 0x6ad26
movl -0x8(%rcx), %ecx
cmpl $0x2, %ecx
je 0x6ad16
cmpl $0x7, %ecx
jne 0x6ad1e
movq (%rax), %r12
addq $0x28, %r12
jmp 0x6adb4
movq (%rax), %r12
jmp 0x6adb4
xorl %r12d, %r12d
jmp 0x6adb4
movq %rax, 0x10(%rbx)
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r12
movq $0x0, (%rax)
leaq 0x82f21(%rip), %rdx     # 0xedc69
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
leaq 0x8d0a5(%rip), %rsi     # 0xf7e0e
leaq 0x83d34(%rip), %rdx     # 0xeeaa4
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x58880
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rcx
movq %rcx, (%rax)
movl -0x18(%rax), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rcx
leaq 0x10(%rcx), %rax
movq %rax, 0x10(%rbx)
movl $0xa0, %esi
addq 0x20(%rbx), %rsi
leaq -0x10(%rcx), %rdx
movq %rbx, %rdi
callq 0x58f49
addq $-0x20, 0x10(%rbx)
cmpq $0x0, (%r12)
jne 0x6ade4
movq %r15, %rdi
movl $0x2, %esi
callq 0xb860
movq %rax, %r15
testq %rax, %rax
jne 0x6ade0
callq 0xb630
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movq %r15, (%r12)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x6ae0b
movq %r14, %rsi
callq 0xb620
testq %rax, %rax
je 0x6ae12
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x58930
jmp 0x6ae27
movl $0x1, %ebp
jmp 0x6ae27
callq 0xb630
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x2, %ebp
movl %ebp, %eax
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/loadlib.c
// Function: loader_preload
static int loader_preload (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  lua_getfield(L, LUA_ENVIRONINDEX, "preload");
  if (!lua_istable(L, -1))
    luaL_error(L, LUA_QL("package.preload") " must be a table");
  lua_getfield(L, -1, name);
  if (lua_isnil(L, -1))  /* not found? */
    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
leaq 0x82f30(%rip), %rdx     # 0xedd7f
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x58b98
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq 0xe6165(%rip), %rcx     # 0x150fd0
je 0x6aebb
cmpl $0x5, -0x8(%rax)
jne 0x6aebb
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x58b98
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq 0xe613e(%rip), %rcx     # 0x150fd0
je 0x6aeae
cmpl $0x0, -0x8(%rax)
jne 0x6aeae
leaq 0x83c2f(%rip), %rsi     # 0xeead0
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x58880
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x83bec(%rip), %rsi     # 0xeeaae
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/loadlib.c
// Function: loader_Lua
static int loader_Lua (lua_State *L) {
  const char *filename;
  const char *name = luaL_checkstring(L, 1);
  filename = findfile(L, name, "path");
  if (filename == NULL) return 1;  /* library not found in this path */
  if (luaL_loadfile(L, filename) != 0)
    loaderror(L, filename);
  return 1;  /* library loaded successfully */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
leaq 0x85e64(%rip), %rdx     # 0xf0d4a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6b03d
testq %rax, %rax
je 0x6af08
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5bcaf
testl %eax, %eax
jne 0x6af15
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b1b9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/loadlib.c
// Function: loader_C
static int loader_C (lua_State *L) {
  const char *funcname;
  const char *name = luaL_checkstring(L, 1);
  const char *filename = findfile(L, name, "cpath");
  if (filename == NULL) return 1;  /* library not found in this path */
  funcname = mkfuncname(L, name);
  if (ll_loadfunc(L, filename, funcname) != 0)
    loaderror(L, filename);
  return 1;  /* library loaded successfully */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
leaq 0x82dd4(%rip), %rdx     # 0xedd12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6b03d
testq %rax, %rax
je 0x6af6e
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6b1fc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6aca1
testl %eax, %eax
jne 0x6af79
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b1b9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/loadlib.c
// Function: loader_Croot
static int loader_Croot (lua_State *L) {
  const char *funcname;
  const char *filename;
  const char *name = luaL_checkstring(L, 1);
  const char *p = strchr(name, '.');
  int stat;
  if (p == NULL) return 0;  /* is root */
  lua_pushlstring(L, name, p - name);
  filename = findfile(L, lua_tostring(L, -1), "cpath");
  if (filename == NULL) return 1;  /* root not found */
  funcname = mkfuncname(L, name);
  if ((stat = ll_loadfunc(L, filename, funcname)) != 0) {
    if (stat != ERRFUNC) loaderror(L, filename);  /* real error */
    lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
                       name, filename);
    return 1;  /* function not found */
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
movq %rax, %rdi
movl $0x2e, %esi
callq 0xb210
testq %rax, %rax
je 0x6b029
subq %r14, %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x58391
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x58042
leaq 0x82d3b(%rip), %rdx     # 0xedd12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6b03d
testq %rax, %rax
je 0x6b023
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b1fc
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x6aca1
testl %eax, %eax
je 0x6b023
cmpl $0x2, %eax
jne 0x6b032
leaq 0x83b46(%rip), %rsi     # 0xeeb59
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x58880
movl $0x1, %r15d
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6b1b9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/loadlib.c
// Function: findfile
static const char *findfile (lua_State *L, const char *name,
                                           const char *pname) {
  const char *path;
  name = luaL_gsub(L, name, ".", LUA_DIRSEP);
  lua_getfield(L, LUA_ENVIRONINDEX, pname);
  path = lua_tostring(L, -1);
  if (path == NULL)
    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
  lua_pushliteral(L, "");  /* error accumulator */
  while ((path = pushnexttemplate(L, path)) != NULL) {
    const char *filename;
    filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
    lua_remove(L, -2);  /* remove path template */
    if (readable(filename))  /* does file exist and is readable? */
      return filename;  /* return that file name */
    lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
    lua_remove(L, -2);  /* remove file name */
    lua_concat(L, 2);  /* add entry to possible error message */
  }
  return NULL;  /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x7f409(%rip), %rdx     # 0xea45e
leaq 0x84810(%rip), %rcx     # 0xef86c
callq 0x5b89a
movq %rax, %r14
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movq %r15, %rdx
callq 0x58b98
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x58042
testq %rax, %rax
je 0x6b1a5
movq %rax, %rbp
leaq 0x83ae9(%rip), %rsi     # 0xeeb7f
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58391
movq %rbp, %r15
movzbl (%r15), %eax
cmpl $0x3b, %eax
jne 0x6b0b4
incq %r15
incq %rbp
jmp 0x6b0a3
testl %eax, %eax
jne 0x6b0bc
xorl %ebp, %ebp
jmp 0x6b0f3
movq %r15, %rdi
movl $0x3b, %esi
callq 0xb210
movq %rax, %r12
testq %rax, %rax
jne 0x6b0df
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
addq %r15, %r12
movq %r12, %rdx
subq %rbp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58391
movq %r12, %rbp
testq %rbp, %rbp
je 0x6b190
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x58042
movq %rbx, %rdi
movq %rax, %rsi
leaq 0x837e5(%rip), %rdx     # 0xee8fd
movq %r14, %rcx
callq 0x5b89a
movq %rax, %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57916
movq %r15, %rdi
leaq 0x83d6e(%rip), %rsi     # 0xeeea8
callq 0xb720
movq %rax, %r12
testq %rax, %rax
je 0x6b154
movq %r12, %rdi
callq 0xb690
movq %r15, %r13
jmp 0x6b185
movq %rbx, %rdi
leaq 0x839b1(%rip), %rsi     # 0xeeb0f
movq %r15, %rdx
xorl %eax, %eax
callq 0x58880
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57916
movq %rbx, %rdi
movl $0x2, %esi
callq 0x59be2
movq %r13, %r15
testq %r12, %r12
je 0x6b0a0
jmp 0x6b193
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x83945(%rip), %rsi     # 0xeeaf1
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/loadlib.c
// Function: mkfuncname
static const char *mkfuncname (lua_State *L, const char *modname) {
  const char *funcname;
  const char *mark = strchr(modname, *LUA_IGMARK);
  if (mark) modname = mark + 1;
  funcname = luaL_gsub(L, modname, ".", LUA_OFSEP);
  funcname = lua_pushfstring(L, POF"%s", funcname);
  lua_remove(L, -2);  /* remove 'gsub' result */
  return funcname;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2d, %esi
callq 0xb210
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %r14, %rsi
leaq 0x7f239(%rip), %rdx     # 0xea45e
leaq 0x83920(%rip), %rcx     # 0xeeb4c
movq %rbx, %rdi
callq 0x5b89a
leaq 0x83913(%rip), %rsi     # 0xeeb4e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x58880
movq %rax, %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57916
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/loslib.c
// Function: getfield
static int getfield (lua_State *L, const char *key, int d) {
  int res;
  lua_getfield(L, -1, key);
  if (lua_isnumber(L, -1))
    res = (int)lua_tointeger(L, -1);
  else {
    if (d < 0)
      return luaL_error(L, "field " LUA_QS " missing in date table", key);
    res = d;
  }
  lua_pop(L, 1);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x58b98
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57cb2
testl %eax, %eax
je 0x6bfde
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57fed
movq %rax, %r14
jmp 0x6bfe3
testl %r14d, %r14d
js 0x6bff1
addq $-0x10, 0x10(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x82cb0(%rip), %rsi     # 0xeeca8
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: str_byte
static int str_byte (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
  ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
  int n, i;
  if (posi <= 0) posi = 1;
  if ((size_t)pose > l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
  n = (int)(pose -  posi + 1);
  if (posi + n <= pose)  /* overflow? */
    luaL_error(L, "string slice too long");
  luaL_checkstack(L, n, "string slice too long");
  for (i=0; i<n; i++)
    lua_pushinteger(L, uchar(s[posi+i-1]));
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x5b1b3
movq %rax, %r15
movl $0x1, %ebp
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b45e
movq (%r12), %rcx
incq %rcx
movq %rax, %r13
sarq $0x3f, %r13
andq %rcx, %r13
addq %rax, %r13
xorl %r14d, %r14d
testq %r13, %r13
movl $0x0, %edx
cmovgq %r13, %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b45e
movq (%r12), %rdx
leaq 0x1(%rdx), %rsi
movq %rax, %rcx
sarq $0x3f, %rcx
andq %rsi, %rcx
addq %rax, %rcx
testq %rcx, %rcx
cmovleq %r14, %rcx
cmpq $0x2, %r13
cmovlq %rbp, %r13
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
cmpq %r13, %rcx
jb 0x6c10b
movl %ecx, %r12d
subl %r13d, %r12d
leal 0x1(%r12), %r14d
movslq %r14d, %rax
addq %r13, %rax
cmpq %rcx, %rax
jle 0x6c11d
leaq 0x82c5f(%rip), %rdx     # 0xeed19
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5b2dd
cmpl $0x7ffffffe, %r12d      # imm = 0x7FFFFFFE
ja 0x6c10b
leaq (%r15,%r13), %rax
decq %rax
cmpl $0x2, %r14d
movl $0x1, %ecx
cmovgel %r14d, %ecx
xorl %edx, %edx
movzbl (%rax,%rdx), %esi
movq 0x10(%rbx), %rdi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rdi)
movl $0x3, 0x8(%rdi)
addq $0x10, 0x10(%rbx)
incq %rdx
cmpq %rdx, %rcx
jne 0x6c0e4
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x82bf5(%rip), %rsi     # 0xeed19
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/lstrlib.c
// Function: str_char
static int str_char (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  for (i=1; i<=n; i++) {
    int c = luaL_checkint(L, i);
    luaL_argcheck(L, uchar(c) == c, i, "invalid value");
    luaL_addchar(&b, uchar(c));
  }
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq 0x10(%rdi), %r13
subq 0x18(%rdi), %r13
shrq $0x4, %r13
leaq 0x18(%rsp), %rax
movq %rdi, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
testl %r13d, %r13d
jle 0x6c1ce
movq %rdi, %rbx
leaq 0x2018(%rsp), %rbp
negl %r13d
movl $0x1, %r14d
movq %rsp, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5b41f
movq %rax, %r12
testl $0xffffff00, %r12d      # imm = 0xFFFFFF00
jne 0x6c1fc
cmpq %rbp, (%rsp)
jb 0x6c1ac
movq %r15, %rdi
callq 0x5ba5e
testl %eax, %eax
je 0x6c1ac
movq %r15, %rdi
callq 0x5ba94
movq (%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movb %r12b, (%rax)
leal (%r14,%r13), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x6c17b
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x5ba5e
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x59be2
movl $0x1, %eax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x82b2c(%rip), %rdx     # 0xeed2f
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: str_dump
static int str_dump (lua_State *L) {
  luaL_Buffer b;
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 1);
  luaL_buffinit(L,&b);
  if (lua_dump(L, writer, &b) != 0)
    luaL_error(L, "unable to dump given function");
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %rbx
movl $0x1, %esi
movl $0x6, %edx
callq 0x5b30c
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x10(%rcx), %rax
cmpq %rax, %rdx
jae 0x6c250
movq %rdx, %rsi
movl $0x0, 0x8(%rdx)
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x6c239
movq %rdx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x20(%rsp), %rax
movq %rbx, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
leaq 0xf35(%rip), %rsi       # 0x6d1a4
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x597cf
testl %eax, %eax
jne 0x6c2a7
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5ba5e
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x59be2
movl $0x1, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
retq
leaq 0x82a8f(%rip), %rsi     # 0xeed3d
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/lstrlib.c
// Function: str_len
static int str_len (lua_State *L) {
  size_t l;
  luaL_checklstring(L, 1, &l);
  lua_pushinteger(L, l);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b1b3
movq 0x10(%rbx), %rax
cvtsi2sdq (%r14), %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: str_lower
static int str_lower (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i=0; i<l; i++)
    luaL_addchar(&b, tolower(uchar(s[i])));
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x5b1b3
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq %r14, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
cmpq $0x0, (%r15)
je 0x6ceb5
leaq 0x2028(%rsp), %r15
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
cmpq %r15, 0x10(%rsp)
jb 0x6ce8b
movq %r14, %rdi
callq 0x5ba5e
testl %eax, %eax
je 0x6ce8b
movq %r14, %rdi
callq 0x5ba94
callq 0xb0f0
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
movb (%rax,%rcx,4), %al
movq 0x10(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movb %al, (%rcx)
incq %r12
cmpq 0x8(%rsp), %r12
jb 0x6ce70
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5ba5e
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x59be2
movl $0x1, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: str_rep
static int str_rep (lua_State *L) {
  size_t l;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  int n = luaL_checkint(L, 2);
  luaL_buffinit(L, &b);
  while (n-- > 0)
    luaL_addlstring(&b, s, l);
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r15
movq %rsp, %rdx
movl $0x1, %esi
callq 0x5b1b3
movq %rax, %rbx
movq %r15, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %r15, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
testl %r14d, %r14d
jle 0x6cf51
incl %r14d
leaq 0x8(%rsp), %r15
movq (%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b99f
decl %r14d
cmpl $0x1, %r14d
jg 0x6cf39
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5ba5e
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x59be2
movl $0x1, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: str_reverse
static int str_reverse (lua_State *L) {
  size_t l;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  while (l--) luaL_addchar(&b, s[l]);
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r14
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x5b1b3
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq %r14, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
subq $0x1, (%r15)
jb 0x6cffe
leaq 0x2020(%rsp), %r15
leaq 0x8(%rsp), %r14
cmpq %r15, 0x8(%rsp)
jb 0x6cfe0
movq %r14, %rdi
callq 0x5ba5e
testl %eax, %eax
je 0x6cfe0
movq %r14, %rdi
callq 0x5ba94
movq (%rsp), %rax
movb (%rbx,%rax), %al
movq 0x8(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movb %al, (%rcx)
subq $0x1, (%rsp)
jae 0x6cfc5
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5ba5e
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x59be2
movl $0x1, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: str_sub
static int str_sub (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
  ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
  if (start < 1) start = 1;
  if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
  if (start <= end)
    lua_pushlstring(L, s+start-1, end-start+1);
  else lua_pushliteral(L, "");
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x5b1b3
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq (%r15), %rcx
incq %rcx
movq %rax, %r12
sarq $0x3f, %r12
andq %rcx, %r12
addq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x5b45e
movq (%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rax, %rsi
sarq $0x3f, %rsi
andq %rdx, %rsi
addq %rax, %rsi
xorl %edx, %edx
testq %rsi, %rsi
cmovgq %rsi, %rdx
cmpq $0x2, %r12
movl $0x1, %eax
cmovgeq %r12, %rax
cmpq %rcx, %rdx
cmovgeq %rcx, %rdx
subq %rax, %rdx
jge 0x6d0bf
leaq 0x81ac7(%rip), %rsi     # 0xeeb7f
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x6d0cc
leaq (%r14,%rax), %rsi
decq %rsi
incq %rdx
movq %rbx, %rdi
callq 0x58391
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: str_upper
static int str_upper (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i=0; i<l; i++)
    luaL_addchar(&b, toupper(uchar(s[i])));
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x5b1b3
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq %r14, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
cmpq $0x0, (%r15)
je 0x6d177
leaq 0x2028(%rsp), %r15
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
cmpq %r15, 0x10(%rsp)
jb 0x6d14d
movq %r14, %rdi
callq 0x5ba5e
testl %eax, %eax
je 0x6d14d
movq %r14, %rdi
callq 0x5ba94
callq 0xb0b0
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
movb (%rax,%rcx,4), %al
movq 0x10(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movb %al, (%rcx)
incq %r12
cmpq 0x8(%rsp), %r12
jb 0x6d132
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5ba5e
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x59be2
movl $0x1, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: classend
static const char *classend (MatchState *ms, const char *p) {
  switch (*p++) {
    case L_ESC: {
      if (*p == '\0')
        luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
      return p+1;
    }
    case '[': {
      if (*p == '^') p++;
      do {  /* look for a `]' */
        if (*p == '\0')
          luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
        if (*(p++) == L_ESC && *p != '\0')
          p++;  /* skip escapes (e.g. `%]') */
      } while (*p != ']');
      return p+1;
    }
    default: {
      return p;
    }
  }
}

// Assembly:
pushq %rax
leaq 0x1(%rsi), %rax
movzbl (%rsi), %ecx
cmpl $0x5b, %ecx
je 0x6d99e
cmpl $0x25, %ecx
jne 0x6d9d0
cmpb $0x0, (%rax)
je 0x6d9e4
addq $0x2, %rsi
movq %rsi, %rax
jmp 0x6d9d0
leaq 0x2(%rsi), %rcx
cmpb $0x5e, 0x1(%rsi)
cmoveq %rcx, %rax
cmpb $0x0, (%rax)
je 0x6d9d2
leaq 0x1(%rax), %rcx
cmpb $0x25, (%rax)
jne 0x6d9c5
cmpb $0x0, 0x1(%rax)
je 0x6d9c5
addq $0x2, %rax
movq %rax, %rcx
movq %rcx, %rax
cmpb $0x5d, (%rcx)
jne 0x6d9aa
incq %rax
popq %rcx
retq
movq 0x10(%rdi), %rdi
leaq 0x8140c(%rip), %rsi     # 0xeede9
xorl %eax, %eax
callq 0x5af61
movq 0x10(%rdi), %rdi
leaq 0x813d7(%rip), %rsi     # 0xeedc6
jmp 0x6d9dd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: singlematch
static int singlematch (int c, const char *p, const char *ep) {
  switch (*p) {
    case '.': return 1;  /* matches any char */
    case L_ESC: return match_class(c, uchar(*(p+1)));
    case '[': return matchbracketclass(c, p, ep-1);
    default:  return (uchar(*p) == c);
  }
}

// Assembly:
movzbl (%rsi), %ecx
cmpl $0x5b, %ecx
je 0x6daa3
cmpl $0x2e, %ecx
je 0x6da9d
cmpl $0x25, %ecx
jne 0x6daab
movzbl 0x1(%rsi), %esi
jmp 0x6db31
movl $0x1, %eax
retq
decq %rdx
jmp 0x6d9f1
xorl %eax, %eax
cmpl %edi, %ecx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: max_expand
static const char *max_expand (MatchState *ms, const char *s,
                                 const char *p, const char *ep) {
  ptrdiff_t i = 0;  /* counts maximum expand for item */
  while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
    i++;
  /* keeps trying to match with the maximum repetitions */
  while (i>=0) {
    const char *res = match(ms, (s+i), ep+1);
    if (res) return res;
    i--;  /* else didn't match; reduce 1 repetition to try again */
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rbp
subq %rsi, %rbp
jbe 0x6daf4
movq %rdx, %r12
xorl %r13d, %r13d
movzbl (%r14,%r13), %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x6da82
testl %eax, %eax
je 0x6daf7
incq %r13
cmpq %r13, %rbp
jne 0x6dad6
jmp 0x6daf7
xorl %r13d, %r13d
incq %rbx
testq %r13, %r13
js 0x6db1c
leaq (%r14,%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6d498
decq %r13
testq %rax, %rax
cmovneq %rax, %r12
je 0x6dafa
jmp 0x6db1f
xorl %r12d, %r12d
movq %r12, %rax
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/lstrlib.c
// Function: gmatch_aux
static int gmatch_aux (lua_State *L) {
  MatchState ms;
  size_t ls;
  const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
  const char *p = lua_tostring(L, lua_upvalueindex(2));
  const char *src;
  ms.L = L;
  ms.src_init = s;
  ms.src_end = s+ls;
  for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
       src <= ms.src_end;
       src++) {
    const char *e;
    ms.level = 0;
    if ((e = match(&ms, src, p)) != NULL) {
      lua_Integer newstart = e-s;
      if (e == src) newstart++;  /* empty match? go at least one position */
      lua_pushinteger(L, newstart);
      lua_replace(L, lua_upvalueindex(3));
      return push_captures(&ms, src, e);
    }
  }
  return 0;  /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
movq %r14, %rdx
callq 0x58042
movq %rax, %rbp
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0xffffd8ec, %esi       # imm = 0xFFFFD8EC
xorl %edx, %edx
callq 0x58042
movq %rax, %r12
movq %rbx, 0x28(%rsp)
movq %rbp, 0x18(%rsp)
movq (%r14), %r14
leaq (%rbp,%r14), %rax
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movl $0xffffd8eb, %esi       # imm = 0xFFFFD8EB
callq 0x57fed
cmpq %r14, %rax
jg 0x6de05
movq %rax, %r13
movq %rbp, 0x8(%rsp)
addq %rbp, %r13
leaq 0x18(%rsp), %rbp
movl $0x0, 0x30(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6d498
movq %rax, %r14
testq %rax, %rax
je 0x6ddf1
movq %r14, %rax
subq 0x8(%rsp), %rax
xorl %ecx, %ecx
cmpq %r14, %r13
sete %cl
addq %rax, %rcx
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xffffd8eb, %esi       # imm = 0xFFFFD8EB
callq 0x57a43
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x6d8d2
movl %eax, %r15d
testq %r14, %r14
jne 0x6de05
incq %r13
cmpq 0x20(%rsp), %r13
jbe 0x6dd86
xorl %r15d, %r15d
jmp 0x6de05
movl %r15d, %eax
addq $0x238, %rsp            # imm = 0x238
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/ltablib.c
// Function: foreach
static int foreach (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checktype(L, 2, LUA_TFUNCTION);
  lua_pushnil(L);  /* first key */
  while (lua_next(L, 1)) {
    lua_pushvalue(L, 2);  /* function */
    lua_pushvalue(L, -3);  /* key */
    lua_pushvalue(L, -3);  /* value */
    lua_call(L, 2, 1);
    if (!lua_isnil(L, -1))
      return 1;
    lua_pop(L, 2);  /* remove value and result */
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x5b30c
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59a33
xorl %ebp, %ebp
testl %eax, %eax
je 0x6e034
leaq 0x7f783(%rip), %r14     # 0xed710
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
addq $0x10, %rcx
cmpq %rax, %rcx
cmovaeq %r14, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x20, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x594c2
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r14, %rcx
je 0x6e02f
cmpl $0x0, -0x8(%rax)
jne 0x6e02f
addq $-0x20, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59a33
testl %eax, %eax
jne 0x6df8d
jmp 0x6e034
movl $0x1, %ebp
movl %ebp, %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/ltablib.c
// Function: foreachi
static int foreachi (lua_State *L) {
  int i;
  int n = aux_getn(L, 1);
  luaL_checktype(L, 2, LUA_TFUNCTION);
  for (i=1; i <= n; i++) {
    lua_pushvalue(L, 2);  /* function */
    lua_pushinteger(L, i);  /* 1st argument */
    lua_rawgeti(L, 1, i);  /* 2nd argument */
    lua_call(L, 2, 1);
    if (!lua_isnil(L, -1))
      return 1;
    lua_pop(L, 1);  /* remove nil result */
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %r14d
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58111
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x5b30c
testl %r15d, %r15d
jle 0x6e12c
negl %r15d
leaq 0x7f680(%rip), %r12     # 0xed710
movl $0x1, %ebp
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
addq $0x10, %rcx
cmpq %rax, %rcx
cmovaeq %r12, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x10(%rax)
movl $0x3, 0x18(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x58cf6
movq 0x10(%rbx), %rsi
addq $-0x30, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x594c2
movq 0x10(%rbx), %rcx
leaq -0x10(%rcx), %rax
cmpq %r12, %rax
je 0x6e12e
cmpl $0x0, -0x8(%rcx)
jne 0x6e12e
movq %rax, 0x10(%rbx)
leal (%r15,%r14), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x6e095
xorl %ebp, %ebp
movl %ebp, %eax
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/ltablib.c
// Function: maxn
static int maxn (lua_State *L) {
  lua_Number max = 0;
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushnil(L);  /* first key */
  while (lua_next(L, 1)) {
    lua_pop(L, 1);  /* remove value */
    if (lua_type(L, -1) == LUA_TNUMBER) {
      lua_Number v = lua_tonumber(L, -1);
      if (v > max) max = v;
    }
  }
  lua_pushnumber(L, max);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59a33
xorpd %xmm0, %xmm0
testl %eax, %eax
je 0x6e207
movsd %xmm0, (%rsp)
leaq 0x7f54e(%rip), %r14     # 0xed710
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq -0x20(%rax), %rcx
cmpq %r14, %rcx
je 0x6e1f4
cmpl $0x3, -0x18(%rax)
jne 0x6e1f4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57fbe
maxsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59a33
testl %eax, %eax
jne 0x6e1c2
jmp 0x6e20c
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltablib.c
// Function: tinsert
static int tinsert (lua_State *L) {
  int e = aux_getn(L, 1) + 1;  /* first empty element */
  int pos;  /* where to insert new element */
  switch (lua_gettop(L)) {
    case 2: {  /* called with only 2 arguments */
      pos = e;  /* insert new element at the end */
      break;
    }
    case 3: {
      int i;
      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
      if (pos > e) e = pos;  /* `grow' array if necessary */
      for (i = e; i > pos; i--) {  /* move up elements */
        lua_rawgeti(L, 1, i-1);
        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
      }
      break;
    }
    default: {
      return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
    }
  }
  luaL_setn(L, 1, e);  /* new size */
  lua_rawseti(L, 1, pos);  /* t[pos] = v */
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58111
movq %rax, %r14
movq 0x10(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x4, %rax
cmpl $0x2, %eax
je 0x6e2b7
cmpl $0x3, %eax
jne 0x6e2da
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
cmpl %r15d, %r14d
jl 0x6e2bd
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x58cf6
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x59276
leal -0x1(%r14), %eax
cmpl %r15d, %r14d
movl %eax, %r14d
jg 0x6e286
jmp 0x6e2bd
incl %r14d
movl %r14d, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x59276
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x80c89(%rip), %rsi     # 0xeef6a
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/ltablib.c
// Function: tremove
static int tremove (lua_State *L) {
  int e = aux_getn(L, 1);
  int pos = luaL_optint(L, 2, e);
  if (!(1 <= pos && pos <= e))  /* position is outside bounds? */
   return 0;  /* nothing to remove */
  luaL_setn(L, 1, e - 1);  /* t.n = n-1 */
  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
  for ( ;pos<e; pos++) {
    lua_rawgeti(L, 1, pos+1);
    lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
  }
  lua_pushnil(L);
  lua_rawseti(L, 1, e);  /* t[e] = nil */
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58111
movq %rax, %r14
movslq %r14d, %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x5b45e
movq %rax, %r15
testl %r15d, %r15d
setle %al
cmpl %r12d, %r15d
setg %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x6e3a6
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x58cf6
cmpl %r14d, %r15d
jge 0x6e383
leal 0x1(%r15), %r12d
movq %rbx, %rdi
movl $0x1, %esi
movl %r12d, %edx
callq 0x58cf6
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x59276
movl %r12d, %r15d
cmpl %r12d, %r14d
jne 0x6e357
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x59276
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq