LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_pushresult
LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
  lua_State *L = B->L;
  lua_pushlstring(L, B->b, B->n);
  if (buffonstack(B)) {
    resizebox(L, -2, 0);  /* delete old buffer */
    lua_remove(L, -2);  /* remove its header from the stack */
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
movq %rbx, %rdi
callq 0x63fa
leaq 0x20(%r14), %rax
cmpq %rax, (%r14)
je 0x14947
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
xorl %edx, %edx
callq 0x147fc
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5da2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d51
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_addvalue
LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
  lua_State *L = B->L;
  size_t l;
  const char *s = lua_tolstring(L, -1, &l);
  if (buffonstack(B))
    lua_insert(L, -2);  /* put value below buffer */
  luaL_addlstring(B, s, l);
  lua_remove(L, (buffonstack(B)) ? -2 : -1);  /* remove value */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6249
movq %rax, %r15
leaq 0x20(%r14), %r13
cmpq %r13, (%r14)
je 0x1499c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5da2
movq 0x8(%rsp), %r12
testq %r12, %r12
je 0x149c3
movq %r14, %rdi
movq %r12, %rsi
callq 0x146f3
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5320
addq %r12, 0x10(%r14)
xorl %esi, %esi
cmpq %r13, (%r14)
sete %sil
orl $-0x2, %esi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5da2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_buffinit
LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
  B->L = L;
  B->b = B->initb;
  B->n = 0;
  B->size = LUAL_BUFFERSIZE;
}

// Assembly:
movq %rdi, 0x18(%rsi)
leaq 0x20(%rsi), %rax
movq %rax, (%rsi)
movq $0x0, 0x10(%rsi)
movq $0x2000, 0x8(%rsi)      # imm = 0x2000
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_ref
LUALIB_API int luaL_ref (lua_State *L, int t) {
  int ref;
  if (lua_isnil(L, -1)) {
    lua_pop(L, 1);  /* remove from stack */
    return LUA_REFNIL;  /* 'nil' has a unique fixed reference */
  }
  t = lua_absindex(L, t);
  lua_rawgeti(L, t, freelist);  /* get first free element */
  ref = (int)lua_tointeger(L, -1);  /* ref = t[freelist] */
  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);  /* (t[freelist] = t[ref]) */
  }
  else  /* no free elements */
    ref = (int)lua_rawlen(L, t) + 1;  /* get a new reference */
  lua_rawseti(L, t, ref);
  return ref;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f7f
testl %eax, %eax
je 0x14aad
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5d1c
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x684b
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x61d3
movq %rax, %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
testl %r14d, %r14d
je 0x14abc
movslq %r14d, %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x684b
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x6c80
jmp 0x14acc
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
jmp 0x14ad9
movq %rbx, %rdi
movl %ebp, %esi
callq 0x62c9
movq %rax, %r14
incl %r14d
movslq %r14d, %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6c80
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_unref
LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
  if (ref >= 0) {
    t = lua_absindex(L, t);
    lua_rawgeti(L, t, freelist);
    lua_rawseti(L, t, ref);  /* t[ref] = t[freelist] */
    lua_pushinteger(L, ref);
    lua_rawseti(L, t, freelist);  /* t[freelist] = ref */
  }
}

// Assembly:
testl %edx, %edx
js 0x14b38
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x5d1c
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x684b
movl %ebp, %r15d
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x6c80
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63e6
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c80
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: errfile
static int errfile (lua_State *L, const char *what, int fnameindex) {
  const char *serr = strerror(errno);
  const char *filename = lua_tostring(L, fnameindex) + 1;
  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
  lua_remove(L, fnameindex);
  return LUA_ERRFILE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5090
movl (%rax), %edi
callq 0x54d0
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x6249
leaq 0x1(%rax), %rcx
leaq 0xd73d(%rip), %rsi      # 0x2244f
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x64e8
movq %rbx, %rdi
movl %ebp, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5da2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5d51
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: skipcomment
static int skipcomment (LoadF *lf, int *cp) {
  int c = *cp = skipBOM(lf);
  if (c == '#') {  /* first line is a comment (Unix exec. file)? */
    do {  /* skip first line */
      c = getc(lf->f);
    } while (c != EOF && c != '\n');
    *cp = getc(lf->f);  /* skip end-of-line, if present */
    return 1;  /* there was a comment */
  }
  else return 0;  /* no comment */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rdi)
xorl %r15d, %r15d
leaq 0xd6fa(%rip), %r12      # 0x22460
movq 0x8(%r14), %rdi
callq 0x54f0
cmpl $-0x1, %eax
je 0x14da4
movzbl (%r15,%r12), %ecx
cmpl %ecx, %eax
jne 0x14da4
incq %r15
movslq (%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movb %al, 0x10(%r14,%rcx)
cmpq $0x3, %r15
jne 0x14d66
movl $0x0, (%r14)
movq 0x8(%r14), %rdi
callq 0x54f0
movl %eax, (%rbx)
xorl %ecx, %ecx
cmpl $0x23, %eax
jne 0x14dd0
movq 0x8(%r14), %rdi
callq 0x54f0
cmpl $0xa, %eax
je 0x14dc0
cmpl $-0x1, %eax
jne 0x14dad
movq 0x8(%r14), %rdi
callq 0x54f0
movl %eax, (%rbx)
movl $0x1, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: getF
static const char *getF (lua_State *L, void *ud, size_t *size) {
  LoadF *lf = (LoadF *)ud;
  (void)L;  /* not used */
  if (lf->n > 0) {  /* are there pre-read characters to be read? */
    *size = lf->n;  /* return them (chars already in buffer) */
    lf->n = 0;  /* no more pre-read characters */
  }
  else {  /* read a block from file */
    /* 'fread' can return > 0 *and* set the EOF flag. If next call to
       'getF' called 'fread', it might still wait for user input.
       The next check avoids this problem. */
    if (feof(lf->f)) return NULL;
    *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);  /* read block */
  }
  return lf->buff;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
jle 0x14dff
movq %rax, (%r14)
movl $0x0, (%rbx)
addq $0x10, %rbx
jmp 0x14e0e
movq 0x8(%rbx), %rdi
callq 0x52e0
testl %eax, %eax
je 0x14e19
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rbx), %rdi
movq 0x8(%rbx), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x50e0
movq %rax, (%r14)
jmp 0x14df9
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_loadbufferx
LUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size,
                                 const char *name, const char *mode) {
  LoadS ls;
  ls.s = buff;
  ls.size = size;
  return lua_load(L, getS, &ls, name, mode);
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0xd(%rip), %rsi         # 0x14e59
movq %rax, %rdx
callq 0x6f8e
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: getS
static const char *getS (lua_State *L, void *ud, size_t *size) {
  LoadS *ls = (LoadS *)ud;
  (void)L;  /* not used */
  if (ls->size == 0) return NULL;
  *size = ls->size;
  ls->size = 0;
  return ls->s;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x14e71
movq %rax, (%rdx)
movq $0x0, 0x8(%rsi)
movq (%rsi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_getmetafield
LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
  if (!lua_getmetatable(L, obj))  /* no metatable? */
    return LUA_TNIL;
  else {
    int tt;
    lua_pushstring(L, event);
    tt = lua_rawget(L, -2);
    if (tt == LUA_TNIL)  /* is metafield nil? */
      lua_pop(L, 2);  /* remove metatable and metafield */
    else
      lua_remove(L, -2);  /* remove only metatable */
    return tt;  /* return metafield type */
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6935
testl %eax, %eax
je 0x14efd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x645b
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6815
movl %eax, %ebp
testl %eax, %eax
je 0x14f01
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5da2
jmp 0x14f07
xorl %ebp, %ebp
jmp 0x14f12
movl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5d51
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_callmeta
LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
  obj = lua_absindex(L, obj);
  if (luaL_getmetafield(L, obj, event) == LUA_TNIL)  /* no metafield? */
    return 0;
  lua_pushvalue(L, obj);
  lua_call(L, 1, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x5d1c
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x14eb2
testl %eax, %eax
je 0x14f63
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5f5b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6e22
jmp 0x14f65
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_len
LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) {
  lua_Integer l;
  int isnum;
  lua_len(L, idx);
  l = lua_tointegerx(L, -1, &isnum);
  if (!isnum)
    luaL_error(L, "object length is not an integer");
  lua_pop(L, 1);  /* remove object */
  return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7237
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x61d3
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0x14fac
leaq 0xd325(%rip), %rsi      # 0x222c7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13f8e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_tolstring
LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
  if (!luaL_callmeta(L, idx, "__tostring")) {  /* no metafield? */
    switch (lua_type(L, idx)) {
      case LUA_TNUMBER: {
        if (lua_isinteger(L, idx))
          lua_pushfstring(L, "%I", lua_tointeger(L, idx));
        else
          lua_pushfstring(L, "%f", lua_tonumber(L, idx));
        break;
      }
      case LUA_TSTRING:
        lua_pushvalue(L, idx);
        break;
      case LUA_TBOOLEAN:
        lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false"));
        break;
      case LUA_TNIL:
        lua_pushliteral(L, "nil");
        break;
      default:
        lua_pushfstring(L, "%s: %p", luaL_typename(L, idx),
                                            lua_topointer(L, idx));
        break;
    }
  }
  return lua_tolstring(L, -1, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0xd30b(%rip), %rdx      # 0x222e7
callq 0x14f19
testl %eax, %eax
je 0x14fff
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6249
movq %r14, %rdi
movl %ebp, %esi
callq 0x5f7f
cmpl $0x4, %eax
ja 0x1509b
movl %eax, %eax
leaq 0xd195(%rip), %rcx      # 0x221b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xcc4c(%rip), %rsi      # 0x21c77
jmp 0x1507f
movq %r14, %rdi
movl %ebp, %esi
callq 0x5fcc
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
testl %eax, %eax
je 0x150d8
callq 0x61d3
leaq 0xd2a0(%rip), %rsi      # 0x222f2
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x64e8
jmp 0x14fe5
movq %r14, %rdi
movl %ebp, %esi
callq 0x6223
testl %eax, %eax
leaq 0xd286(%rip), %rax      # 0x222fa
leaq 0xd27a(%rip), %rsi      # 0x222f5
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x645b
jmp 0x14fe5
movq %r14, %rdi
movl %ebp, %esi
callq 0x5f5b
jmp 0x14fe5
movq %r14, %rdi
movl %ebp, %esi
callq 0x5f7f
movq %r14, %rdi
movl %eax, %esi
callq 0x5fa0
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x637a
leaq 0xd23d(%rip), %rsi      # 0x22300
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x64e8
jmp 0x14fe5
callq 0x6182
leaq 0xd2bb(%rip), %rsi      # 0x2239f
movq %r14, %rdi
movb $0x1, %al
callq 0x64e8
jmp 0x14fe5
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_setfuncs
LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
  luaL_checkstack(L, nup, "too many upvalues");
  for (; l->name != NULL; l++) {  /* fill the table with given functions */
    int i;
    for (i = 0; i < nup; i++)  /* copy upvalues to the top */
      lua_pushvalue(L, -nup);
    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
    lua_setfield(L, -(nup + 2), l->name);
  }
  lua_pop(L, nup);  /* remove upvalues */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xd1fa(%rip), %rdx      # 0x22307
movl %ebx, %esi
callq 0x13e55
cmpq $0x0, (%r15)
je 0x15164
movl %ebx, %ebp
negl %ebp
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
subl %ebx, %r12d
testl %ebx, %ebx
jle 0x1513d
movl %ebx, %r13d
movq %r14, %rdi
movl %ebp, %esi
callq 0x5f5b
decl %r13d
jne 0x1512e
movq 0x8(%r15), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x6591
movq (%r15), %rdx
movq %r14, %rdi
movl %r12d, %esi
callq 0x6b3f
cmpq $0x0, 0x10(%r15)
leaq 0x10(%r15), %r15
jne 0x15127
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5d51
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_getsubtable
LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
  if (lua_getfield(L, idx, fname) == LUA_TTABLE)
    return 1;  /* table already there */
  else {
    lua_pop(L, 1);  /* remove previous result */
    idx = lua_absindex(L, idx);
    lua_newtable(L);
    lua_pushvalue(L, -1);  /* copy to be left at top */
    lua_setfield(L, idx, fname);  /* assign new table to field */
    return 0;  /* false, because did not find table there */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x6777
movl $0x1, %ebp
cmpl $0x5, %eax
je 0x151e1
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %r14, %rdi
movl %r15d, %esi
callq 0x5d1c
movl %eax, %r15d
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x68d6
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f5b
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x6b3f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_requiref
LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
                               lua_CFunction openf, int glb) {
  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, -1, modname);  /* _LOADED[modname] */
  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
    lua_pop(L, 1);  /* remove field */
    lua_pushcfunction(L, openf);
    lua_pushstring(L, modname);  /* argument to open function */
    lua_call(L, 1, 1);  /* call 'openf' to open module */
    lua_pushvalue(L, -1);  /* make copy of module (call result) */
    lua_setfield(L, -3, modname);  /* _LOADED[modname] = module */
  }
  lua_remove(L, -2);  /* remove _LOADED table */
  if (glb) {
    lua_pushvalue(L, -1);  /* copy of module */
    lua_setglobal(L, modname);  /* _G[modname] = module */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd112(%rip), %rdx      # 0x22319
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1517e
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
callq 0x6777
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6223
testl %eax, %eax
jne 0x1528b
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6591
movq %r14, %rdi
movq %rbx, %rsi
callq 0x645b
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6e22
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f5b
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movq %rbx, %rdx
callq 0x6b3f
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5da2
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
testl %ebp, %ebp
je 0x152d0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f5b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x69c7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_gsub
LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
                                                               const char *r) {
  const char *wild;
  size_t l = strlen(p);
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  while ((wild = strstr(s, p)) != NULL) {
    luaL_addlstring(&b, s, wild - s);  /* push prefix */
    luaL_addstring(&b, r);  /* push replacement in place of pattern */
    s = wild + l;  /* continue after 'p' */
  }
  luaL_addstring(&b, s);  /* push last suffix */
  luaL_pushresult(&b);
  return lua_tostring(L, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2038, %rsp           # imm = 0x2038
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x5150
movq %rax, %r13
leaq 0x38(%rsp), %rax
movq %rbx, 0x8(%rsp)
movq %rbx, -0x8(%rax)
movq %rax, -0x20(%rax)
movq $0x0, -0x10(%rax)
movq $0x2000, -0x18(%rax)    # imm = 0x2000
movq %r12, %rdi
movq %r15, %rsi
callq 0x5500
testq %rax, %rax
je 0x1538b
movq %rax, %r14
leaq 0x18(%rsp), %rbp
movq %r14, %rbx
subq %r12, %rbx
je 0x15365
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x146f3
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5320
addq %rbx, 0x28(%rsp)
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x148b1
movq %r14, %r12
addq %r13, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5500
movq %rax, %r14
testq %rax, %rax
jne 0x1533f
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x148b1
movq %rbx, %rdi
callq 0x148ef
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6249
addq $0x2038, %rsp           # imm = 0x2038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: l_alloc
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  (void)ud; (void)osize;  /* not used */
  if (nsize == 0) {
    free(ptr);
    return NULL;
  }
  else
    return realloc(ptr, nsize);
}

// Assembly:
movq %rsi, %rdi
testq %rcx, %rcx
je 0x15401
movq %rcx, %rsi
jmp 0x53f0
pushq %rax
callq 0x5050
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_checkversion_
LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
  const lua_Number *v = lua_version(L);
  if (sz != LUAL_NUMSIZES)  /* check numeric types */
    luaL_error(L, "core and library have incompatible numeric types");
  if (v != lua_version(NULL))
    luaL_error(L, "multiple Lua VMs detected");
  else if (*v != ver)
    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                  ver, *v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x5d03
movq %rax, %r14
cmpq $0x88, %r15
je 0x15442
leaq 0xcee9(%rip), %rsi      # 0x22321
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13f8e
xorl %edi, %edi
callq 0x5d03
cmpq %rax, %r14
je 0x15468
leaq 0xcefd(%rip), %rsi      # 0x22352
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x13f8e
movsd (%r14), %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm0, %xmm1
jne 0x1547b
jnp 0x15495
leaq 0xceea(%rip), %rsi      # 0x2236c
movq %rbx, %rdi
movb $0x2, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x13f8e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: findfield
static int findfield (lua_State *L, int objidx, int level) {
  if (level == 0 || !lua_istable(L, -1))
    return 0;  /* not found */
  lua_pushnil(L);  /* start 'next' loop */
  while (lua_next(L, -2)) {  /* for each pair in table */
    if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */
      if (lua_rawequal(L, objidx, -1)) {  /* found object? */
        lua_pop(L, 1);  /* remove value (but keep name) */
        return 1;
      }
      else if (findfield(L, objidx, level - 1)) {  /* try recursively */
        lua_remove(L, -2);  /* remove table (but keep name) */
        lua_pushliteral(L, ".");
        lua_insert(L, -2);  /* place '.' between the two names */
        lua_concat(L, 3);
        return 1;
      }
    }
    lua_pop(L, 1);  /* remove value */
  }
  return 0;  /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testl %edx, %edx
je 0x155aa
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f7f
cmpl $0x5, %eax
jne 0x155aa
movq %rbx, %rdi
callq 0x63bd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x719c
testl %eax, %eax
je 0x155aa
decl %r14d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5f7f
cmpl $0x4, %eax
jne 0x15524
movq %rbx, %rdi
movl %r15d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x603d
testl %eax, %eax
jne 0x15544
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x1549f
testl %eax, %eax
jne 0x15558
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x719c
testl %eax, %eax
jne 0x154ec
jmp 0x155aa
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movl $0x1, %ebp
jmp 0x155aa
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5da2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
leaq 0xcc5f(%rip), %rsi      # 0x221dd
movq %rbx, %rdi
callq 0x645b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5da2
movq %rbx, %rdi
movl $0x3, %esi
callq 0x71d3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/linit.c
// Function: luaL_openlibs
LUALIB_API void luaL_openlibs (lua_State *L) {
  const luaL_Reg *lib;
  /* "require" functions from 'loadedlibs' and set results to global table */
  for (lib = loadedlibs; lib->func; lib++) {
    luaL_requiref(L, lib->name, lib->func, 1);
    lua_pop(L, 1);  /* remove lib */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18b69(%rip), %r14     # 0x2e140
leaq 0x286a(%rip), %rdx      # 0x17e48
movq (%r14), %rsi
movq 0x18(%r14), %r15
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x151ee
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
addq $0x10, %r14
movq %r15, %rdx
testq %r15, %r15
jne 0x155de
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_nil
void luaK_nil (FuncState *fs, int from, int n) {
  Instruction *previous;
  int l = from + n - 1;  /* last register to set nil */
  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
    previous = &fs->f->code[fs->pc-1];
    if (GET_OPCODE(*previous) == OP_LOADNIL) {  /* previous is LOADNIL? */
      int pfrom = GETARG_A(*previous);  /* get previous range */
      int pl = pfrom + GETARG_B(*previous);
      if ((pfrom <= from && from <= pl + 1) ||
          (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */
        if (pfrom < from) from = pfrom;  /* from = min(from, pfrom) */
        if (pl > l) l = pl;  /* l = max(l, pl) */
        SETARG_A(*previous, from);
        SETARG_B(*previous, l - from);
        return;
      }
    }  /* else go through */
  }
  luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0);  /* else no optimization */
}

// Assembly:
movslq 0x20(%rdi), %rax
cmpl 0x24(%rdi), %eax
jle 0x156c8
movq (%rdi), %rcx
movq 0x38(%rcx), %rcx
movl -0x4(%rcx,%rax,4), %r8d
movl %r8d, %r9d
andl $0x3f, %r9d
cmpl $0x4, %r9d
jne 0x156c8
pushq %rbp
pushq %rbx
leal (%rdx,%rsi), %r10d
movl %r8d, %r9d
shrl $0x6, %r9d
movzbl %r9b, %r11d
movl %r8d, %r9d
shrl $0x17, %r9d
cmpl %esi, %r11d
setg %bl
leal (%r11,%r9), %ebp
incl %ebp
cmpl %esi, %ebp
setl %bpl
orb %bl, %bpl
cmpb $0x1, %bpl
jne 0x15685
cmpl %esi, %r11d
setl %bl
cmpl %r10d, %r11d
setg %bpl
orb %bl, %bpl
movb $0x1, %bl
jne 0x156c2
leal (%rdx,%rsi), %ebx
addl $0x1ff, %ebx            # imm = 0x1FF
addl %r11d, %r9d
cmpl %esi, %r11d
cmovll %r11d, %esi
cmpl %r10d, %r9d
cmovll %ebx, %r9d
andl $0x7fc004, %r8d         # imm = 0x7FC004
movzbl %sil, %r10d
shll $0x6, %r10d
orl %r8d, %r10d
subl %esi, %r9d
shll $0x17, %r9d
orl %r10d, %r9d
movl %r9d, -0x4(%rcx,%rax,4)
xorl %ebx, %ebx
testb %bl, %bl
popq %rbx
popq %rbp
je 0x156dd
shll $0x6, %esi
shll $0x17, %edx
addl $0xff800004, %edx       # imm = 0xFF800004
orl %esi, %edx
movl %edx, %esi
jmp 0x158de
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_concat
void luaK_concat (FuncState *fs, int *l1, int l2) {
  if (l2 == NO_JUMP) return;  /* nothing to concatenate? */
  else if (*l1 == NO_JUMP)  /* no original list? */
    *l1 = l2;  /* 'l1' points to 'l2' */
  else {
    int list = *l1;
    int next;
    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
      list = next;
    fixjump(fs, list, l2);  /* last element links to 'l2' */
  }
}

// Assembly:
cmpl $-0x1, %edx
je 0x15735
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0x15733
movq (%rdi), %rax
movq 0x38(%rax), %rax
movl %ecx, %esi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %r8d
shrl $0xe, %r8d
leal -0x1ffff(%r8), %r9d
cmpl $-0x1, %r9d
leal -0x1fffe(%rcx,%r8), %ecx
cmovel %r9d, %ecx
cmpl $-0x1, %ecx
jne 0x15708
jmp 0x15736
movl %edx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: fixjump
static void fixjump (FuncState *fs, int pc, int dest) {
  Instruction *jmp = &fs->f->code[pc];
  int offset = dest - (pc + 1);
  lua_assert(dest != NO_JUMP);
  if (abs(offset) > MAXARG_sBx)
    luaX_syntaxerror(fs->ls, "control structure too long");
  SETARG_sBx(*jmp, offset);
}

// Assembly:
movl %esi, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x20000, %ecx          # imm = 0x20000
jae 0x1576b
movq (%rdi), %rcx
movq 0x38(%rcx), %rcx
movslq %esi, %rdx
movl $0x3fff, %esi           # imm = 0x3FFF
andl (%rcx,%rdx,4), %esi
shll $0xe, %eax
addl %esi, %eax
addl $0x7fffc000, %eax       # imm = 0x7FFFC000
movl %eax, (%rcx,%rdx,4)
retq
pushq %rax
movq 0x10(%rdi), %rdi
leaq 0xce55(%rip), %rsi      # 0x225cc
callq 0x16d86
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_jump
int luaK_jump (FuncState *fs) {
  int jpc = fs->jpc;  /* save list of jumps to here */
  int j;
  fs->jpc = NO_JUMP;  /* no more jumps to here */
  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
  luaK_concat(fs, &j, jpc);  /* keep them on hold */
  return j;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %ebp
movl $0xffffffff, 0x28(%rdi) # imm = 0xFFFFFFFF
movl $0x7fff801e, %esi       # imm = 0x7FFF801E
callq 0x158de
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x156f5
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_patchlist
void luaK_patchlist (FuncState *fs, int list, int target) {
  if (target == fs->pc)  /* 'target' is current position? */
    luaK_patchtohere(fs, list);  /* add list to pending jumps */
  else {
    lua_assert(target < fs->pc);
    patchlistaux(fs, list, target, NO_REG, target);
  }
}

// Assembly:
movl %edx, %r8d
movl %esi, %edx
movl 0x20(%rdi), %eax
cmpl %r8d, %eax
jne 0x15812
movl %eax, 0x24(%rdi)
leaq 0x28(%rdi), %rsi
jmp 0x156f5
movl %edx, %esi
movl %r8d, %edx
movl $0xff, %ecx
jmp 0x1581e
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: patchlistaux
static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
                          int dtarget) {
  while (list != NO_JUMP) {
    int next = getjump(fs, list);
    if (patchtestreg(fs, list, reg))
      fixjump(fs, list, vtarget);
    else
      fixjump(fs, list, dtarget);  /* jump to default target */
    list = next;
  }
}

// Assembly:
cmpl $-0x1, %esi
je 0x15896
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
movq (%r15), %rax
movq 0x38(%rax), %rax
movslq %r12d, %r13
movl (%rax,%r13,4), %eax
shrl $0xe, %eax
leal -0x1ffff(%rax), %ecx
cmpl $-0x1, %ecx
leal -0x1fffe(%r13,%rax), %r12d
cmovel %ecx, %r12d
movq %r15, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x169ff
testl %eax, %eax
movl %r14d, %edx
cmovel %ebx, %edx
movq %r15, %rdi
movl %r13d, %esi
callq 0x15736
cmpl $-0x1, %r12d
jne 0x1583c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_patchclose
void luaK_patchclose (FuncState *fs, int list, int level) {
  level++;  /* argument is +1 to reserve 0 as non-op */
  for (; list != NO_JUMP; list = getjump(fs, list)) {
    lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP &&
                (GETARG_A(fs->f->code[list]) == 0 ||
                 GETARG_A(fs->f->code[list]) >= level));
    SETARG_A(fs->f->code[list], level);
  }
}

// Assembly:
cmpl $-0x1, %esi
je 0x158dd
movq (%rdi), %rax
movq 0x38(%rax), %rax
shll $0x6, %edx
addl $0x40, %edx
andl $0x3fc0, %edx           # imm = 0x3FC0
movslq %esi, %rcx
movl (%rax,%rcx,4), %esi
movl %esi, %edi
andl $0xffffc03f, %edi       # imm = 0xFFFFC03F
orl %edx, %edi
movl %edi, (%rax,%rcx,4)
shrl $0xe, %esi
leal -0x1ffff(%rsi), %edi
cmpl $-0x1, %edi
leal -0x1fffe(%rcx,%rsi), %esi
cmovel %edi, %esi
cmpl $-0x1, %esi
jne 0x158af
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_code
static int luaK_code (FuncState *fs, Instruction i) {
  Proto *f = fs->f;
  dischargejpc(fs);  /* 'pc' will change */
  /* put new instruction in code array */
  luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
                  MAX_INT, "opcodes");
  f->code[fs->pc] = i;
  /* save corresponding line information */
  luaM_growvector(fs->ls->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
                  MAX_INT, "opcodes");
  f->lineinfo[fs->pc] = fs->ls->lastline;
  return fs->pc++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r14
movl 0x28(%rdi), %esi
movl 0x20(%rdi), %edx
movl $0xff, %ecx
movl %edx, %r8d
callq 0x1581e
movl $0xffffffff, 0x28(%rbx) # imm = 0xFFFFFFFF
movl 0x20(%rbx), %eax
cmpl 0x18(%r14), %eax
jl 0x15938
leaq 0x18(%r14), %rdx
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x38(%r14), %rsi
leaq 0xccc3(%rip), %r9       # 0x225e7
movl $0x4, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
callq 0xb38c
movq %rax, 0x38(%r14)
movq 0x38(%r14), %rax
movslq 0x20(%rbx), %rcx
movl %ebp, (%rax,%rcx,4)
movl 0x20(%rbx), %eax
cmpl 0x1c(%r14), %eax
jl 0x15977
leaq 0x1c(%r14), %rdx
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x48(%r14), %rsi
leaq 0xcc84(%rip), %r9       # 0x225e7
movl $0x4, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
callq 0xb38c
movq %rax, 0x48(%r14)
movq 0x10(%rbx), %rax
movl 0x8(%rax), %eax
movq 0x48(%r14), %rcx
movslq 0x20(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
movl 0x20(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_codek
int luaK_codek (FuncState *fs, int reg, int k) {
  if (k <= MAXARG_Bx)
    return luaK_codeABx(fs, OP_LOADK, reg, k);
  else {
    int p = luaK_codeABx(fs, OP_LOADKX, reg, 0);
    codeextraarg(fs, k);
    return p;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
shll $0x6, %esi
cmpl $0x3ffff, %edx          # imm = 0x3FFFF
jg 0x159bf
shll $0xe, %ebp
orl %ebp, %esi
orl $0x1, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x158de
orl $0x2, %esi
movq %rbx, %rdi
callq 0x158de
movl %eax, %r14d
shll $0x6, %ebp
orl $0x2e, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x158de
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_checkstack
void luaK_checkstack (FuncState *fs, int n) {
  int newstack = fs->freereg + n;
  if (newstack > fs->f->maxstacksize) {
    if (newstack >= MAXREGS)
      luaX_syntaxerror(fs->ls,
        "function or expression needs too many registers");
    fs->f->maxstacksize = cast_byte(newstack);
  }
}

// Assembly:
movzbl 0x3c(%rdi), %eax
addl %esi, %eax
movq (%rdi), %rcx
movzbl 0xc(%rcx), %edx
cmpl %edx, %eax
jle 0x15a00
cmpl $0xff, %eax
jge 0x15a01
movb %al, 0xc(%rcx)
retq
pushq %rax
movq 0x10(%rdi), %rdi
leaq 0xcb8f(%rip), %rsi      # 0x2259c
callq 0x16d86
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: addk
static int addk (FuncState *fs, TValue *key, TValue *v) {
  lua_State *L = fs->ls->L;
  Proto *f = fs->f;
  TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */
  int k, oldsize;
  if (ttisinteger(idx)) {  /* is there an index there? */
    k = cast_int(ivalue(idx));
    /* correct value? (warning: must distinguish floats from integers!) */
    if (k < fs->nk && ttype(&f->k[k]) == ttype(v) &&
                      luaV_rawequalobj(&f->k[k], v))
      return k;  /* reuse index */
  }
  /* constant not found; create a new entry */
  oldsize = f->sizek;
  k = fs->nk;
  /* numerical value does not need GC barrier;
     table has no metatable, so it does not need to invalidate cache */
  setivalue(idx, k);
  luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
  setobj(L, &f->k[k], v);
  fs->nk++;
  luaC_barrier(L, f, v);
  return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r13
movq (%rdi), %rbx
movq 0x10(%rdi), %rax
movq 0x38(%rax), %rdi
movq 0x50(%rax), %rsi
movq %rdi, 0x8(%rsp)
callq 0xfa25
movq %rax, %rbp
cmpl $0x13, 0x8(%rax)
jne 0x15aae
movq (%rbp), %rdx
cmpl %edx, 0x2c(%r13)
jle 0x15aae
movq 0x30(%rbx), %rsi
movslq %edx, %rax
shlq $0x4, %rax
movl 0x8(%r14), %ecx
xorl 0x8(%rsi,%rax), %ecx
testb $0x3f, %cl
je 0x15b6c
movq %r14, 0x10(%rsp)
leaq 0x14(%rbx), %r14
movslq 0x14(%rbx), %r12
movl 0x2c(%r13), %edi
movslq %edi, %r15
movq %r15, (%rbp)
movl $0x13, 0x8(%rbp)
cmpl 0x14(%rbx), %r15d
jl 0x15b00
movq 0x30(%rbx), %rsi
leaq 0xcb11(%rip), %r9       # 0x225ef
movl $0x10, %ecx
movq %rdi, %rbp
movq 0x8(%rsp), %rdi
movq %r14, %rdx
movl $0x3ffffff, %r8d        # imm = 0x3FFFFFF
callq 0xb38c
movq %rbp, %rdi
movq %rax, 0x30(%rbx)
movslq (%r14), %rax
cmpl %eax, %r12d
jge 0x15b29
movq 0x30(%rbx), %rcx
subq %r12, %rax
shlq $0x4, %r12
addq %r12, %rcx
addq $0x8, %rcx
movl $0x0, (%rcx)
addq $0x10, %rcx
decq %rax
jne 0x15b1a
movq 0x30(%rbx), %rax
shlq $0x4, %r15
movq 0x10(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax,%r15)
incl 0x2c(%r13)
testb $0x40, 0x8(%rcx)
je 0x15b87
testb $0x4, 0x9(%rbx)
je 0x15b87
movq (%rcx), %rdx
testb $0x3, 0x9(%rdx)
je 0x15b87
movq %rdi, %r14
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9ddc
movq %r14, %rdi
jmp 0x15b87
addq %rax, %rsi
movq %rdx, %r15
xorl %edi, %edi
movq %r14, %rdx
callq 0x11583
movq %r15, %rdi
testl %eax, %eax
je 0x15aae
movl %edi, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_intK
int luaK_intK (FuncState *fs, lua_Integer n) {
  TValue k, o;
  setpvalue(&k, cast(void*, cast(size_t, n)));
  setivalue(&o, n);
  return addk(fs, &k, &o);
}

// Assembly:
subq $0x28, %rsp
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movl $0x2, 0x8(%rax)
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movl $0x13, 0x8(%rdx)
movq %rax, %rsi
callq 0x15a4f
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_setreturns
void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
  if (e->k == VCALL) {  /* expression is an open function call? */
    SETARG_C(getinstruction(fs, e), nresults + 1);
  }
  else if (e->k == VVARARG) {
    Instruction *pc = &getinstruction(fs, e);
    SETARG_B(*pc, nresults + 1);
    SETARG_A(*pc, fs->freereg);
    luaK_reserveregs(fs, 1);
  }
  else lua_assert(nresults == LUA_MULTRET);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0xe, %eax
je 0x15c00
cmpl $0xd, %eax
jne 0x15c43
movq (%rbx), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0xff803fff, %esi       # imm = 0xFF803FFF
andl (%rax,%rcx,4), %esi
shll $0xe, %edx
addl $0x4000, %edx           # imm = 0x4000
andl $0x7fc000, %edx         # imm = 0x7FC000
orl %esi, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x15c43
movq (%rbx), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %esi         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %esi
shll $0x17, %edx
addl %esi, %edx
addl $0x800000, %edx         # imm = 0x800000
movl %edx, (%rax,%rcx,4)
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
movzbl 0x3c(%rbx), %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x159e5
incb 0x3c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_setoneret
void luaK_setoneret (FuncState *fs, expdesc *e) {
  if (e->k == VCALL) {  /* expression is an open function call? */
    /* already returns 1 value */
    lua_assert(GETARG_C(getinstruction(fs, e)) == 2);
    e->k = VNONRELOC;  /* result has fixed position */
    e->u.info = GETARG_A(getinstruction(fs, e));
  }
  else if (e->k == VVARARG) {
    SETARG_B(getinstruction(fs, e), 2);
    e->k = VRELOCABLE;  /* can relocate its simple result */
  }
}

// Assembly:
movl (%rsi), %eax
cmpl $0xe, %eax
je 0x15c6f
cmpl $0xd, %eax
jne 0x15c91
movl $0x7, (%rsi)
movq (%rdi), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rsi), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x6, %eax
movzbl %al, %eax
movl %eax, 0x8(%rsi)
retq
movq (%rdi), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %edx         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %edx
orl $0x1000000, %edx        # imm = 0x1000000
movl %edx, (%rax,%rcx,4)
movl $0xc, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_dischargevars
void luaK_dischargevars (FuncState *fs, expdesc *e) {
  switch (e->k) {
    case VLOCAL: {  /* already in a register */
      e->k = VNONRELOC;  /* becomes a non-relocatable value */
      break;
    }
    case VUPVAL: {  /* move value to some (pending) register */
      e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    case VINDEXED: {
      OpCode op;
      freereg(fs, e->u.ind.idx);
      if (e->u.ind.vt == VLOCAL) {  /* is 't' in a register? */
        freereg(fs, e->u.ind.t);
        op = OP_GETTABLE;
      }
      else {
        lua_assert(e->u.ind.vt == VUPVAL);
        op = OP_GETTABUP;  /* 't' is in an upvalue */
      }
      e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx);
      e->k = VRELOCABLE;
      break;
    }
    case VVARARG: case VCALL: {
      luaK_setoneret(fs, e);
      break;
    }
    default: break;  /* there is one value available (somewhere) */
  }
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
addl $-0x8, %eax
cmpl $0x6, %eax
ja 0x15d1c
movq %rsi, %rbx
leaq 0xc80d(%rip), %rcx      # 0x224b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rsi
popq %rbx
jmp 0x15c45
movswl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x15cce
movzbl 0x3a(%rdi), %ecx
cmpl %eax, %ecx
jg 0x15cce
decb 0x3c(%rdi)
movl $0x6, %eax
cmpb $0x8, 0xb(%rbx)
jne 0x15ce9
movb 0x3a(%rdi), %cl
movl $0x7, %eax
cmpb 0xa(%rbx), %cl
ja 0x15ce9
decb 0x3c(%rdi)
movzbl 0xa(%rbx), %ecx
movswl 0x8(%rbx), %esi
shll $0x17, %ecx
orl %eax, %ecx
shll $0xe, %esi
orl %ecx, %esi
jmp 0x15d0e
movl $0x7, (%rbx)
jmp 0x15d1c
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x5, %esi
callq 0x158de
movl %eax, 0x8(%rbx)
movl $0xc, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_exp2nextreg
void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
  luaK_dischargevars(fs, e);
  freeexp(fs, e);
  luaK_reserveregs(fs, 1);
  exp2reg(fs, e, fs->freereg - 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15c92
cmpl $0x7, (%rbx)
jne 0x15d48
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x15d48
movzbl 0x3a(%r14), %ecx
cmpl %ecx, %eax
jl 0x15d48
decb 0x3c(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x159e5
movb 0x3c(%r14), %al
incb %al
movb %al, 0x3c(%r14)
movzbl %al, %edx
decl %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15d73
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: exp2reg
static void exp2reg (FuncState *fs, expdesc *e, int reg) {
  discharge2reg(fs, e, reg);
  if (e->k == VJMP)  /* expression itself is a test? */
    luaK_concat(fs, &e->t, e->u.info);  /* put this jump in 't' list */
  if (hasjumps(e)) {
    int final;  /* position after whole expression */
    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
    if (need_value(fs, e->t) || need_value(fs, e->f)) {
      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
      p_f = code_loadbool(fs, reg, 0, 1);
      p_t = code_loadbool(fs, reg, 1, 0);
      luaK_patchtohere(fs, fj);
    }
    final = luaK_getlabel(fs);
    patchlistaux(fs, e->f, final, reg, p_f);
    patchlistaux(fs, e->t, final, reg, p_t);
  }
  e->f = e->t = NO_JUMP;
  e->u.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16a71
cmpl $0xb, (%rbx)
jne 0x15d9f
leaq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x156f5
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %r15d
cmpl %r15d, %esi
je 0x15e69
movq %r14, %rdi
callq 0x16b7b
testl %eax, %eax
jne 0x15dce
movq %r14, %rdi
movl %r15d, %esi
callq 0x16b7b
testl %eax, %eax
je 0x15e89
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0xb, (%rbx)
je 0x15de4
movq %r14, %rdi
callq 0x1577c
movl %eax, %r15d
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
movl %ebp, %r12d
shll $0x6, %r12d
movl %r12d, %esi
orl $0x4003, %esi           # imm = 0x4003
movq %r14, %rdi
callq 0x158de
movl %eax, %r13d
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
orl $0x800003, %r12d        # imm = 0x800003
movq %r14, %rdi
movl %r12d, %esi
callq 0x158de
movl %eax, %r12d
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
leaq 0x28(%r14), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x156f5
movl 0x20(%r14), %r15d
movl %r15d, 0x24(%r14)
movl 0x14(%rbx), %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movl %r13d, %r8d
callq 0x1581e
movl 0x10(%rbx), %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x1581e
movq $-0x1, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movl $0x7, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x15e3b
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_exp2anyreg
int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
  luaK_dischargevars(fs, e);
  if (e->k == VNONRELOC) {  /* expression already has a register? */
    if (!hasjumps(e))  /* no jumps? */
      return e->u.info;  /* result is already in a register */
    if (e->u.info >= fs->nactvar) {  /* reg. is not a local? */
      exp2reg(fs, e, e->u.info);  /* put final result in it */
      return e->u.info;
    }
  }
  luaK_exp2nextreg(fs, e);  /* otherwise, use next available register */
  return e->u.info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15c92
cmpl $0x7, (%rbx)
jne 0x15ec4
movl 0x10(%rbx), %eax
leaq 0x8(%rbx), %r15
cmpl 0x14(%rbx), %eax
je 0x15ed6
movl (%r15), %edx
movzbl 0x3a(%r14), %eax
cmpl %eax, %edx
jge 0x15edf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15d1e
addq $0x8, %rbx
movq %rbx, %r15
movl (%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15d73
jmp 0x15ed6