LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21ac0
movq -0x18(%rbp), %rcx
movl %eax, (%rcx)
movl %eax, -0x1c(%rbp)
cmpl $0x23, -0x1c(%rbp)
jne 0x20fd4
jmp 0x20f8a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54c0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x20faf
cmpl $0xa, -0x1c(%rbp)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x20f8a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x20fdb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x2102f
movq -0x28(%rbp), %rax
movslq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0x21074
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52c0
cmpl $0x0, %eax
je 0x2104b
movq $0x0, -0x8(%rbp)
jmp 0x21080
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x50e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x11(%rip), %rsi        # 0x210e0
leaq -0x38(%rbp), %rdx
callq 0x8410
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2110d
movq $0x0, -0x8(%rbp)
jmp 0x21133
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7680
cmpl $0x0, %eax
jne 0x211bd
movl $0x0, -0x4(%rbp)
jmp 0x21218
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6ce0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7440
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x211f1
movq -0x10(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x5dc0
jmp 0x21212
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5e60
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5d40
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x21190
cmpl $0x0, %eax
jne 0x21270
movl $0x0, -0x4(%rbp)
jmp 0x2129b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6190
movq -0x10(%rbp), %rdi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
movq %r8, %rcx
callq 0x8140
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x88c0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq -0x1c(%rbp), %rdx
callq 0x66e0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x212f9
movq -0x8(%rbp), %rdi
leaq 0x14421(%rip), %rsi     # 0x35713
movb $0x0, %al
callq 0x1fbf0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x143f2(%rip), %rdx     # 0x35733
callq 0x21230
cmpl $0x0, %eax
jne 0x21498
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x61f0
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x21446
movq -0x20(%rbp), %rax
leaq 0x14287(%rip), %rcx     # 0x355fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x213be
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66e0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x14389(%rip), %rsi     # 0x3573e
movb $0x0, %al
callq 0x6de0
jmp 0x213e8
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6650
movq -0x30(%rbp), %rdi
leaq 0x1440a(%rip), %rsi     # 0x357eb
movb $0x1, %al
callq 0x6de0
jmp 0x21496
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6190
jmp 0x21496
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6770
movq -0x38(%rbp), %rdi
movl %eax, %ecx
leaq 0x14327(%rip), %rsi     # 0x35746
leaq 0x1431b(%rip), %rax     # 0x35741
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x6ce0
jmp 0x21496
movq -0x8(%rbp), %rdi
leaq 0x13cb0(%rip), %rsi     # 0x350ef
callq 0x6ce0
jmp 0x21496
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x61f0
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x6240
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6aa0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
leaq 0x142bd(%rip), %rsi     # 0x3574c
movb $0x0, %al
callq 0x6de0
jmp 0x21498
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x67d0
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x14282(%rip), %rdx     # 0x35753
callq 0x1f930
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x21544
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x21508
movq -0x8(%rbp), %rdi
xorl %esi, %esi
subl -0x14(%rbp), %esi
callq 0x6190
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x214e7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x6ea0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x2, %eax
xorl %esi, %esi
subl %eax, %esi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x7ae0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x214d6
movq -0x8(%rbp), %rdi
xorl %esi, %esi
subl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x5dc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x72f0
cmpl $0x5, %eax
jne 0x21591
movl $0x1, -0x4(%rbp)
jmp 0x215e0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5d40
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x75e0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6190
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x7ae0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x1414e(%rip), %rdx     # 0x35765
callq 0x21560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x72f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6770
cmpl $0x0, %eax
jne 0x216a3
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x6ea0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6ce0
movq -0x8(%rbp), %rdi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
movq %r8, %rcx
callq 0x8140
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7ae0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5e60
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
cmpl $0x0, -0x1c(%rbp)
je 0x216e5
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x77e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5150
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2050(%rbp), %rsi
callq 0x20aa0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54d0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x21778
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
leaq -0x2050(%rbp), %rdi
callq 0x208a0
movq -0x20(%rbp), %rsi
leaq -0x2050(%rbp), %rdi
callq 0x20900
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x21728
movq -0x10(%rbp), %rsi
leaq -0x2050(%rbp), %rdi
callq 0x20900
leaq -0x2050(%rbp), %rdi
callq 0x20940
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x67d0
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x21822
movq -0x18(%rbp), %rdi
callq 0x5040
movq $0x0, -0x8(%rbp)
jmp 0x21833
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x53c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d00
movq %rax, -0x20(%rbp)
cmpq $0x88, -0x18(%rbp)
je 0x218de
movq -0x8(%rbp), %rdi
leaq 0x13e96(%rip), %rsi     # 0x3576d
movb $0x0, %al
callq 0x1fbf0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x5d00
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x2190f
movq -0x8(%rbp), %rdi
leaq 0x13e98(%rip), %rsi     # 0x3579e
movb $0x0, %al
callq 0x1fbf0
jmp 0x21943
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jne 0x21922
jp 0x21922
jmp 0x21941
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
leaq 0x13e7e(%rip), %rsi     # 0x357b8
movb $0x2, %al
callq 0x1fbf0
jmp 0x21943
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2197b
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x61f0
cmpl $0x5, %eax
je 0x21987
movl $0x0, -0x4(%rbp)
jmp 0x21a7e
movq -0x10(%rbp), %rdi
callq 0x6b60
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x87b0
cmpl $0x0, %eax
je 0x21a77
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x61f0
cmpl $0x4, %eax
jne 0x21a64
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6410
cmpl $0x0, %eax
je 0x219ee
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movl $0x1, -0x4(%rbp)
jmp 0x21a7e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x21950
cmpl $0x0, %eax
je 0x21a60
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5e60
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x10(%rbp), %rdi
leaq 0x13bf8(%rip), %rsi     # 0x35629
callq 0x6ce0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5e60
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x8820
movl $0x1, -0x4(%rbp)
jmp 0x21a7e
jmp 0x21a62
jmp 0x21a64
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
jmp 0x21990
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: skipBOM
static int skipBOM (LoadF *lf) {
  const char *p = "\xEF\xBB\xBF";  /* UTF-8 BOM mark */
  int c;
  lf->n = 0;
  do {
    c = getc(lf->f);
    if (c == EOF || c != *(const unsigned char *)p++) return c;
    lf->buff[lf->n++] = c;  /* to be read by the parser */
  } while (*p != '\0');
  lf->n = 0;  /* prefix matched; discard it */
  return getc(lf->f);  /* return next character */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x13dd9(%rip), %rax     # 0x358ac
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54c0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x21b10
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x21b18
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21b5b
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, 0x10(%rax,%rcx)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x21ae1
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2058d(%rip), %rax     # 0x42110
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x21bcb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x1, %ecx
callq 0x215f0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x21b87
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jle 0x21cff
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x0, %eax
andl $0x3f, %eax
cmpl $0x4, %eax
jne 0x21cfd
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x6, %eax
andl $0xff, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x17, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x21c87
movl -0xc(%rbp), %eax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0x21c9c
movl -0xc(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x21cfb
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x21cfb
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x21caa
movl -0x20(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x21cb8
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xffffc03f, %ecx       # imm = 0xFFFFC03F
movl -0xc(%rbp), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffff, %ecx         # imm = 0x7FFFFF
movl -0x1c(%rbp), %eax
subl -0xc(%rbp), %eax
shll $0x17, %eax
andl $0xff800000, %eax       # imm = 0xFF800000
orl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x21d19
jmp 0x21cfd
jmp 0x21cff
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl $0x4, %esi
xorl %r8d, %r8d
callq 0x21d20
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x21d8b
jmp 0x21dd5
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x21d9f
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x21dd3
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x21de0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x21dc4
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x21da8
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x21e30
jmp 0x21dd5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: getjump
static int getjump (FuncState *fs, int pc) {
  int offset = GETARG_sBx(fs->f->code[pc]);
  if (offset == NO_JUMP)  /* point to itself represents end of list */
    return NO_JUMP;  /* end of list */
  else
    return (pc+1)+offset;  /* turn offset into absolute position */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0xe, %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
subl $0x1ffff, %eax          # imm = 0x1FFFF
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x21e1c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21e28
movl -0x14(%rbp), %eax
addl $0x1, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x1ffff, %eax          # imm = 0x1FFFF
jle 0x21e8f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x13bf7(%rip), %rsi     # 0x35a81
callq 0x24390
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
movl -0x1c(%rbp), %eax
addl $0x1ffff, %eax          # imm = 0x1FFFF
shll $0xe, %eax
andl $0xffffc000, %eax       # imm = 0xFFFFC000
orl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl $0x1e, %esi
xorl %edx, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x21f20
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0x10(%rbp), %rsi
callq 0x21d70
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x2202c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x21fc0
jmp 0x22044
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x10(%rbp), %r8d
movl $0xff, %ecx
callq 0x22050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x220ba
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x21de0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x23c20
cmpl $0x0, %eax
je 0x220a3
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x21e30
jmp 0x220b2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x21e30
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x22069
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x22129
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
movl -0x10(%rbp), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x21de0
movl %eax, -0xc(%rbp)
jmp 0x220db
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x23d50
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jle 0x221a4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x18, %rdx
movl $0x4, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
leaq 0x13908(%rip), %r9      # 0x35a9c
callq 0x10070
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x20(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x2220b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x1c, %rdx
movl $0x4, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
leaq 0x138a1(%rip), %r9      # 0x35a9c
callq 0x10070
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x20(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x20(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x3ffff, -0x18(%rbp)   # imm = 0x3FFFF
jg 0x22274
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl $0x1, %esi
callq 0x21f20
movl %eax, -0x4(%rbp)
jmp 0x2229c
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x21f20
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x222b0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3c(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0xc(%rcx), %ecx
cmpl %ecx, %eax
jle 0x2233b
cmpl $0xff, -0x10(%rbp)
jl 0x2232c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x13715(%rip), %rsi     # 0x35a3c
callq 0x24390
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb %cl, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x2, 0x8(%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl $0x13, 0x8(%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x223f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xd, (%rax)
jne 0x226d3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0xff803fff, %edx       # imm = 0xFF803FFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
shll $0xe, %eax
andl $0x7fc000, %eax         # imm = 0x7FC000
orl %eax, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x22754
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x22750
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffff, %ecx         # imm = 0x7FFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
shll $0x17, %eax
andl $0xff800000, %eax       # imm = 0xFF800000
orl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xffffc03f, %ecx       # imm = 0xFFFFC03F
movq -0x8(%rbp), %rax
movzbl 0x3c(%rax), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x22350
jmp 0x22752
jmp 0x22752
jmp 0x22754
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xd, (%rax)
jne 0x227a7
movq -0x10(%rbp), %rax
movl $0x7, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %ecx
shrl $0x6, %ecx
andl $0xff, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x227f4
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x227f2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
orl $0x1000000, %edx        # imm = 0x1000000
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl $0xc, (%rax)
jmp 0x227f4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x6, %eax
ja 0x22900
movq -0x20(%rbp), %rax
leaq 0x130cd(%rip), %rcx     # 0x35900
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl $0x7, (%rax)
jmp 0x22902
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x5, %esi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x21d20
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0xc, (%rax)
jmp 0x22902
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %esi
callq 0x22910
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x8, %eax
jne 0x228b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %esi
callq 0x22910
movl $0x7, -0x14(%rbp)
jmp 0x228bd
movl $0x6, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %ecx
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %r8d
xorl %edx, %edx
callq 0x21d20
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0xc, (%rax)
jmp 0x22902
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22760
jmp 0x22902
jmp 0x22902
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22800
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x229b0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x22350
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movzbl 0x3c(%rax), %edx
subl $0x1, %edx
callq 0x229e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)