LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_newstring
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
  lua_State *L = ls->L;
  TValue *o;  /* entry for 'str' */
  TString *ts = luaS_newlstr(L, str, l);  /* create new string */
  setsvalue2s(L, L->top++, ts);  /* temporarily anchor it in stack */
  o = luaH_set(L, ls->h, L->top - 1);
  if (ttisnil(o)) {  /* not in use yet? */
    /* boolean value does not need GC barrier;
       table has no metatable, so it does not need to invalidate cache */
    setbvalue(o, 1);  /* t[string] = true */
    luaC_checkGC(L);
  }
  else {  /* string already present */
    ts = tsvalue(keyfromval(o));  /* re-use value previously stored */
  }
  L->top--;  /* remove string from stack */
  return ts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16890
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movzbl 0x8(%rax), %ecx
orl $0x40, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
addq $-0x10, %rdx
callq 0x17480
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x24523
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movq -0x48(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
jle 0x24521
movq -0x20(%rbp), %rdi
callq 0xe0b0
jmp 0x2452f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_setinput
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
                    int firstchar) {
  ls->t.token = 0;
  ls->L = L;
  ls->current = firstchar;
  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
  ls->z = z;
  ls->fs = NULL;
  ls->linenumber = 1;
  ls->lastline = 1;
  ls->source = source;
  ls->envn = luaS_newliteral(L, LUA_ENV);  /* get env name */
  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x121, 0x20(%rax)      # imm = 0x121
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rdi
leaq 0xff79(%rip), %rsi      # 0x34555
movl $0x4, %edx
callq 0x16890
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
movl $0x20, %ecx
callq 0x10130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq $0x20, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_next
void luaX_next (LexState *ls) {
  ls->lastline = ls->linenumber;
  if (ls->lookahead.token != TK_EOS) {  /* is there a look-ahead token? */
    ls->t = ls->lookahead;  /* use this one */
    ls->lookahead.token = TK_EOS;  /* and discharge it */
  }
  else
    ls->t.token = llex(ls, &ls->t.seminfo);  /* read next token */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x121, 0x20(%rax)      # imm = 0x121
je 0x2469c
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x121, 0x20(%rax)      # imm = 0x121
jmp 0x246ba
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
callq 0x246c0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: txtToken
static const char *txtToken (LexState *ls, int token) {
  switch (token) {
    case TK_NAME: case TK_STRING:
    case TK_FLT: case TK_INT:
      save(ls, '\0');
      return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff));
    default:
      return luaX_token2str(ls, token);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0xfffffede, %eax       # imm = 0xFFFFFEDE
subl $0x3, %eax
ja 0x24fd0
jmp 0x24f9e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x24ff0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdx
leaq 0x126b6(%rip), %rsi     # 0x37679
movb $0x0, %al
callq 0x114b0
movq %rax, -0x8(%rbp)
jmp 0x24fe0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x24300
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: save
static void save (LexState *ls, int c) {
  Mbuffer *b = ls->buff;
  if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
    size_t newsize;
    if (luaZ_sizebuffer(b) >= MAX_SIZE/2)
      lexerror(ls, "lexical element too long", 0);
    newsize = luaZ_sizebuffer(b) * 2;
    luaZ_resizebuffer(ls->L, b, newsize);
  }
  b->buffer[luaZ_bufflen(b)++] = cast(char, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x25094
movq -0x18(%rbp), %rax
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
jb 0x25047
movq -0x8(%rbp), %rdi
leaq 0x10fe7(%rip), %rsi     # 0x36027
xorl %edx, %edx
callq 0x243c0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
movq -0x20(%rbp), %rcx
shlq $0x0, %rcx
callq 0x10130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: inclinenumber
static void inclinenumber (LexState *ls) {
  int old = ls->current;
  lua_assert(currIsNewline(ls));
  next(ls);  /* skip '\n' or '\r' */
  if (currIsNewline(ls) && ls->current != old)
    next(ls);  /* skip '\n\r' or '\r\n' */
  if (++ls->linenumber >= MAX_INT)
    lexerror(ls, "chunk has too many lines", 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x2510f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x2511f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1f490
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0xa, (%rax)
je 0x2513a
movq -0x8(%rbp), %rax
cmpl $0xd, (%rax)
jne 0x25198
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x25198
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x2517f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x2518f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1f490
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jl 0x251be
movq -0x8(%rbp), %rdi
leaq 0x10ea7(%rip), %rsi     # 0x3605e
xorl %edx, %edx
callq 0x243c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: skip_sep
static int skip_sep (LexState *ls) {
  int count = 0;
  int s = ls->current;
  lua_assert(s == '[' || s == ']');
  save_and_next(ls);
  while (ls->current == '=') {
    save_and_next(ls);
    count++;
  }
  return (ls->current == s) ? count : (-count) - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x24ff0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x25235
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x25245
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1f490
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x3d, (%rax)
jne 0x252c4
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x24ff0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x252a0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x252b0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1f490
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2524e
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x252d7
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x252e2
xorl %eax, %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: check_next1
static int check_next1 (LexState *ls, int c) {
  if (ls->current == c) {
    next(ls);
    return 1;
  }
  else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x25656
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x25634
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x25644
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1f490
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2565d
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/llex.c
// Function: readhexaesc
static int readhexaesc (LexState *ls) {
  int r = gethexa(ls);
  r = (r << 4) + gethexa(ls);
  luaZ_buffremove(ls->buff, 2);  /* remove saved chars from buffer */
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25ff0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25ff0
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rcx
subq $0x2, %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: utf8esc
static void utf8esc (LexState *ls) {
  char buff[UTF8BUFFSZ];
  int n = luaO_utf8esc(buff, readutf8esc(ls));
  for (; n > 0; n--)  /* add 'buff' to string */
    save(ls, buff[UTF8BUFFSZ - n]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x260a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x10cb0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x25e25
movq -0x8(%rbp), %rdi
movl $0x8, %eax
subl -0x14(%rbp), %eax
cltq
movsbl -0x10(%rbp,%rax), %esi
callq 0x24ff0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25dfc
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: esccheck
static void esccheck (LexState *ls, int c, const char *msg) {
  if (!c) {
    if (ls->current != EOZ)
      save_and_next(ls);  /* add current to buffer for error message */
    lexerror(ls, msg, TK_STRING);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x25ec6
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x25eb4
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x24ff0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x25e9b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x25eab
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1f490
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x125, %edx            # imm = 0x125
callq 0x243c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: readdecesc
static int readdecesc (LexState *ls) {
  int i;
  int r = 0;  /* result accumulator */
  for (i = 0; i < 3 && lisdigit(ls->current); i++) {  /* read up to 3 digits */
    r = 10*r + ls->current - '0';
    save_and_next(ls);
  }
  esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
  luaZ_buffremove(ls->buff, i);  /* remove read digits from buffer */
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x3, -0xc(%rbp)
movb %al, -0x11(%rbp)
jge 0x25f18
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0xfba8(%rip), %rax      # 0x35ab0
movzbl (%rax,%rcx), %eax
andl $0x2, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x25f24
jmp 0x25fa4
imull $0xa, -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
addl (%rcx), %eax
subl $0x30, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x24ff0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x25f7d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x25f8d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1f490
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x25eea
movq -0x8(%rbp), %rdi
cmpl $0xff, -0x10(%rbp)
setle %al
andb $0x1, %al
movzbl %al, %esi
leaq 0x1015d(%rip), %rdx     # 0x3611b
callq 0x25e30
movslq -0xc(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: check_next2
static int check_next2 (LexState *ls, const char *set) {
  lua_assert(set[2] == '\0');
  if (ls->current == set[0] || ls->current == set[1]) {
    save_and_next(ls);
    return 1;
  }
  else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x262e3
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x2634e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x24ff0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x2632c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2633c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1f490
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x26355
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaopen_base
LUAMOD_API int luaopen_base (lua_State *L) {
  /* open lib into global table */
  lua_pushglobaltable(L);
  luaL_setfuncs(L, base_funcs, 0);
  /* set global _G */
  lua_pushvalue(L, -1);
  lua_setfield(L, -2, "_G");
  /* set global _VERSION */
  lua_pushliteral(L, LUA_VERSION);
  lua_setfield(L, -2, "_VERSION");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl $0x2, %edx
callq 0x74c0
movq -0x8(%rbp), %rdi
leaq 0x1bf66(%rip), %rsi     # 0x422f0
xorl %edx, %edx
callq 0x214b0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6190
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xf533(%rip), %rdx      # 0x358e2
callq 0x7ae0
movq -0x8(%rbp), %rdi
leaq 0xfda1(%rip), %rsi      # 0x36160
callq 0x6ce0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xfd94(%rip), %rdx      # 0x36168
callq 0x7ae0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_assert
static int luaB_assert (lua_State *L) {
  if (lua_toboolean(L, 1))  /* condition is true? */
    return lua_gettop(L);  /* return all arguments */
  else {  /* error */
    luaL_checkany(L, 1);  /* there must be a condition */
    lua_remove(L, 1);  /* remove it */
    lua_pushliteral(L, "assertion failed!");  /* default message */
    lua_settop(L, 1);  /* leave only message (default if no other one) */
    return luaB_error(L);  /* call 'error' */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6770
cmpl $0x0, %eax
je 0x2641d
movq -0x10(%rbp), %rdi
callq 0x5d90
movl %eax, -0x4(%rbp)
jmp 0x26476
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5e60
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x10(%rbp), %rdi
leaq 0xfda1(%rip), %rsi      # 0x361f8
callq 0x6ce0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
callq 0x26610
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_collectgarbage
static int luaB_collectgarbage (lua_State *L) {
  static const char *const opts[] = {"stop", "restart", "collect",
    "count", "step", "setpause", "setstepmul",
    "isrunning", NULL};
  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
    LUA_GCISRUNNING};
  int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
  int ex = (int)luaL_optinteger(L, 2, 0);
  int res = lua_gc(L, o, ex);
  switch (o) {
    case LUA_GCCOUNT: {
      int b = lua_gc(L, LUA_GCCOUNTB, 0);
      lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));
      return 1;
    }
    case LUA_GCSTEP: case LUA_GCISRUNNING: {
      lua_pushboolean(L, res);
      return 1;
    }
    default: {
      lua_pushinteger(L, res);
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xfd80(%rip), %rdx      # 0x36217
leaq 0x1bfe2(%rip), %rcx     # 0x42480
movl $0x1, %esi
callq 0x20230
movslq %eax, %rcx
leaq 0xfeae(%rip), %rax      # 0x36360
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %esi
callq 0x205e0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x85d0
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x26500
jmp 0x264ec
movl -0x24(%rbp), %eax
subl $0x5, %eax
je 0x2653f
jmp 0x264f6
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0x2653f
jmp 0x26554
movq -0x10(%rbp), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x85d0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
cvtsi2sdl -0x1c(%rbp), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
movsd 0xfc2f(%rip), %xmm2     # 0x36158
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
callq 0x6b90
movl $0x1, -0x4(%rbp)
jmp 0x26568
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6fc0
movl $0x1, -0x4(%rbp)
jmp 0x26568
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6be0
movl $0x1, -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/lbaselib.c
// Function: luaB_dofile
static int luaB_dofile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  lua_settop(L, 1);
  if (luaL_loadfile(L, fname) != LUA_OK)
    return lua_error(L);
  lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
  return dofilecont(L, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x20310
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x20c80
cmpl $0x0, %eax
je 0x265d7
movq -0x10(%rbp), %rdi
callq 0x8790
movl %eax, -0x4(%rbp)
jmp 0x26604
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
leaq 0xbf3(%rip), %r8        # 0x271e0
callq 0x8140
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x271e0
movl %eax, -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/lbaselib.c
// Function: luaB_error
static int luaB_error (lua_State *L) {
  int level = (int)luaL_optinteger(L, 2, 1);
  lua_settop(L, 1);
  if (lua_type(L, 1) == LUA_TSTRING && level > 0) {
    luaL_where(L, level);   /* add extra information */
    lua_pushvalue(L, 1);
    lua_concat(L, 2);
  }
  return lua_error(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x205e0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x4, %eax
jne 0x26681
cmpl $0x0, -0xc(%rbp)
jle 0x26681
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1fdc0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6190
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x8820
movq -0x8(%rbp), %rdi
callq 0x8790
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_getmetatable
static int luaB_getmetatable (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_getmetatable(L, 1)) {
    lua_pushnil(L);
    return 1;  /* no metatable */
  }
  luaL_getmetafield(L, 1, "__metatable");
  return 1;  /* returns either __metatable field (if present) or metatable */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7680
cmpl $0x0, %eax
jne 0x266cf
movq -0x10(%rbp), %rdi
callq 0x6b60
movl $0x1, -0x4(%rbp)
jmp 0x266eb
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0xfb69(%rip), %rdx      # 0x36248
callq 0x21190
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_ipairs
static int luaB_ipairs (lua_State *L) {
#if defined(LUA_COMPAT_IPAIRS)
  return pairsmeta(L, "__ipairs", 1, ipairsaux);
#else
  luaL_checkany(L, 1);
  lua_pushcfunction(L, ipairsaux);  /* iteration function */
  lua_pushvalue(L, 1);  /* state */
  lua_pushinteger(L, 0);  /* initial value */
  return 3;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
leaq 0xaeb(%rip), %rsi       # 0x27210
xorl %edx, %edx
callq 0x6ea0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6190
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6be0
movl $0x3, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_loadfile
static int luaB_loadfile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  const char *mode = luaL_optstring(L, 2, NULL);
  int env = (!lua_isnone(L, 3) ? 3 : 0);  /* 'env' index or 0 if no 'env' */
  int status = luaL_loadfilex(L, fname, mode);
  return load_aux(L, status, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x20310
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x20310
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x61f0
cmpl $-0x1, %eax
sete %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x3, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x20c80
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x27270
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_load
static int luaB_load (lua_State *L) {
  int status;
  size_t l;
  const char *s = lua_tolstring(L, 1, &l);
  const char *mode = luaL_optstring(L, 3, "bt");
  int env = (!lua_isnone(L, 4) ? 4 : 0);  /* 'env' index or 0 if no 'env' */
  if (s != NULL) {  /* loading a string? */
    const char *chunkname = luaL_optstring(L, 2, s);
    status = luaL_loadbufferx(L, s, l, chunkname, mode);
  }
  else {  /* loading from a reader function */
    const char *chunkname = luaL_optstring(L, 2, "=(load)");
    luaL_checktype(L, 1, LUA_TFUNCTION);
    lua_settop(L, RESERVEDSLOT);  /* create reserved slot */
    status = lua_load(L, generic_reader, NULL, chunkname, mode);
  }
  return load_aux(L, status, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x67d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
leaq 0xfa32(%rip), %rdx      # 0x36254
xorl %eax, %eax
movl %eax, %ecx
callq 0x20310
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x61f0
cmpl $-0x1, %eax
sete %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x4, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26895
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x20310
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x21090
movl %eax, -0xc(%rbp)
jmp 0x268f2
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xf9b2(%rip), %rdx      # 0x36257
xorl %eax, %eax
movl %eax, %ecx
callq 0x20310
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0xa1a(%rip), %rsi       # 0x27300
xorl %eax, %eax
movl %eax, %edx
callq 0x8410
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x27270
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_next
static int luaB_next (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
  if (lua_next(L, 1))
    return 2;
  else {
    lua_pushnil(L);
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x203e0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x87b0
cmpl $0x0, %eax
je 0x26959
movl $0x2, -0x4(%rbp)
jmp 0x26969
movq -0x10(%rbp), %rdi
callq 0x6b60
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_pcall
static int luaB_pcall (lua_State *L) {
  int status;
  luaL_checkany(L, 1);
  lua_pushboolean(L, 1);  /* first result if no errors */
  lua_insert(L, 1);  /* put it in place */
  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
  return finishpcall(L, status, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6fc0
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x5e60
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
movq -0x18(%rbp), %rdi
movl %eax, %esi
subl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
leaq 0xa9b(%rip), %r9        # 0x274b0
callq 0x8210
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x274b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_print
static int luaB_print (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    size_t l;
    lua_pushvalue(L, -1);  /* function to be called */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tolstring(L, -1, &l);  /* get result */
    if (s == NULL)
      return luaL_error(L, "'tostring' must return a string to 'print'");
    if (i>1) lua_writestring("\t", 1);
    lua_writestring(s, l);
    lua_pop(L, 1);  /* pop result */
  }
  lua_writeline();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d90
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xecd2(%rip), %rsi      # 0x35735
callq 0x70b0
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x26b40
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6190
movq -0x10(%rbp), %rdi
movl -0x18(%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
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rdx
callq 0x67d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x26ae4
movq -0x10(%rbp), %rdi
leaq 0xf7d1(%rip), %rsi      # 0x362a6
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x26b74
cmpl $0x1, -0x18(%rbp)
jle 0x26b08
movq 0x1c4d7(%rip), %rax     # 0x42fc8
movq (%rax), %rcx
leaq 0xf7d6(%rip), %rdi      # 0x362d1
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5470
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq 0x1c4b1(%rip), %rax     # 0x42fc8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x5470
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26a6f
movq 0x1c481(%rip), %rax     # 0x42fc8
movq (%rax), %rcx
leaq 0xdb8a(%rip), %rdi      # 0x346db
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5470
movq 0x1c463(%rip), %rax     # 0x42fc8
movq (%rax), %rdi
callq 0x5340
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawequal
static int luaB_rawequal (lua_State *L) {
  luaL_checkany(L, 1);
  luaL_checkany(L, 2);
  lua_pushboolean(L, lua_rawequal(L, 1, 2));
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x20470
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x6410
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x6fc0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawlen
static int luaB_rawlen (lua_State *L) {
  int t = lua_type(L, 1);
  luaL_argcheck(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
                   "table or string expected");
  lua_pushinteger(L, lua_rawlen(L, 1));
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
movl %eax, -0xc(%rbp)
movb $0x1, %al
cmpl $0x5, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x26c31
movb $0x1, %al
cmpl $0x4, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x26c31
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xf6b0(%rip), %rdx      # 0x362d3
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x68c0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x6be0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawget
static int luaB_rawget (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checkany(L, 2);
  lua_settop(L, 2);
  lua_rawget(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7440
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawset
static int luaB_rawset (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checkany(L, 2);
  luaL_checkany(L, 3);
  lua_settop(L, 3);
  lua_rawset(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7c90
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_select
static int luaB_select (lua_State *L) {
  int n = lua_gettop(L);
  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
    lua_pushinteger(L, n-1);
    return 1;
  }
  else {
    lua_Integer i = luaL_checkinteger(L, 1);
    if (i < 0) i = n + i;
    else if (i > n) i = n;
    luaL_argcheck(L, 1 <= i, 1, "index out of range");
    return n - (int)i;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d90
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x4, %eax
jne 0x26da0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x67d0
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x26da0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x6be0
movl $0x1, -0x4(%rbp)
jmp 0x26e1b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x20550
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x26dc7
movslq -0x14(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x26dde
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jle 0x26ddc
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x26dde
movb $0x1, %al
movl $0x1, %ecx
cmpq -0x20(%rbp), %rcx
movb %al, -0x21(%rbp)
jle 0x26e0c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0xf4ee(%rip), %rdx      # 0x362ec
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
subl %ecx, %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/lbaselib.c
// Function: luaB_setmetatable
static int luaB_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  if (luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL)
    return luaL_error(L, "cannot change a protected metatable");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x61f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x203e0
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x26e94
movb $0x1, %al
cmpl $0x5, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x26e94
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0xf479(%rip), %rdx      # 0x362ff
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0xf3a1(%rip), %rdx      # 0x36248
callq 0x21190
cmpl $0x0, %eax
je 0x26ec8
movq -0x10(%rbp), %rdi
leaq 0xf459(%rip), %rsi      # 0x36315
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x26eeb
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7ef0
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/lbaselib.c
// Function: luaB_tonumber
static int luaB_tonumber (lua_State *L) {
  if (lua_isnoneornil(L, 2)) {  /* standard conversion? */
    luaL_checkany(L, 1);
    if (lua_type(L, 1) == LUA_TNUMBER) {  /* already a number? */
      lua_settop(L, 1);  /* yes; return it */
      return 1;
    }
    else {
      size_t l;
      const char *s = lua_tolstring(L, 1, &l);
      if (s != NULL && lua_stringtonumber(L, s) == l + 1)
        return 1;  /* successful conversion to number */
      /* else not a number */
    }
  }
  else {
    size_t l;
    const char *s;
    lua_Integer n = 0;  /* to avoid warnings */
    lua_Integer base = luaL_checkinteger(L, 2);
    luaL_checktype(L, 1, LUA_TSTRING);  /* no numbers as strings */
    s = lua_tolstring(L, 1, &l);
    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
    if (b_str2int(s, (int)base, &n) == s + l) {
      lua_pushinteger(L, n);
      return 1;
    }  /* else not a number */
  }  /* else not a number */
  lua_pushnil(L);  /* not a number */
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x61f0
cmpl $0x0, %eax
jg 0x26fa8
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x3, %eax
jne 0x26f5e
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
movl $0x1, -0x4(%rbp)
jmp 0x2706b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x67d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26fa1
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6600
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x26fa1
movl $0x1, -0x4(%rbp)
jmp 0x2706b
jmp 0x26fa3
jmp 0x2705b
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x20550
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x203e0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0x67d0
movq %rax, -0x30(%rbp)
movl $0x2, %eax
cmpq -0x40(%rbp), %rax
jg 0x27002
movb $0x1, %al
cmpq $0x24, -0x40(%rbp)
movb %al, -0x41(%rbp)
jle 0x27020
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0xf327(%rip), %rdx      # 0x36339
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %esi
leaq -0x38(%rbp), %rdx
callq 0x27510
movq -0x30(%rbp), %rcx
addq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x27059
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6be0
movl $0x1, -0x4(%rbp)
jmp 0x2706b
jmp 0x2705b
movq -0x10(%rbp), %rdi
callq 0x6b60
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_type
static int luaB_type (lua_State *L) {
  int t = lua_type(L, 1);
  luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
  lua_pushstring(L, lua_typename(L, t));
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
movl %eax, -0xc(%rbp)
movb $0x1, %al
cmpl $-0x1, -0xc(%rbp)
movb %al, -0xd(%rbp)
jne 0x27106
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xe5e6(%rip), %rdx      # 0x356de
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6240
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x6ce0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_xpcall
static int luaB_xpcall (lua_State *L) {
  int status;
  int n = lua_gettop(L);
  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */
  lua_pushboolean(L, 1);  /* first result */
  lua_pushvalue(L, 1);  /* function */
  lua_rotate(L, 3, 2);  /* move them below function's arguments */
  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
  return finishpcall(L, status, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6fc0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6190
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x5e60
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
subl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x2, %ecx
movl $0x2, %r8d
leaq 0x2f5(%rip), %r9        # 0x274b0
callq 0x8210
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0x274b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: load_aux
static int load_aux (lua_State *L, int status, int envidx) {
  if (status == LUA_OK) {
    if (envidx != 0) {  /* 'env' parameter? */
      lua_pushvalue(L, envidx);  /* environment for loaded function */
      if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */
        lua_pop(L, 1);  /* remove 'env' if not used by previous call */
    }
    return 1;
  }
  else {  /* error (message is on top of the stack) */
    lua_pushnil(L);
    lua_insert(L, -2);  /* put before error message */
    return 2;  /* return nil plus error message */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x272cc
cmpl $0x0, -0x18(%rbp)
je 0x272c3
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x6190
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x8c30
cmpq $0x0, %rax
jne 0x272c1
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
jmp 0x272c3
movl $0x1, -0x4(%rbp)
jmp 0x272ef
movq -0x10(%rbp), %rdi
callq 0x6b60
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5e60
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)