LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstate.c
// Function: close_state
static void close_state (lua_State *L) {
  global_State *g = G(L);
  luaF_close(L, L->stack);  /* close all upvalues for this thread */
  luaC_freeall(L);  /* collect all objects */
  lua_assert(g->rootgc == obj2gco(L));
  lua_assert(g->strt.nuse == 0);
  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
  luaZ_freebuffer(L, &g->buff);
  freestack(L, L);
  lua_assert(g->totalbytes == sizeof(LG));
  (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movq 0x40(%rdi), %rsi
callq 0x5accd
movq 0x20(%rbx), %r14
movb $0x43, 0x20(%r14)
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
movq $-0x3, %rdx
callq 0x66687
cmpl $0x0, 0xc(%r14)
jle 0x5abe0
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r14), %rsi
addq %r12, %rsi
movq %rbx, %rdi
movq $-0x3, %rdx
callq 0x66687
incq %r13
movslq 0xc(%r14), %rax
addq $0x8, %r12
cmpq %rax, %r13
jl 0x5abbb
movq 0x20(%rbx), %r12
movslq 0xc(%r12), %r14
shlq $0x3, %r14
movq (%r12), %rsi
movq 0x18(%r12), %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0x10(%r12)
subq %r14, 0x78(%r12)
movq 0x58(%r15), %rsi
movq 0x68(%r15), %r14
movq 0x20(%rbx), %r12
movq 0x18(%r12), %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0x10(%r12)
subq %r14, 0x78(%r12)
movq %rax, 0x58(%r15)
movq $0x0, 0x68(%r15)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x66c18
movq 0x10(%r15), %rax
movq 0x18(%r15), %rdi
movl $0x268, %edx            # imm = 0x268
movq %rbx, %rsi
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstate.c
// Function: lua_close
LUA_API void lua_close (lua_State *L) {
  L = G(L)->mainthread;  /* only the main thread can be closed */
  lua_lock(L);
  luaF_close(L, L->stack);  /* close all upvalues for this thread */
  luaC_separateudata(L, 1);  /* separate udata that have GC metamethods */
  L->errfunc = 0;  /* no error function during GC metamethods */
  do {  /* repeat until no more errors */
    L->ci = L->base_ci;
    L->base = L->top = L->ci->base;
    L->nCcalls = L->baseCcalls = 0;
  } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
  lua_assert(G(L)->tmudata == NULL);
  luai_userstateclose(L);
  close_state(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
movq 0xb0(%rax), %rbx
movq 0x40(%rbx), %rsi
movq %rbx, %rdi
callq 0x5accd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5adba
movq $0x0, 0xb0(%rbx)
leaq 0x1f5(%rip), %r14       # 0x5ae88
movq 0x50(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x0, 0x60(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5a753
testl %eax, %eax
jne 0x5ac93
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5ab79
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lfunc.c
// Function: luaF_close
void luaF_close (lua_State *L, StkId level) {
  UpVal *uv;
  global_State *g = G(L);
  while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
    GCObject *o = obj2gco(uv);
    lua_assert(!isblack(o) && uv->v != &uv->u.value);
    L->openupval = uv->next;  /* remove from `open' list */
    if (isdead(g, o))
      luaF_freeupval(L, uv);  /* free upvalue */
    else {
      unlinkupval(uv);
      setobj(L, &uv->u.value, uv->v);
      uv->v = &uv->u.value;  /* now current value lives here */
      luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x98(%rdi), %rsi
testq %rsi, %rsi
je 0x5adb4
movq %rdi, %r14
movq 0x20(%rdi), %r15
cmpq %rbx, 0x10(%rsi)
jb 0x5adb4
movq (%rsi), %rax
movq %rax, 0x98(%r14)
movb 0x20(%r15), %al
notb %al
andb 0x9(%rsi), %al
testb $0x3, %al
je 0x5ad1a
movq %r14, %rdi
callq 0x66bdc
jmp 0x5ad9d
leaq 0x18(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rdx
movq %rcx, 0x18(%rdx)
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rdx
movq %rdx, 0x20(%rcx)
movq 0x10(%rsi), %rcx
movq (%rcx), %rdx
movq %rdx, 0x18(%rsi)
movl 0x8(%rcx), %ecx
movl %ecx, 0x20(%rsi)
movq %rax, 0x10(%rsi)
movq 0x20(%r14), %rdx
movq 0x28(%rdx), %rcx
movq %rcx, (%rsi)
movq %rsi, 0x28(%rdx)
movb 0x9(%rsi), %cl
testb $0x7, %cl
jne 0x5ad9d
cmpb $0x1, 0x21(%rdx)
jne 0x5ad93
movl %ecx, %edx
orb $0x4, %dl
movb %dl, 0x9(%rsi)
cmpl $0x4, 0x20(%rsi)
jl 0x5ad9d
movq (%rax), %rax
testb $0x3, 0x9(%rax)
je 0x5ad9d
movq 0x20(%r14), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x5adaf
movq %rax, %rsi
callq 0x66a62
jmp 0x5ad9d
movb 0x20(%rdx), %al
andb $0x3, %al
orb %cl, %al
movb %al, 0x9(%rsi)
movq 0x98(%r14), %rsi
testq %rsi, %rsi
jne 0x5acec
jmp 0x5adb4
movb 0x20(%rdi), %al
jmp 0x5ad96
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lgc.c
// Function: luaC_separateudata
size_t luaC_separateudata (lua_State *L, int all) {
  global_State *g = G(L);
  size_t deadmem = 0;
  GCObject **p = &g->mainthread->next;
  GCObject *curr;
  while ((curr = *p) != NULL) {
    if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
      p = &curr->gch.next;  /* don't bother with them */
    else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
      markfinalized(gco2u(curr));  /* don't need finalization */
      p = &curr->gch.next;
    }
    else {  /* must call its gc method */
      deadmem += sizeudata(gco2u(curr));
      markfinalized(gco2u(curr));
      *p = curr->gch.next;
      /* link `curr' at the end of `tmudata' list */
      if (g->tmudata == NULL)  /* list is empty? */
        g->tmudata = curr->gch.next = curr;  /* creates a circular list */
      else {
        curr->gch.next = g->tmudata->gch.next;
        g->tmudata->gch.next = curr;
        g->tmudata = curr;
      }
    }
  }
  return deadmem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r12
movq 0xb0(%r12), %rbp
movq (%rbp), %r13
testq %r13, %r13
je 0x5ae73
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movzbl 0x9(%r13), %eax
testb $0x8, %al
jne 0x5ae57
andl $0x3, %eax
orl %ebx, %eax
je 0x5ae57
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x5ae52
testb $0x4, 0xa(%rdi)
jne 0x5ae52
movq 0x20(%r14), %rax
movq 0x138(%rax), %rdx
movl $0x2, %esi
callq 0x66b52
testq %rax, %rax
je 0x5ae52
movq (%r13), %rax
movq 0x20(%r13), %rcx
orb $0x8, 0x9(%r13)
addq %rcx, %r15
addq $0x28, %r15
movq %rax, (%rbp)
movq 0x50(%r12), %rax
testq %rax, %rax
je 0x5ae65
movq (%rax), %rax
movq %rax, (%r13)
movq 0x50(%r12), %rax
movq %r13, (%rax)
jmp 0x5ae69
orb $0x8, 0x9(%r13)
movq %r13, %rbp
movq (%r13), %r13
testq %r13, %r13
jne 0x5ade6
jmp 0x5ae76
movq %r13, (%r13)
movq %r13, 0x50(%r12)
movq %rbp, %r13
jmp 0x5ae57
xorl %r15d, %r15d
movq %r15, %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/lauxlib.c
// Function: luaL_argerror
LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
  lua_Debug ar;
  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
  lua_getinfo(L, "n", &ar);
  if (strcmp(ar.namewhat, "method") == 0) {
    narg--;  /* do not count `self' */
    if (narg == 0)  /* error is in the self argument itself? */
      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
                           ar.name, extramsg);
  }
  if (ar.name == NULL)
    ar.name = "?";
  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
                        narg, ar.name, extramsg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x28(%rdi), %rax
subq 0x50(%rdi), %rax
jbe 0x5af1c
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
movq %rsp, %r15
movl %eax, 0x74(%r15)
leaq 0x968d7(%rip), %rsi     # 0xf17b7
movq %r14, %rdi
movq %r15, %rdx
callq 0x5a270
movq 0x10(%r15), %rdi
leaq 0x9e565(%rip), %rsi     # 0xf945b
callq 0xb890
testl %eax, %eax
jne 0x5af32
decl %ebp
jne 0x5af32
movq 0x8(%rsp), %rdx
leaq 0x92c6c(%rip), %rsi     # 0xedb7b
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5af61
leaq 0x92c42(%rip), %rsi     # 0xedb65
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5af61
cmpq $0x0, 0x8(%rsp)
jne 0x5af46
leaq 0x939bc(%rip), %rax     # 0xee8fd
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
leaq 0x92c47(%rip), %rsi     # 0xedb99
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: luaL_newmetatable
LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
  lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get registry.name */
  if (!lua_isnil(L, -1))  /* name already in use? */
    return 0;  /* leave previous value on top, but return 0 */
  lua_pop(L, 1);
  lua_newtable(L);  /* create metatable */
  lua_pushvalue(L, -1);
  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %rbx, %rdx
callq 0x58b98
movq 0x10(%r14), %rdx
leaq -0x10(%rdx), %rcx
xorl %eax, %eax
cmpq 0xf5dc9(%rip), %rcx     # 0x150fd0
je 0x5b24a
cmpl $0x0, -0x8(%rdx)
jne 0x5b24a
movq %rcx, 0x10(%r14)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq 0x10(%r14), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %rbx, %rdx
callq 0x59137
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/lauxlib.c
// Function: luaL_checkudata
LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
  void *p = lua_touserdata(L, ud);
  if (p != NULL) {  /* value is a userdata? */
    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
        lua_pop(L, 2);  /* remove both metatables */
        return p;
      }
    }
  }
  luaL_typerror(L, ud, tname);  /* else error */
  return NULL;  /* to avoid warnings */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x57945
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x5b27c
cmpl $0x7, %ecx
jne 0x5b281
movq (%rax), %r15
addq $0x28, %r15
jmp 0x5b284
movq (%rax), %r15
jmp 0x5b284
xorl %r15d, %r15d
testq %r15, %r15
je 0x5b2d0
movq %r14, %rdi
movl %ebp, %esi
callq 0x58e77
testl %eax, %eax
je 0x5b2d0
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %rbx, %rdx
callq 0x58b98
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x57d6f
testl %eax, %eax
je 0x5b2d0
addq $-0x20, 0x10(%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x5b010
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: luaL_checknumber
LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
  lua_Number d = lua_tonumber(L, narg);
  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x57fbe
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5b3c6
jp 0x5b3c6
movq %r14, %rdi
movl %ebx, %esi
movsd %xmm0, (%rsp)
callq 0x57cb2
movsd (%rsp), %xmm0
testl %eax, %eax
je 0x5b3ce
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x92a92(%rip), %rdx     # 0xede67
movq %r14, %rdi
movl %ebx, %esi
callq 0x5b010
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: luaL_checkinteger
LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
  lua_Integer d = lua_tointeger(L, narg);
  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x57fed
movq %rax, %r15
testq %rax, %rax
jne 0x5b444
movq %r14, %rdi
movl %ebx, %esi
callq 0x57cb2
testl %eax, %eax
je 0x5b44d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x92a13(%rip), %rdx     # 0xede67
movq %r14, %rdi
movl %ebx, %esi
callq 0x5b010
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: luaL_callmeta
LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
  obj = abs_index(L, obj);
  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
    return 0;
  lua_pushvalue(L, obj);
  lua_call(L, 1, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal -0x1(%r14), %eax
cmpl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
jb 0x5b539
movq 0x10(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x4, %rax
addl %eax, %r14d
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5b497
testl %eax, %eax
je 0x5b587
movq %rbx, %rdi
movl %r14d, %esi
callq 0x57945
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x10, %rsi
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %edx
callq 0x594c2
jmp 0x5b589
xorl %ebp, %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/lauxlib.c
// Function: luaL_findtable
LUALIB_API const char *luaL_findtable (lua_State *L, int idx,
                                       const char *fname, int szhint) {
  const char *e;
  lua_pushvalue(L, idx);
  do {
    e = strchr(fname, '.');
    if (e == NULL) e = fname + strlen(fname);
    lua_pushlstring(L, fname, e - fname);
    lua_rawget(L, -2);
    if (lua_isnil(L, -1)) {  /* no such field? */
      lua_pop(L, 1);  /* remove this nil */
      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
      lua_pushlstring(L, fname, e - fname);
      lua_pushvalue(L, -2);
      lua_settable(L, -4);  /* set new table into field */
    }
    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */
      lua_pop(L, 2);  /* remove table and value */
      return fname;  /* return problematic part of the name */
    }
    lua_remove(L, -2);  /* remove previous table */
    fname = e + 1;
  } while (*e == '.');
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %r14
movq %rdi, %rbx
callq 0x57945
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
leaq 0x91f8a(%rip), %r13     # 0xed710
movq %r14, %rdi
movl $0x2e, %esi
callq 0xb210
movq %rax, %r15
testq %rax, %rax
jne 0x5b7a9
movq %r14, %rdi
callq 0xb260
movq %rax, %r15
addq %r14, %r15
movq %r15, %r12
subq %r14, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x58391
movq 0x10(%rbx), %rbp
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x58c18
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x8(%rbp)
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r13, %rcx
je 0x5b880
cmpl $0x0, -0x8(%rax)
je 0x5b803
cmpq %r13, %rcx
je 0x5b880
cmpl $0x5, -0x8(%rax)
je 0x5b860
jmp 0x5b880
movq %rcx, 0x10(%rbx)
cmpb $0x2e, (%r15)
movl $0x1, %edx
je 0x5b816
movl 0x4(%rsp), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58da0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %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
leaq 0x10(%rcx), %rax
movq %rax, 0x10(%rbx)
leaq -0x30(%rcx), %rsi
leaq -0x10(%rcx), %rdx
movq %rbx, %rdi
callq 0x58f49
addq $-0x20, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57916
leaq 0x1(%r15), %r14
cmpb $0x2e, (%r15)
je 0x5b786
xorl %r14d, %r14d
jmp 0x5b888
addq $-0x20, %rax
movq %rax, 0x10(%rbx)
movq %r14, %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/lauxlib.c
// Function: emptybuffer
static int emptybuffer (luaL_Buffer *B) {
  size_t l = bufflen(B);
  if (l == 0) return 0;  /* put nothing on stack */
  else {
    lua_pushlstring(B->L, B->buffer, l);
    B->p = B->buffer;
    B->lvl++;
    return 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rdx
leaq 0x18(%rdi), %r14
subq %r14, %rdx
je 0x5ba8a
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %r14, %rsi
callq 0x58391
movq %r14, (%rbx)
incl 0x8(%rbx)
movl $0x1, %eax
jmp 0x5ba8c
xorl %eax, %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/lauxlib.c
// Function: adjuststack
static void adjuststack (luaL_Buffer *B) {
  if (B->lvl > 1) {
    lua_State *L = B->L;
    int toget = 1;  /* number of levels to concat */
    size_t toplen = lua_strlen(L, -1);
    do {
      size_t l = lua_strlen(L, -(toget+1));
      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
        toplen += l;
        toget++;
      }
      else break;
    } while (toget < B->lvl);
    lua_concat(L, toget);
    B->lvl = B->lvl - toget + 1;
  }
}

// Assembly:
cmpl $0x2, 0x8(%rdi)
jl 0x5bb16
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58111
movq %rax, %r15
movl $0x1, %ebp
xorl %r12d, %r12d
movl %ebp, %esi
notl %esi
movq %r14, %rdi
callq 0x58111
movl 0x8(%rbx), %ecx
movl %ecx, %edx
subl %ebp, %edx
cmpl $0x9, %edx
setge %dl
cmpq %rax, %r15
seta %sil
orb %dl, %sil
cmoveq %r12, %rax
movzbl %sil, %edx
addl %edx, %ebp
cmpb $0x1, %dl
jne 0x5bafa
addq %rax, %r15
cmpl %ecx, %ebp
jl 0x5bac1
movq %r14, %rdi
movl %ebp, %esi
callq 0x59be2
movl 0x8(%rbx), %eax
subl %ebp, %eax
incl %eax
movl %eax, 0x8(%rbx)
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/lauxlib.c
// Function: luaL_addvalue
LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
  lua_State *L = B->L;
  size_t vl;
  const char *s = lua_tolstring(L, -1, &vl);
  if (vl <= bufffree(B)) {  /* fit into buffer? */
    memcpy(B->p, s, vl);  /* put it there */
    B->p += vl;
    lua_pop(L, 1);  /* remove from stack */
  }
  else {
    if (emptybuffer(B))
      lua_insert(L, -2);  /* put buffer before new value */
    B->lvl++;  /* add new value into B stack */
    adjuststack(B);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x58042
movq (%r15), %rdx
movq (%rbx), %rdi
movq %rbx, %rcx
subq %rdi, %rcx
addq $0x2018, %rcx           # imm = 0x2018
cmpq %rcx, %rdx
jbe 0x5bb7a
movq %rbx, %rdi
callq 0x5ba5e
testl %eax, %eax
je 0x5bb6d
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57a06
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0x5ba94
jmp 0x5bb8f
movq %rax, %rsi
callq 0xb520
movq 0x8(%rsp), %rax
addq %rax, (%rbx)
addq $-0x10, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: luaL_ref
LUALIB_API int luaL_ref (lua_State *L, int t) {
  int ref;
  t = abs_index(L, t);
  if (lua_isnil(L, -1)) {
    lua_pop(L, 1);  /* remove from stack */
    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
  }
  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */
  lua_pop(L, 1);  /* remove it from stack */
  if (ref != 0) {  /* any free element? */
    lua_rawgeti(L, t, ref);  /* remove it from list */
    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
  }
  else {  /* no free elements */
    ref = (int)lua_objlen(L, t);
    ref++;  /* create new reference */
  }
  lua_rawseti(L, t, ref);
  return ref;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %eax
cmpl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
jb 0x5bbbd
movq 0x10(%r14), %rax
subq 0x18(%r14), %rax
shrq $0x4, %rax
addl %eax, %ebx
incl %ebx
movq 0x10(%r14), %rcx
leaq -0x10(%rcx), %rax
cmpq 0xf5404(%rip), %rax     # 0x150fd0
je 0x5bbd4
cmpl $0x0, -0x8(%rcx)
je 0x5bc2f
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x58cf6
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57fed
movq %rax, %r15
addq $-0x10, 0x10(%r14)
movq %r14, %rdi
movl %ebx, %esi
testl %r15d, %r15d
je 0x5bc15
movl %r15d, %edx
callq 0x58cf6
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x59276
jmp 0x5bc20
callq 0x58111
movq %rax, %r15
incl %r15d
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x59276
jmp 0x5bc39
movq %rax, 0x10(%r14)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: luaL_unref
LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
  if (ref >= 0) {
    t = abs_index(L, t);
    lua_rawgeti(L, t, FREELIST_REF);
    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
    lua_pushinteger(L, ref);
    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
  }
}

// Assembly:
testl %edx, %edx
js 0x5bcae
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %eax
cmpl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
jb 0x5bc6b
movq 0x10(%r14), %rax
subq 0x18(%r14), %rax
shrq $0x4, %rax
addl %eax, %ebx
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x58cf6
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x59276
movq 0x10(%r14), %rax
movl %ebp, %ecx
cvtsi2sd %rcx, %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x59276
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: getF
static const char *getF (lua_State *L, void *ud, size_t *size) {
  LoadF *lf = (LoadF *)ud;
  (void)L;
  if (lf->extraline) {
    lf->extraline = 0;
    *size = 1;
    return "\n";
  }
  if (feof(lf->f)) return NULL;
  *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);
  return (*size > 0) ? lf->buff : NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpl $0x0, (%rsi)
je 0x5bf2e
movl $0x0, (%rbx)
movq $0x1, (%r14)
leaq 0x9b97d(%rip), %rbx     # 0xf78a9
jmp 0x5bf63
movq 0x8(%rbx), %rdi
callq 0xb9d0
testl %eax, %eax
je 0x5bf3f
xorl %ebx, %ebx
jmp 0x5bf63
movq 0x8(%rbx), %rcx
addq $0x10, %rbx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %rbx, %rdi
callq 0xb940
movq %rax, (%r14)
testq %rax, %rax
cmoveq %rax, %rbx
movq %rbx, %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/lauxlib.c
// Function: luaL_loadbuffer
LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
                                const char *name) {
  LoadS ls;
  ls.s = buff;
  ls.size = size;
  return lua_load(L, getS, &ls, name);
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0xd(%rip), %rsi         # 0x5bf92
movq %rax, %rdx
callq 0x59744
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: l_alloc
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  (void)ud;
  (void)osize;
  if (nsize == 0) {
    free(ptr);
    return NULL;
  }
  else
    return realloc(ptr, nsize);
}

// Assembly:
movq %rsi, %rdi
testq %rcx, %rcx
je 0x5c020
movq %rcx, %rsi
jmp 0xba70
pushq %rax
callq 0xb790
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/liolib.c
// Function: luaopen_io
LUALIB_API int luaopen_io (lua_State *L) {
  createmeta(L);
  /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
  newfenv(L, io_fclose);
  lua_replace(L, LUA_ENVIRONINDEX);
  /* open library */
  luaL_register(L, LUA_IOLIBNAME, iolib);
  /* create (and set) default files */
  newfenv(L, io_noclose);  /* close function for default files */
  createstdfile(L, stdin, IO_INPUT, "stdin");
  createstdfile(L, stdout, IO_OUTPUT, "stdout");
  createstdfile(L, stderr, 0, "stderr");
  lua_pop(L, 1);  /* pop environment for default files */
  lua_getfield(L, -1, "popen");
  newfenv(L, io_pclose);  /* create environment for 'popen' */
  lua_setfenv(L, -2);  /* set fenv for 'popen' */
  lua_pop(L, 1);  /* pop 'popen' */
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x92771(%rip), %rsi     # 0xee914
callq 0x5b1df
movq 0x10(%rbx), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
leaq 0x92159(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0xf3467(%rip), %rdx     # 0x14f640
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x5b597
leaq 0x112(%rip), %rsi       # 0x5c2fe
movq %rbx, %rdi
callq 0x5c2c0
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x57a43
leaq 0x908e7(%rip), %rsi     # 0xecaef
leaq 0xf2ba1(%rip), %rdx     # 0x14edb0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x5b597
leaq 0x121(%rip), %rsi       # 0x5c341
movq %rbx, %rdi
callq 0x5c2c0
movq 0xf4d61(%rip), %rax     # 0x150f90
movq (%rax), %rsi
leaq 0x919fb(%rip), %rcx     # 0xedc34
movq %rbx, %rdi
movl $0x1, %edx
callq 0x5c36d
movq 0xf4d0b(%rip), %rax     # 0x150f58
movq (%rax), %rsi
leaq 0x919f1(%rip), %rcx     # 0xedc48
movq %rbx, %rdi
movl $0x2, %edx
callq 0x5c36d
movq 0xf4d55(%rip), %rax     # 0x150fc0
movq (%rax), %rsi
leaq 0x919da(%rip), %rcx     # 0xedc4f
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5c36d
addq $-0x10, 0x10(%rbx)
leaq 0x919cb(%rip), %rdx     # 0xedc56
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58b98
leaq 0x14e(%rip), %rsi       # 0x5c3ed
movq %rbx, %rdi
callq 0x5c2c0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x593ec
addq $-0x10, 0x10(%rbx)
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: io_fclose
static int io_fclose (lua_State *L) {
  FILE **p = tofilep(L);
  int ok = (fclose(*p) == 0);
  *p = NULL;
  return pushresult(L, ok, NULL);
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0x6a34a
movq %r15, (%rax)
testl %ebp, %ebp
jle 0x5c3b0
movq 0x10(%r14), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebp, %edx
callq 0x59276
movq 0x10(%r14), %rax
movq -0x20(%rax), %rcx
movq %rcx, (%rax)
movl -0x18(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x593ec
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x59137
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/liolib.c
// Function: io_pclose
static int io_pclose (lua_State *L) {
  FILE **p = tofilep(L);
  int ok = lua_pclose(L, *p);
  *p = NULL;
  return pushresult(L, ok, NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x9251c(%rip), %rdx     # 0xee914
movl $0x1, %esi
callq 0x5b252
movq $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0x69862
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/linit.c
// Function: luaL_openlibs
LUALIB_API void luaL_openlibs (lua_State *L) {
  const luaL_Reg *lib = lualibs;
  for (; lib->func; lib++) {
    lua_pushcfunction(L, lib->func);
    lua_pushstring(L, lib->name);
    lua_call(L, 1, 0);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xf2a4b(%rip), %r15     # 0x14ee70
leaq -0x402(%rip), %r14      # 0x5c02a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x58930
movq (%r15), %rsi
movq 0x18(%r15), %r14
movq %rbx, %rdi
callq 0x58568
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x594c2
addq $0x10, %r15
testq %r14, %r14
jne 0x5c42c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lmathlib.c
// Function: luaopen_math
LUALIB_API int luaopen_math (lua_State *L) {
  luaL_register(L, LUA_MATHLIBNAME, mathlib);
  lua_pushnumber(L, PI);
  lua_setfield(L, -2, "pi");
  lua_pushnumber(L, HUGE_VAL);
  lua_setfield(L, -2, "huge");
#if defined(LUA_COMPAT_MOD)
  lua_getfield(L, -1, "fmod");
  lua_setfield(L, -2, "mod");
#endif
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x90360(%rip), %rsi     # 0xec7d6
leaq 0xf2a83(%rip), %rdx     # 0x14ef00
xorl %ecx, %ecx
callq 0x5b597
movq 0x10(%rbx), %rax
movabsq $0x400921fb54442d18, %rcx # imm = 0x400921FB54442D18
movq %rcx, (%rax)
movl $0x3, %ebp
movl %ebp, 0x8(%rax)
addq $0x10, 0x10(%rbx)
leaq 0x917b3(%rip), %rdx     # 0xedc5c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
movq 0x10(%rbx), %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movq %rcx, (%rax)
movl %ebp, 0x8(%rax)
addq $0x10, 0x10(%rbx)
leaq 0x91789(%rip), %rdx     # 0xedc5f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x9177a(%rip), %rdx     # 0xedc64
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58b98
leaq 0x91e59(%rip), %rdx     # 0xee357
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/loadlib.c
// Function: gctm
static int gctm (lua_State *L) {
  void **lib = (void **)luaL_checkudata(L, 1, "_LOADLIB");
  if (*lib) ll_unloadlib(*lib);
  *lib = NULL;  /* mark library as closed */
  return 0;
}

// Assembly:
pushq %rbx
leaq 0x91589(%rip), %rdx     # 0xedc69
movl $0x1, %esi
callq 0x5b252
movq %rax, %rbx
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5c6fa
callq 0xb4f0
movq $0x0, (%rbx)
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: setpath
static void setpath (lua_State *L, const char *fieldname, const char *envname,
                                   const char *def) {
  const char *path = getenv(envname);
  if (path == NULL)  /* no environment variable? */
    lua_pushstring(L, def);  /* use default */
  else {
    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
    path = luaL_gsub(L, path, LUA_PATHSEP LUA_PATHSEP,
                              LUA_PATHSEP AUXMARK LUA_PATHSEP);
    luaL_gsub(L, path, AUXMARK, def);
    lua_remove(L, -2);
  }
  setprogdir(L);
  lua_setfield(L, -2, fieldname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0xb7c0
testq %rax, %rax
je 0x5c75d
leaq 0x92450(%rip), %rdx     # 0xeeb77
leaq 0x9244c(%rip), %rcx     # 0xeeb7a
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b89a
leaq 0x9243e(%rip), %rdx     # 0xeeb7e
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x5b89a
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57916
jmp 0x5c768
movq %r14, %rdi
movq %r15, %rsi
callq 0x58568
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x59137
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstrlib.c
// Function: luaopen_string
LUALIB_API int luaopen_string (lua_State *L) {
  luaL_register(L, LUA_STRLIBNAME, strlib);
#if defined(LUA_COMPAT_GFIND)
  lua_getfield(L, -1, "gmatch");
  lua_setfield(L, -2, "gfind");
#endif
  createmetatable(L);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x86917(%rip), %rsi     # 0xe30bc
leaq 0xf2a74(%rip), %rdx     # 0x14f220
xorl %ecx, %ecx
callq 0x5b597
leaq 0x915cd(%rip), %rdx     # 0xedd87
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58b98
leaq 0x915c0(%rip), %rdx     # 0xedd8e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x58da0
leaq 0x9238e(%rip), %rsi     # 0xeeb7f
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58391
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rcx
movq %rcx, (%rax)
movl -0x18(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x30(%rax), %rcx
movq %rcx, -0x10(%rax)
movl -0x28(%rax), %ecx
movl %ecx, -0x8(%rax)
addq $0x10, 0x10(%rbx)
leaq 0x91ada(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
addq $-0x10, 0x10(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldebug.c
// Function: currentpc
static int currentpc (lua_State *L, CallInfo *ci) {
  if (!isLua(ci)) return -1;  /* function is not a Lua function? */
  if (ci == L->ci)
    ci->savedpc = L->savedpc;
  return pcRel(ci->savedpc, ci_func(ci)->l.p);
}

// Assembly:
movq 0x8(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x6, 0x8(%rcx)
jne 0x5c892
movq (%rcx), %rdx
cmpb $0x0, 0xa(%rdx)
je 0x5c893
retq
cmpq %rsi, 0x28(%rdi)
jne 0x5c8a1
movq 0x30(%rdi), %rax
movq %rax, 0x18(%rsi)
movq 0x18(%rsi), %rax
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
subq 0x18(%rcx), %rax
shrq $0x2, %rax
decl %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lobject.c
// Function: luaO_chunkid
void luaO_chunkid (char *out, const char *source, size_t bufflen) {
  if (*source == '=') {
    strncpy(out, source+1, bufflen);  /* remove first char */
    out[bufflen-1] = '\0';  /* ensures null termination */
  }
  else {  /* out = "source", or "...source" */
    if (*source == '@') {
      size_t l;
      source++;  /* skip the `@' */
      bufflen -= sizeof(" '...' ");
      l = strlen(source);
      strcpy(out, "");
      if (l > bufflen) {
        source += (l-bufflen);  /* get last part of file name */
        strcat(out, "...");
      }
      strcat(out, source);
    }
    else {  /* out = [string "string"] */
      size_t len = strcspn(source, "\n\r");  /* stop at first newline */
      bufflen -= sizeof(" [string \"...\"] ");
      if (len > bufflen) len = bufflen;
      strcpy(out, "[string \"");
      if (source[len] != '\0') {  /* must truncate? */
        strncat(out, source, len);
        strcat(out, "...");
      }
      else
        strcat(out, source);
      strcat(out, "\"]");
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x40, %eax
je 0x5c8ee
cmpl $0x3d, %eax
jne 0x5c927
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb2d0
movb $0x0, -0x1(%rbx,%r15)
jmp 0x5c998
incq %r14
addq $-0x8, %r15
movq %r14, %rdi
callq 0xb260
movb $0x0, (%rbx)
subq %r15, %rax
jbe 0x5c917
addq %rax, %r14
movq %rbx, %rdi
callq 0xb260
movl $0x2e2e2e, (%rbx,%rax)  # imm = 0x2E2E2E
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbb40
leaq 0x91480(%rip), %rsi     # 0xeddae
movq %r14, %rdi
callq 0xb080
addq $-0x11, %r15
cmpq %r15, %rax
cmovbq %rax, %r15
movabsq $0x20676e697274735b, %rax # imm = 0x20676E697274735B
movq %rax, (%rbx)
movw $0x22, 0x8(%rbx)
cmpb $0x0, (%r14,%r15)
je 0x5c97a
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb430
movq %rbx, %rdi
callq 0xb260
movl $0x2e2e2e, (%rbx,%rax)  # imm = 0x2E2E2E
jmp 0x5c985
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbb40
movq %rbx, %rdi
callq 0xb260
movw $0x5d22, (%rbx,%rax)    # imm = 0x5D22
movb $0x0, 0x2(%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldebug.c
// Function: checkArgMode
static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {
  switch (mode) {
    case OpArgN: check(r == 0); break;
    case OpArgU: break;
    case OpArgR: checkreg(pt, r); break;
    case OpArgK:
      check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);
      break;
  }
  return 1;
}

// Assembly:
cmpl $0x3, %edx
je 0x5d14f
cmpl $0x2, %edx
je 0x5d155
testl %edx, %edx
jne 0x5d15d
testl %esi, %esi
je 0x5d15d
xorl %eax, %eax
retq
btl $0x8, %esi
jb 0x5d163
movzbl 0x73(%rdi), %eax
cmpl %esi, %eax
jle 0x5d14c
movl $0x1, %eax
retq
andl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
cmpl 0x4c(%rdi), %esi
jge 0x5d14c
jmp 0x5d15d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldo.c
// Function: luaD_throw
void luaD_throw (lua_State *L, int errcode) {
  if (L->errorJmp) {
    L->errorJmp->status = errcode;
    LUAI_THROW(L, L->errorJmp);
  }
  else {
    L->status = cast_byte(errcode);
    if (G(L)->panic) {
      resetstack(L, errcode);
      lua_unlock(L);
      G(L)->panic(L);
    }
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
testq %rdi, %rdi
jne 0x5d1f5
movb %bpl, 0xa(%rbx)
movq 0x20(%rbx), %rax
cmpq $0x0, 0x98(%rax)
je 0x5d1eb
leaq 0xa8(%rbx), %r14
movq 0x50(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%rax), %rsi
movq %rsi, 0x18(%rbx)
movq %rbx, %rdi
callq 0x5accd
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5a837
movzwl 0x62(%rbx), %eax
movw %ax, 0x60(%rbx)
movb $0x1, 0x65(%rbx)
movq %rbx, %rdi
callq 0x5d209
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq 0x20(%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
movl $0x1, %edi
callq 0xb7b0
movl %ebp, 0xd0(%rdi)
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb220
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldo.c
// Function: luaD_reallocCI
void luaD_reallocCI (lua_State *L, int newsize) {
  CallInfo *oldci = L->base_ci;
  luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
  L->size_ci = newsize;
  L->ci = (L->ci - oldci) + L->base_ci;
  L->end_ci = L->base_ci + L->size_ci - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, %esi
jl 0x5d2e1
movl %esi, %ebp
movq 0x50(%rbx), %r14
movslq 0x5c(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movslq %esi, %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x5d2f2
movq %rax, 0x50(%rbx)
movl %ebp, 0x5c(%rbx)
movq 0x28(%rbx), %rcx
subq %r14, %rcx
addq %rax, %rcx
movq %rcx, 0x28(%rbx)
addq %r15, %rax
addq $-0x28, %rax
movq %rax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x90ae6(%rip), %rsi     # 0xeddce
movq %rbx, %rdi
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  global_State *g = G(L);
  lua_assert((osize == 0) == (block == NULL));
  block = (*g->frealloc)(g->ud, block, osize, nsize);
  if (block == NULL && nsize > 0)
    luaD_throw(L, LUA_ERRMEM);
  lua_assert((nsize == 0) == (block == NULL));
  g->totalbytes = (g->totalbytes - osize) + nsize;
  return block;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%rdi), %r12
movq 0x18(%r12), %rdi
callq *0x10(%r12)
testq %rbx, %rbx
je 0x5d31b
testq %rax, %rax
je 0x5d32f
subq %r14, %rbx
addq %rbx, 0x78(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movl $0x4, %esi
callq 0x5d170
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldo.c
// Function: luaD_reallocstack
void luaD_reallocstack (lua_State *L, int newsize) {
  TValue *oldstack = L->stack;
  int realsize = newsize + 1 + EXTRA_STACK;
  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
  luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
  L->stacksize = realsize;
  L->stack_last = L->stack+newsize;
  correctstack(L, oldstack);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x7, %esi
jl 0x5d498
movl %esi, %ebp
movslq %esi, %r15
addl $0x6, %ebp
shlq $0x4, %r15
movq 0x40(%rbx), %r14
movslq 0x58(%rbx), %rdx
shlq $0x4, %rdx
leaq 0x60(%r15), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d2f2
movq %rax, 0x40(%rbx)
movl %ebp, 0x58(%rbx)
addq %rax, %r15
movq %r15, 0x38(%rbx)
movq 0x10(%rbx), %rdx
movq 0x98(%rbx), %rcx
subq %r14, %rdx
addq %rax, %rdx
movq %rdx, 0x10(%rbx)
testq %rcx, %rcx
je 0x5d43c
movq 0x10(%rcx), %rax
subq %r14, %rax
addq 0x40(%rbx), %rax
movq (%rcx), %rdx
movq %rax, 0x10(%rcx)
movq %rdx, %rcx
testq %rdx, %rdx
jne 0x5d422
movq 0x28(%rbx), %rax
movq 0x50(%rbx), %rcx
cmpq %rax, %rcx
ja 0x5d47e
movq 0x40(%rbx), %rdx
movq 0x10(%rcx), %rsi
subq %r14, %rsi
addq %rdx, %rsi
movq %rsi, 0x10(%rcx)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
subq %r14, %rsi
addq %rdx, %rsi
movq %rsi, (%rcx)
subq %r14, %rdi
addq %rdx, %rdi
movq %rdi, 0x8(%rcx)
addq $0x28, %rcx
cmpq %rax, %rcx
jbe 0x5d44d
movq 0x18(%rbx), %rax
subq %r14, %rax
addq 0x40(%rbx), %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9092f(%rip), %rsi     # 0xeddce
movq %rbx, %rdi
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldo.c
// Function: growCI
static CallInfo *growCI (lua_State *L) {
  if (L->size_ci > LUAI_MAXCALLS)  /* overflow while handling overflow? */
    luaD_throw(L, LUA_ERRERR);
  else {
    luaD_reallocCI(L, 2*L->size_ci);
    if (L->size_ci > LUAI_MAXCALLS)
      luaG_runerror(L, "stack overflow");
  }
  return ++L->ci;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x5c(%rdi), %esi
cmpl $0x4e21, %esi           # imm = 0x4E21
jge 0x5ee5a
addl %esi, %esi
movq %rbx, %rdi
callq 0x5d27c
cmpl $0x4e21, 0x5c(%rbx)     # imm = 0x4E21
jge 0x5ee67
movq 0x28(%rbx), %rax
addq $0x28, %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5d170
leaq 0x8eb69(%rip), %rsi     # 0xed9d7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldo.c
// Function: luaD_callhook
void luaD_callhook (lua_State *L, int event, int line) {
  lua_Hook hook = L->hook;
  if (hook && L->allowhook) {
    ptrdiff_t top = savestack(L, L->top);
    ptrdiff_t ci_top = savestack(L, L->ci->top);
    lua_Debug ar;
    ar.event = event;
    ar.currentline = line;
    if (event == LUA_HOOKTAILRET)
      ar.i_ci = 0;  /* tail call; no debug information about it */
    else
      ar.i_ci = cast_int(L->ci - L->base_ci);
    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
    L->ci->top = L->top + LUA_MINSTACK;
    lua_assert(L->ci->top <= L->stack_last);
    L->allowhook = 0;  /* cannot call hooks inside a hook */
    lua_unlock(L);
    (*hook)(L, &ar);
    lua_lock(L);
    lua_assert(!L->allowhook);
    L->allowhook = 1;
    L->ci->top = restorestack(L, ci_top);
    L->top = restorestack(L, top);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq 0x70(%rdi), %r14
testq %r14, %r14
je 0x5ef2b
movq %rdi, %rbx
cmpb $0x0, 0x65(%rdi)
je 0x5ef2b
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rdi
movq 0x40(%rbx), %rcx
movq 0x10(%rdi), %r15
movl %esi, (%rsp)
movl %edx, 0x28(%rsp)
xorl %edx, %edx
cmpl $0x4, %esi
je 0x5eec9
subq 0x50(%rbx), %rdi
shrq $0x3, %rdi
imull $0xcccccccd, %edi, %edx # imm = 0xCCCCCCCD
movq %rax, %r12
subq %rcx, %r12
subq %rcx, %r15
movl %edx, 0x74(%rsp)
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x140, %rcx            # imm = 0x140
jg 0x5eef3
movq %rbx, %rdi
movl $0x14, %esi
callq 0x576ac
movl $0x140, %eax            # imm = 0x140
addq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rax, 0x10(%rcx)
movb $0x0, 0x65(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq *%r14
movb $0x1, 0x65(%rbx)
movq 0x28(%rbx), %rax
movq 0x40(%rbx), %rcx
addq %rcx, %r15
movq %r15, 0x10(%rax)
addq %rcx, %r12
movq %r12, 0x10(%rbx)
addq $0x78, %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/ldo.c
// Function: luaD_poscall
int luaD_poscall (lua_State *L, StkId firstResult) {
  StkId res;
  int wanted, i;
  CallInfo *ci;
  if (L->hookmask & LUA_MASKRET)
    firstResult = callrethooks(L, firstResult);
  ci = L->ci--;
  res = ci->func;  /* res == final position of 1st result */
  wanted = ci->nresults;
  L->base = (ci - 1)->base;  /* restore base */
  L->savedpc = (ci - 1)->savedpc;  /* restore savedpc */
  /* move results to correct place */
  for (i = wanted; i != 0 && firstResult < L->top; i--)
    setobjs2s(L, res++, firstResult++);
  while (i-- > 0)
    setnilvalue(res++);
  L->top = res;
  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testb $0x2, 0x64(%rdi)
je 0x5ef9a
movq 0x40(%rbx), %r15
movq %rbx, %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5ee78
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
jne 0x5ef93
jmp 0x5ef8d
movq 0x28(%rbx), %rax
subl $0x1, 0x24(%rax)
jb 0x5ef93
movq %rbx, %rdi
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5ee78
testb $0x2, 0x64(%rbx)
jne 0x5ef71
subq %r15, %r14
addq 0x40(%rbx), %r14
movq 0x28(%rbx), %rcx
leaq -0x28(%rcx), %rax
movq %rax, 0x28(%rbx)
movq -0x28(%rcx), %rdx
movq 0x8(%rcx), %rsi
movl 0x20(%rcx), %eax
movq %rdx, 0x18(%rbx)
movq -0x10(%rcx), %rcx
movq %rcx, 0x30(%rbx)
movl %eax, %ecx
testl %eax, %eax
je 0x5efe9
cmpq 0x10(%rbx), %r14
jae 0x5efe9
leaq 0x10(%rsi), %rdx
movq (%r14), %rdi
movq %rdi, (%rsi)
movl 0x8(%r14), %edi
movl %edi, 0x8(%rsi)
addq $0x10, %r14
movq %rdx, %rsi
decl %ecx
jne 0x5efc3
xorl %ecx, %ecx
jmp 0x5efec
movq %rsi, %rdx
testl %ecx, %ecx
jle 0x5f004
incl %ecx
movl $0x0, 0x8(%rdx)
addq $0x10, %rdx
decl %ecx
cmpl $0x1, %ecx
jg 0x5eff2
movq %rdx, 0x10(%rbx)
incl %eax
popq %rbx
popq %r14
popq %r15
retq