LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_exit
static int os_exit (lua_State *L) {
  int status;
  if (lua_isboolean(L, 1))
    status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
  else
    status = (int)luaL_optinteger(L, 1, EXIT_SUCCESS);
  if (lua_toboolean(L, 2))
    lua_close(L);
  if (L) exit(status);  /* 'if' to avoid warnings for unreachable 'return' */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x1, %eax
jne 0x2b9f1
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6770
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ba06
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x205e0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6770
cmpl $0x0, %eax
je 0x2ba22
movq -0x8(%rbp), %rdi
callq 0x16350
cmpq $0x0, -0x8(%rbp)
je 0x2ba31
movl -0xc(%rbp), %edi
callq 0x5460
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_setlocale
static int os_setlocale (lua_State *L) {
  static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
                      LC_NUMERIC, LC_TIME};
  static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
     "numeric", "time", NULL};
  const char *l = luaL_optstring(L, 1, NULL);
  int op = luaL_checkoption(L, 2, "all", catnames);
  lua_pushstring(L, setlocale(cat[op], l));
  return 1;
}

// 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
leaq 0xa933(%rip), %rdx      # 0x364c8
leaq 0x16f14(%rip), %rcx     # 0x42ab0
callq 0x20230
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xaec9(%rip), %rax      # 0x36a80
movl (%rax,%rcx,4), %edi
movq -0x10(%rbp), %rsi
callq 0x53d0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x6ce0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_time
static int os_time (lua_State *L) {
  time_t t;
  if (lua_isnoneornil(L, 1))  /* called without args? */
    t = time(NULL);  /* get current time */
  else {
    struct tm ts;
    luaL_checktype(L, 1, LUA_TTABLE);
    lua_settop(L, 1);  /* make sure table is at the top */
    ts.tm_sec = getfield(L, "sec", 0, 0);
    ts.tm_min = getfield(L, "min", 0, 0);
    ts.tm_hour = getfield(L, "hour", 12, 0);
    ts.tm_mday = getfield(L, "day", -1, 0);
    ts.tm_mon = getfield(L, "month", -1, 1);
    ts.tm_year = getfield(L, "year", -1, 1900);
    ts.tm_isdst = getboolfield(L, "isdst");
    t = mktime(&ts);
    setallfields(L, &ts);  /* update fields with normalized values */
  }
  if (t != (time_t)(l_timet)t || t == (time_t)(-1))
    luaL_error(L, "time result cannot be represented in this installation");
  l_pushtime(L, t);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x0, %eax
jg 0x2bc11
xorl %eax, %eax
movl %eax, %edi
callq 0x5320
movq %rax, -0x10(%rbp)
jmp 0x2bcfb
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
leaq 0xad10(%rip), %rsi      # 0x3694d
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x2c070
movl %eax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xabfb(%rip), %rsi      # 0x3684f
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x2c070
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xace6(%rip), %rsi      # 0x36951
movl $0xc, %edx
xorl %ecx, %ecx
callq 0x2c070
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xacdd(%rip), %rsi      # 0x36962
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x2c070
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xacb7(%rip), %rsi      # 0x36956
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x2c070
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xaca0(%rip), %rsi      # 0x3695c
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x76c, %ecx            # imm = 0x76C
callq 0x2c070
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xac92(%rip), %rsi      # 0x3696b
callq 0x2c170
movl %eax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5380
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2be00
movq -0x10(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x2bd0c
cmpq $-0x1, -0x10(%rbp)
jne 0x2bd1e
movq -0x8(%rbp), %rdi
leaq 0xabe9(%rip), %rsi      # 0x36900
movb $0x0, %al
callq 0x1fbf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6be0
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_tmpname
static int os_tmpname (lua_State *L) {
  char buff[LUA_TMPNAMBUFSIZE];
  int err;
  lua_tmpnam(buff, err);
  if (err)
    return luaL_error(L, "unable to generate a unique filename");
  lua_pushstring(L, buff);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5480
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x2bd81
movq -0x10(%rbp), %rdi
leaq 0xace6(%rip), %rsi      # 0x36a5b
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2bd95
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6ce0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: setallfields
static void setallfields (lua_State *L, struct tm *stm) {
  setfield(L, "sec", stm->tm_sec);
  setfield(L, "min", stm->tm_min);
  setfield(L, "hour", stm->tm_hour);
  setfield(L, "day", stm->tm_mday);
  setfield(L, "month", stm->tm_mon + 1);
  setfield(L, "year", stm->tm_year + 1900);
  setfield(L, "wday", stm->tm_wday + 1);
  setfield(L, "yday", stm->tm_yday + 1);
  setboolfield(L, "isdst", stm->tm_isdst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0xab2c(%rip), %rsi      # 0x3694d
callq 0x2bff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xaa17(%rip), %rsi      # 0x3684f
callq 0x2bff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xab02(%rip), %rsi      # 0x36951
callq 0x2bff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0xaafc(%rip), %rsi      # 0x36962
callq 0x2bff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
addl $0x1, %edx
leaq 0xaad6(%rip), %rsi      # 0x36956
callq 0x2bff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
addl $0x76c, %edx            # imm = 0x76C
leaq 0xaabf(%rip), %rsi      # 0x3695c
callq 0x2bff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
addl $0x1, %edx
leaq 0xaaaa(%rip), %rsi      # 0x36961
callq 0x2bff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edx
addl $0x1, %edx
leaq 0xaa95(%rip), %rsi      # 0x36966
callq 0x2bff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
leaq 0xaa83(%rip), %rsi      # 0x3696b
callq 0x2c030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: checkoption
static const char *checkoption (lua_State *L, const char *conv, char *buff) {
  const char *option;
  int oplen = 1;
  for (option = LUA_STRFTIMEOPTIONS; *option != '\0'; option += oplen) {
    if (*option == '|')  /* next block? */
      oplen++;  /* next length */
    else if (memcmp(conv, option, oplen) == 0) {  /* match? */
      memcpy(buff, conv, oplen);  /* copy valid option to buffer */
      buff[oplen] = '\0';
      return conv + oplen;  /* return next item */
    }
  }
  luaL_argerror(L, 1,
    lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv));
  return conv;  /* to avoid warnings */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x2c(%rbp)
leaq 0xaa4f(%rip), %rax      # 0x36971
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2bfa4
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x2bf49
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2bf8f
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x5230
cmpl $0x0, %eax
jne 0x2bf8d
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x5300
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2bfdb
jmp 0x2bf8f
jmp 0x2bf91
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x2bf26
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xaa04(%rip), %rsi      # 0x369bf
movb $0x0, %al
callq 0x6de0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movl $0x1, %esi
callq 0x1fab0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: setboolfield
static void setboolfield (lua_State *L, const char *key, int value) {
  if (value < 0)  /* undefined? */
    return;  /* does not set field */
  lua_pushboolean(L, value);
  lua_setfield(L, -2, key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x2c04b
jmp 0x2c069
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6fc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7ae0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: getfield
static int getfield (lua_State *L, const char *key, int d, int delta) {
  int isnum;
  int t = lua_getfield(L, -1, key);  /* get field and its type */
  lua_Integer res = lua_tointegerx(L, -1, &isnum);
  if (!isnum) {  /* field is not an integer? */
    if (t != LUA_TNIL)  /* some other value? */
      return luaL_error(L, "field '%s' is not an integer", key);
    else if (d < 0)  /* absent field; no default? */
      return luaL_error(L, "field '%s' missing in date table", key);
    res = d;
  }
  else {
    if (!(-L_MAXDATEFIELD <= res && res <= L_MAXDATEFIELD))
      return luaL_error(L, "field '%s' is out-of-bound", key);
    res -= delta;
  }
  lua_pop(L, 1);
  return (int)res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x72f0
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq -0x24(%rbp), %rdx
callq 0x66e0
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2c108
cmpl $0x0, -0x28(%rbp)
je 0x2c0db
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa936(%rip), %rsi      # 0x36a02
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2c15e
cmpl $0x0, -0x1c(%rbp)
jge 0x2c0fc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa92f(%rip), %rsi      # 0x36a1f
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2c15e
jmp 0x2c0fe
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x2c149
movq $-0x3fffffff, %rax      # imm = 0xC0000001
cmpq -0x30(%rbp), %rax
jg 0x2c11f
cmpq $0x3fffffff, -0x30(%rbp) # imm = 0x3FFFFFFF
jle 0x2c13a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa912(%rip), %rsi      # 0x36a40
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2c15e
movslq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: getboolfield
static int getboolfield (lua_State *L, const char *key) {
  int res;
  res = (lua_getfield(L, -1, key) == LUA_TNIL) ? -1 : lua_toboolean(L, -1);
  lua_pop(L, 1);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x72f0
cmpl $0x0, %eax
jne 0x2c1a1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x2c1b2
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6770
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: createmetatable
static void createmetatable (lua_State *L) {
  lua_createtable(L, 0, 1);  /* table to be metatable for strings */
  lua_pushliteral(L, "");  /* dummy string */
  lua_pushvalue(L, -2);  /* copy table */
  lua_setmetatable(L, -2);  /* set table as metatable for strings */
  lua_pop(L, 1);  /* pop dummy string */
  lua_pushvalue(L, -2);  /* get string library */
  lua_setfield(L, -2, "__index");  /* metatable.__index = string */
  lua_pop(L, 1);  /* pop metatable */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x75e0
movq -0x8(%rbp), %rdi
leaq 0xb42f(%rip), %rsi      # 0x37686
callq 0x6ce0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6190
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7ef0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6190
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x8ea5(%rip), %rdx      # 0x35149
callq 0x7ae0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_byte
static int str_byte (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  lua_Integer posi = posrelat(luaL_optinteger(L, 2, 1), l);
  lua_Integer pose = posrelat(luaL_optinteger(L, 3, posi), l);
  int n, i;
  if (posi < 1) posi = 1;
  if (pose > (lua_Integer)l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
  if (pose - posi >= INT_MAX)  /* arithmetic overflow? */
    return luaL_error(L, "string slice too long");
  n = (int)(pose -  posi) + 1;
  luaL_checkstack(L, n, "string slice too long");
  for (i=0; i<n; i++)
    lua_pushinteger(L, uchar(s[posi+i-1]));
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x20390
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x205e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2de20
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x3, %esi
callq 0x205e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2de20
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x28(%rbp)
jge 0x2c336
movq $0x1, -0x28(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x2c348
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x2c35e
movl $0x0, -0x4(%rbp)
jmp 0x2c3e8
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jl 0x2c385
movq -0x10(%rbp), %rdi
leaq 0xaacb(%rip), %rsi      # 0x36e44
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2c3e8
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
leaq 0xaaa3(%rip), %rdx      # 0x36e44
callq 0x1f930
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x2c3e2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x38(%rbp), %rdx
addq %rdx, %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
callq 0x6be0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2c3ad
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_char
static int str_char (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  luaL_Buffer b;
  char *p = luaL_buffinitsize(L, &b, n);
  for (i=1; i<=n; i++) {
    lua_Integer c = luaL_checkinteger(L, i);
    luaL_argcheck(L, uchar(c) == c, i, "value out of range");
    p[i - 1] = uchar(c);
  }
  luaL_pushresultsize(&b, n);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
leaq -0x2030(%rbp), %rsi
callq 0x20af0
movq %rax, -0x2038(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x2c4c4
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x20550
movq %rax, -0x2040(%rbp)
movq -0x2040(%rbp), %rax
movzbl %al, %eax
movl %eax, %ecx
movb $0x1, %al
cmpq -0x2040(%rbp), %rcx
movb %al, -0x2041(%rbp)
je 0x2c494
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
leaq 0xa9d7(%rip), %rdx      # 0x36e5a
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x2041(%rbp)
movb -0x2041(%rbp), %al
movq -0x2040(%rbp), %rax
movb %al, %dl
movq -0x2038(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2c43d
movslq -0xc(%rbp), %rsi
leaq -0x2030(%rbp), %rdi
callq 0x209c0
movl $0x1, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_dump
static int str_dump (lua_State *L) {
  luaL_Buffer b;
  int strip = lua_toboolean(L, 2);
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 1);
  luaL_buffinit(L,&b);
  if (lua_dump(L, writer, &b, strip) != 0)
    return luaL_error(L, "unable to dump given function");
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6770
movl %eax, -0x2034(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x203e0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
leaq -0x2030(%rbp), %rsi
callq 0x20aa0
movq -0x10(%rbp), %rdi
movl -0x2034(%rbp), %ecx
leaq 0x191b(%rip), %rsi      # 0x2de70
leaq -0x2030(%rbp), %rdx
callq 0x8540
cmpl $0x0, %eax
je 0x2c57d
movq -0x10(%rbp), %rdi
leaq 0xa8fc(%rip), %rsi      # 0x36e6d
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2c590
leaq -0x2030(%rbp), %rdi
callq 0x20940
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: gmatch
static int gmatch (lua_State *L) {
  size_t ls, lp;
  const char *s = luaL_checklstring(L, 1, &ls);
  const char *p = luaL_checklstring(L, 2, &lp);
  GMatchState *gm;
  lua_settop(L, 2);  /* keep them on closure to avoid being collected */
  gm = (GMatchState *)lua_newuserdata(L, sizeof(GMatchState));
  prepstate(&gm->ms, L, s, ls, p, lp);
  gm->src = s; gm->p = p; gm->lastmatch = NULL;
  lua_pushcclosure(L, gmatch_aux, 3);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x20390
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq -0x18(%rbp), %rdx
callq 0x20390
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
movl $0x240, %esi            # imm = 0x240
callq 0x8990
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x18(%rbp), %r9
callq 0x2e2d0
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
leaq 0x2e59(%rip), %rsi      # 0x2f990
movl $0x3, %edx
callq 0x6ea0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_len
static int str_len (lua_State *L) {
  size_t l;
  luaL_checklstring(L, 1, &l);
  lua_pushinteger(L, (lua_Integer)l);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x20390
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6be0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_lower
static int str_lower (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  char *p = luaL_buffinitsize(L, &b, l);
  for (i=0; i<l; i++)
    p[i] = tolower(uchar(s[i]));
  luaL_pushresultsize(&b, l);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x20390
movq %rax, -0x2040(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x2038(%rbp), %rsi
callq 0x20af0
movq %rax, -0x2048(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2cea7
movq -0x2040(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x5330
movb %al, %dl
movq -0x2048(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2ce6b
movq -0x10(%rbp), %rsi
leaq -0x2038(%rbp), %rdi
callq 0x209c0
movl $0x1, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_rep
static int str_rep (lua_State *L) {
  size_t l, lsep;
  const char *s = luaL_checklstring(L, 1, &l);
  lua_Integer n = luaL_checkinteger(L, 2);
  const char *sep = luaL_optlstring(L, 3, "", &lsep);
  if (n <= 0) lua_pushliteral(L, "");
  else if (l + lsep < l || l + lsep > MAXSIZE / n)  /* may overflow? */
    return luaL_error(L, "resulting string too large");
  else {
    size_t totallen = (size_t)n * l + (size_t)(n - 1) * lsep;
    luaL_Buffer b;
    char *p = luaL_buffinitsize(L, &b, totallen);
    while (n-- > 1) {  /* first n-1 copies (followed by separator) */
      memcpy(p, s, l * sizeof(char)); p += l;
      if (lsep > 0) {  /* empty 'memcpy' is not that cheap */
        memcpy(p, sep, lsep * sizeof(char));
        p += lsep;
      }
    }
    memcpy(p, s, l * sizeof(char));  /* last copy (not followed by separator) */
    luaL_pushresultsize(&b, totallen);
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2070, %rsp           # imm = 0x2070
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x20390
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x20550
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq 0xa74f(%rip), %rdx      # 0x37686
leaq -0x20(%rbp), %rcx
callq 0x20310
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jg 0x2cf60
movq -0x10(%rbp), %rdi
leaq 0xa730(%rip), %rsi      # 0x37686
callq 0x6ce0
jmp 0x2d087
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2cf99
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x2070(%rbp)
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x30(%rbp)
movq %rax, %rcx
movq -0x2070(%rbp), %rax
cmpq %rcx, %rax
jbe 0x2cfb3
movq -0x10(%rbp), %rdi
leaq 0xa116(%rip), %rsi      # 0x370ba
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2d08e
movq -0x30(%rbp), %rax
imulq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq -0x2060(%rbp), %rsi
callq 0x20af0
movq %rax, -0x2068(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x30(%rbp)
cmpq $0x1, %rax
jle 0x2d05d
movq -0x2068(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5300
movq -0x18(%rbp), %rax
addq -0x2068(%rbp), %rax
movq %rax, -0x2068(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x2d05b
movq -0x2068(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5300
movq -0x20(%rbp), %rax
addq -0x2068(%rbp), %rax
movq %rax, -0x2068(%rbp)
jmp 0x2cfeb
movq -0x2068(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5300
movq -0x40(%rbp), %rsi
leaq -0x2060(%rbp), %rdi
callq 0x209c0
jmp 0x2d087
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2070, %rsp           # imm = 0x2070
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_reverse
static int str_reverse (lua_State *L) {
  size_t l, i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  char *p = luaL_buffinitsize(L, &b, l);
  for (i = 0; i < l; i++)
    p[i] = s[l - i - 1];
  luaL_pushresultsize(&b, l);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x20390
movq %rax, -0x2040(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x2038(%rbp), %rsi
callq 0x20af0
movq %rax, -0x2048(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2d127
movq -0x2040(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %dl
movq -0x2048(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2d0eb
movq -0x10(%rbp), %rsi
leaq -0x2038(%rbp), %rdi
callq 0x209c0
movl $0x1, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_sub
static int str_sub (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  lua_Integer start = posrelat(luaL_checkinteger(L, 2), l);
  lua_Integer end = posrelat(luaL_optinteger(L, 3, -1), l);
  if (start < 1) start = 1;
  if (end > (lua_Integer)l) end = l;
  if (start <= end)
    lua_pushlstring(L, s + start - 1, (size_t)(end - start) + 1);
  else lua_pushliteral(L, "");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x20390
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x20550
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2de20
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x205e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2de20
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x2d1c4
movq $0x1, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x2d1d6
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x2d203
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
addq $-0x1, %rsi
movq -0x28(%rbp), %rdx
subq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x6c20
jmp 0x2d213
movq -0x8(%rbp), %rdi
leaq 0xa478(%rip), %rsi      # 0x37686
callq 0x6ce0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_upper
static int str_upper (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  char *p = luaL_buffinitsize(L, &b, l);
  for (i=0; i<l; i++)
    p[i] = toupper(uchar(s[i]));
  luaL_pushresultsize(&b, l);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x20390
movq %rax, -0x2040(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x2038(%rbp), %rsi
callq 0x20af0
movq %rax, -0x2048(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2d2a7
movq -0x2040(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x50c0
movb %al, %dl
movq -0x2048(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2d26b
movq -0x10(%rbp), %rsi
leaq -0x2038(%rbp), %rdi
callq 0x209c0
movl $0x1, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_packsize
static int str_packsize (lua_State *L) {
  Header h;
  const char *fmt = luaL_checkstring(L, 1);  /* format string */
  size_t totalsize = 0;  /* accumulate total size of result */
  initheader(L, &h);
  while (*fmt != '\0') {
    int size, ntoalign;
    KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
    size += ntoalign;  /* total space used by option */
    luaL_argcheck(L, totalsize <= MAXSIZE - size, 1,
                     "format result too large");
    totalsize += size;
    switch (opt) {
      case Kstring:  /* strings with length count */
      case Kzstr:    /* zero-terminated string */
        luaL_argerror(L, 1, "variable-length format");
        /* call never return, but to avoid warnings: *//* FALLTHROUGH */
      default:  break;
    }
  }
  lua_pushinteger(L, (lua_Integer)totalsize);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x20390
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2fdf0
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2daaf
movq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x2fe30
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rax
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
subq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x35(%rbp)
jbe 0x2da74
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x978b(%rip), %rdx      # 0x371f1
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
movslq -0x2c(%rbp), %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $-0x4, %eax
subl $0x1, %eax
ja 0x2daa8
jmp 0x2da93
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x9766(%rip), %rdx      # 0x37209
callq 0x1fab0
jmp 0x2daaa
jmp 0x2da07
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6be0
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: nospecials
static int nospecials (const char *p, size_t l) {
  size_t upto = 0;
  do {
    if (strpbrk(p + upto, SPECIALS))
      return 0;  /* pattern has a special character */
    upto += strlen(p + upto) + 1;  /* may have more after \0 */
  } while (upto <= l);
  return 1;  /* no special chars found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
leaq 0x8d04(%rip), %rsi      # 0x36e8b
callq 0x53a0
cmpq $0x0, %rax
je 0x2e19b
movl $0x0, -0x4(%rbp)
jmp 0x2e1c5
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
callq 0x5150
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x2e178
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: lmemfind
static const char *lmemfind (const char *s1, size_t l1,
                               const char *s2, size_t l2) {
  if (l2 == 0) return s1;  /* empty strings are everywhere */
  else if (l2 > l1) return NULL;  /* avoids a negative 'l1' */
  else {
    const char *init;  /* to search for a '*s2' inside 's1' */
    l2--;  /* 1st char will be checked by 'memchr' */
    l1 = l1-l2;  /* 's2' cannot be found after that */
    while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
      init++;   /* 1st char is already checked */
      if (memcmp(init, s2+1, l2) == 0)
        return init-1;
      else {  /* correct 'l1' and 's1' to try again */
        l1 -= init-s1;
        s1 = init;
      }
    }
    return NULL;  /* not found */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2e1fc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e2c1
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x2e213
movq $0x0, -0x8(%rbp)
jmp 0x2e2c1
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x31(%rbp)
jbe 0x2e259
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movsbl (%rax), %esi
movq -0x18(%rbp), %rdx
callq 0x5200
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2e262
jmp 0x2e2b9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rdx
callq 0x5230
cmpl $0x0, %eax
jne 0x2e296
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2e2c1
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2e22b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: prepstate
static void prepstate (MatchState *ms, lua_State *L,
                       const char *s, size_t ls, const char *p, size_t lp) {
  ms->L = L;
  ms->matchdepth = MAXCCALLS;
  ms->src_init = s;
  ms->src_end = s + ls;
  ms->p_end = p + lp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0xc8, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
addq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: push_captures
static int push_captures (MatchState *ms, const char *s, const char *e) {
  int i;
  int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
  luaL_checkstack(ms->L, nlevels, "too many captures");
  for (i = 0; i < nlevels; i++)
    push_onecapture(ms, i, s, e);
  return nlevels;  /* number of strings pushed */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x24(%rax), %eax
cmpl $0x0, %eax
jne 0x2e762
cmpq $0x0, -0x10(%rbp)
je 0x2e762
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2e76d
movq -0x8(%rbp), %rax
movzbl 0x24(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x20(%rbp), %esi
leaq 0x8748(%rip), %rdx      # 0x36ecd
callq 0x1f930
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2e7b8
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x2f1a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2e791
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: start_capture
static const char *start_capture (MatchState *ms, const char *s,
                                    const char *p, int what) {
  const char *res;
  int level = ms->level;
  if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
  ms->capture[level].init = s;
  ms->capture[level].len = what;
  ms->level = level+1;
  if ((res=match(ms, s, p)) == NULL)  /* match failed? */
    ms->level--;  /* undo capture */
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x24(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x20, -0x2c(%rbp)
jl 0x2e80e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x86c6(%rip), %rsi      # 0x36ecd
movb $0x0, %al
callq 0x1fbf0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movslq -0x1c(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x24(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2e350
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2e87a
movq -0x8(%rbp), %rax
movb 0x24(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x24(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: end_capture
static const char *end_capture (MatchState *ms, const char *s,
                                  const char *p) {
  int l = capture_to_close(ms);
  const char *res;
  ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
  if ((res = match(ms, s, p)) == NULL)  /* match failed? */
    ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2eee0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2e350
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2e91a
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $-0x1, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: matchbalance
static const char *matchbalance (MatchState *ms, const char *s,
                                   const char *p) {
  if (p >= ms->p_end - 1)
    luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')");
  if (*s != *p) return NULL;
  else {
    int b = *p;
    int e = *(p+1);
    int cont = 1;
    while (++s < ms->src_end) {
      if (*s == e) {
        if (--cont == 0) return s+1;
      }
      else if (*s == b) cont++;
    }
  }
  return NULL;  /* string ends out of balance */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x2e96f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x858f(%rip), %rsi      # 0x36ef7
movb $0x0, %al
callq 0x1fbf0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x2e98b
movq $0x0, -0x8(%rbp)
jmp 0x2ea0a
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2ea00
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x2e9e7
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x2e9e5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2ea0a
jmp 0x2e9fe
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x2e9fc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2e9fe
jmp 0x2e9a7
jmp 0x2ea02
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: classend
static const char *classend (MatchState *ms, const char *p) {
  switch (*p++) {
    case L_ESC: {
      if (p == ms->p_end)
        luaL_error(ms->L, "malformed pattern (ends with '%%')");
      return p+1;
    }
    case '[': {
      if (*p == '^') p++;
      do {  /* look for a ']' */
        if (p == ms->p_end)
          luaL_error(ms->L, "malformed pattern (missing ']')");
        if (*(p++) == L_ESC && p < ms->p_end)
          p++;  /* skip escapes (e.g. '%]') */
      } while (*p != ']');
      return p+1;
    }
    default: {
      return p;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x25, %eax
je 0x2ea58
jmp 0x2ea4b
movl -0x1c(%rbp), %eax
subl $0x5b, %eax
je 0x2ea8d
jmp 0x2eb18
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x2ea7c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x84b1(%rip), %rsi      # 0x36f26
movb $0x0, %al
callq 0x1fbf0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2eb20
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x2eaa5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2eaa7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x2eacb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x8485(%rip), %rsi      # 0x36f49
movb $0x0, %al
callq 0x1fbf0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x2eafc
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2eafc
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2eafe
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x2eaa7
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2eb20
movq -0x18(%rbp), %rax
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/lstrlib.c
// Function: matchbracketclass
static int matchbracketclass (int c, const char *p, const char *ec) {
  int sig = 1;
  if (*(p+1) == '^') {
    sig = 0;
    p++;  /* skip the '^' */
  }
  while (++p < ec) {
    if (*p == L_ESC) {
      p++;
      if (match_class(c, uchar(*p)))
        return sig;
    }
    else if ((*(p+1) == '-') && (p+2 < ec)) {
      p+=2;
      if (uchar(*(p-2)) <= c && c <= uchar(*p))
        return sig;
    }
    else if (uchar(*p) == c) return sig;
  }
  return !sig;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5e, %eax
jne 0x2eb6a
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2eb6c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
cmpq -0x18(%rbp), %rax
jae 0x2ec21
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x2ebb8
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
callq 0x2ef60
cmpl $0x0, %eax
je 0x2ebb6
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ec32
jmp 0x2ec1c
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2d, %eax
jne 0x2ec04
movq -0x10(%rbp), %rax
addq $0x2, %rax
cmpq -0x18(%rbp), %rax
jae 0x2ec04
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x2(%rax), %eax
cmpl -0x8(%rbp), %eax
jg 0x2ec02
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jg 0x2ec02
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ec32
jmp 0x2ec1a
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x2ec18
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ec32
jmp 0x2ec1a
jmp 0x2ec1c
jmp 0x2eb6c
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: match_capture
static const char *match_capture (MatchState *ms, const char *s, int l) {
  size_t len;
  l = check_capture(ms, l);
  len = ms->capture[l].len;
  if ((size_t)(ms->src_end-s) >= len &&
      memcmp(ms->capture[l].init, s, len) == 0)
    return s+len;
  else return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2f120
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
cmpq -0x28(%rbp), %rax
jb 0x2ecc8
movq -0x10(%rbp), %rax
addq $0x28, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5230
cmpl $0x0, %eax
jne 0x2ecc8
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ecd0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)