LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_fmod
static int math_fmod (lua_State *L) {
  if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
    lua_Integer d = lua_tointeger(L, 2);
    if ((lua_Unsigned)d + 1u <= 1u) {  /* special cases: -1 or 0 */
      luaL_argcheck(L, d != 0, 2, "zero");
      lua_pushinteger(L, 0);  /* avoid overflow with 0x80000... / -1 */
    }
    else
      lua_pushinteger(L, lua_tointeger(L, 1) % d);
  }
  else
    lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
                                     luaL_checknumber(L, 2)));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x60dc
testl %eax, %eax
je 0x1bd17
movq %rbx, %rdi
movl $0x2, %esi
callq 0x60dc
testl %eax, %eax
je 0x1bd17
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x62e1
movq %rax, %r14
incq %rax
cmpq $0x1, %rax
ja 0x1bd4d
testq %r14, %r14
jne 0x1bd10
leaq 0x74be(%rip), %rdx      # 0x231c1
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1497c
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x1bd67
movq %rbx, %rdi
movl $0x1, %esi
callq 0x150a0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x150a0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x51e0
movq %rbx, %rdi
callq 0x64e1
jmp 0x1bd6c
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x62e1
cqto
idivq %r14
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x64f6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_ult
static int math_ult (lua_State *L) {
  lua_Integer a = luaL_checkinteger(L, 1);
  lua_Integer b = luaL_checkinteger(L, 2);
  lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x15124
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x15124
xorl %esi, %esi
cmpq %rax, %r14
setb %sil
movq %rbx, %rdi
callq 0x6725
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_log
static int math_log (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number res;
  if (lua_isnoneornil(L, 2))
    res = l_mathop(log)(x);
  else {
    lua_Number base = luaL_checknumber(L, 2);
#if !defined(LUA_USE_C89)
    if (base == 2.0) res = l_mathop(log2)(x); else
#endif
    if (base == 10.0) res = l_mathop(log10)(x);
    else res = l_mathop(log)(x)/l_mathop(log)(base);
  }
  lua_pushnumber(L, res);
  return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x150a0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x608f
testl %eax, %eax
jle 0x1be05
movq %rbx, %rdi
movl $0x2, %esi
callq 0x150a0
ucomisd 0x8243(%rip), %xmm0     # 0x24038
jne 0x1be11
jp 0x1be11
movsd (%rsp), %xmm0
callq 0x5060
jmp 0x1be55
movsd (%rsp), %xmm0
callq 0x51d0
jmp 0x1be55
movapd %xmm0, %xmm1
ucomisd 0x8223(%rip), %xmm0     # 0x24040
movsd (%rsp), %xmm0
jne 0x1be2d
jp 0x1be2d
callq 0x52a0
jmp 0x1be55
movsd %xmm1, 0x8(%rsp)
callq 0x51d0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x51d0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x64e1
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_max
static int math_max (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int imax = 1;  /* index of current maximum value */
  int i;
  luaL_argcheck(L, n >= 1, 1, "value expected");
  for (i = 2; i <= n; i++) {
    if (lua_compare(L, imax, i, LUA_OPLT))
      imax = i;
  }
  lua_pushvalue(L, imax);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d39
testl %eax, %eax
jle 0x1bebf
movl %eax, %r14d
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x1bed8
negl %r14d
movl $0x2, %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x61d0
testl %eax, %eax
je 0x1beaa
movl %r15d, %ebp
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x1be91
jmp 0x1bed8
leaq 0x745c(%rip), %rdx      # 0x23322
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x606b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_min
static int math_min (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int imin = 1;  /* index of current minimum value */
  int i;
  luaL_argcheck(L, n >= 1, 1, "value expected");
  for (i = 2; i <= n; i++) {
    if (lua_compare(L, i, imin, LUA_OPLT))
      imin = i;
  }
  lua_pushvalue(L, imin);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d39
testl %eax, %eax
jle 0x1bf49
movl %eax, %r14d
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x1bf62
negl %r14d
movl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x61d0
testl %eax, %eax
je 0x1bf34
movl %r15d, %ebp
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x1bf1b
jmp 0x1bf62
leaq 0x73d2(%rip), %rdx      # 0x23322
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x606b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_modf
static int math_modf (lua_State *L) {
  if (lua_isinteger(L ,1)) {
    lua_settop(L, 1);  /* number is its own integer part */
    lua_pushnumber(L, 0);  /* no fractional part */
  }
  else {
    lua_Number n = luaL_checknumber(L, 1);
    /* integer part (rounds toward zero) */
    lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
    pushnumint(L, ip);
    /* fractional part (test needed for inf/-inf) */
    lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
  }
  return 2;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x60dc
movq %rbx, %rdi
movl $0x1, %esi
testl %eax, %eax
je 0x1bfa5
callq 0x5d4d
xorpd %xmm0, %xmm0
jmp 0x1bff1
callq 0x150a0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm0, 0x10(%rsp)
jbe 0x1bfc1
callq 0x54d0
jmp 0x1bfc6
callq 0x5460
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x1c229
movapd 0x10(%rsp), %xmm0
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
cmpeqsd %xmm2, %xmm0
andnpd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x64e1
movl $0x2, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_random
static int math_random (lua_State *L) {
  lua_Integer low, up;
  double r = (double)l_rand() * (1.0 / ((double)L_RANDMAX + 1.0));
  switch (lua_gettop(L)) {  /* check number of arguments */
    case 0: {  /* no arguments */
      lua_pushnumber(L, (lua_Number)r);  /* Number between 0 and 1 */
      return 1;
    }
    case 1: {  /* only upper limit */
      low = 1;
      up = luaL_checkinteger(L, 1);
      break;
    }
    case 2: {  /* lower and upper limits */
      low = luaL_checkinteger(L, 1);
      up = luaL_checkinteger(L, 2);
      break;
    }
    default: return luaL_error(L, "wrong number of arguments");
  }
  /* random integer in the interval [low, up] */
  luaL_argcheck(L, low <= up, 1, "interval is empty"); 
  luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,
                   "interval too large");
  r *= (double)(up - low) + 1.0;
  lua_pushinteger(L, (lua_Integer)r + low);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5510
cvtsi2sd %eax, %xmm0
mulsd 0x800b(%rip), %xmm0     # 0x24050
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5d39
movl %eax, %r15d
cmpl $0x2, %eax
je 0x1c07c
movq %r15, %r14
cmpl $0x1, %eax
je 0x1c08c
testl %eax, %eax
jne 0x1c127
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x64e1
jmp 0x1c116
movq %rbx, %rdi
movl $0x1, %esi
callq 0x15124
movq %rax, %r14
movq %rbx, %rdi
movl %r15d, %esi
callq 0x15124
movq %rax, %r15
movq %rax, %r12
subq %r14, %r12
jge 0x1c0b6
leaq 0x8064(%rip), %rdx      # 0x2410d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
testq %r14, %r14
sets %al
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
addq %r14, %rcx
cmpq %rcx, %r15
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1c0ea
leaq 0x8042(%rip), %rdx      # 0x2411f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
addsd 0x6e8e(%rip), %xmm0     # 0x22f88
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7fc5(%rip), %rsi      # 0x240f3
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14a62
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_type
static int math_type (lua_State *L) {
  if (lua_type(L, 1) == LUA_TNUMBER) {
      if (lua_isinteger(L, 1))
        lua_pushliteral(L, "integer"); 
      else
        lua_pushliteral(L, "float"); 
  }
  else {
    luaL_checkany(L, 1);
    lua_pushnil(L);
  }
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x608f
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x3, %eax
jne 0x1c204
callq 0x60dc
testl %eax, %eax
je 0x1c213
leaq 0x807f(%rip), %rsi      # 0x24281
jmp 0x1c21a
callq 0x1506d
movq %rbx, %rdi
callq 0x64cd
jmp 0x1c222
leaq 0x7f18(%rip), %rsi      # 0x24132
movq %rbx, %rdi
callq 0x656b
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_difftime
static int os_difftime (lua_State *L) {
  time_t t1 = l_checktime(L, 1);
  time_t t2 = l_checktime(L, 2);
  lua_pushnumber(L, (lua_Number)difftime(t1, t2));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x15124
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x15124
movq %r14, %rdi
movq %rax, %rsi
callq 0x5170
movq %rbx, %rdi
callq 0x64e1
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_execute
static int os_execute (lua_State *L) {
  const char *cmd = luaL_optstring(L, 1, NULL);
  int stat = system(cmd);
  if (cmd != NULL)
    return luaL_execresult(L, stat);
  else {
    lua_pushboolean(L, stat);  /* true if there is a shell */
    return 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r14
movq %rax, %rdi
callq 0x5150
movq %rbx, %rdi
movl %eax, %esi
testq %r14, %r14
je 0x1c535
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14ce7
callq 0x6725
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x608f
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x1, %eax
jne 0x1c575
callq 0x6333
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
jmp 0x1c57f
xorl %edx, %edx
callq 0x1518f
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6333
testl %eax, %eax
je 0x1c598
movq %rbx, %rdi
callq 0xf5bb
testq %rbx, %rbx
jne 0x1c5a7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %r14d, %edi
callq 0x5480
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r14
leaq 0x775f(%rip), %rdx      # 0x23dd8
leaq 0x13430(%rip), %rcx     # 0x2fab0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14f15
cltq
leaq 0x7c5a(%rip), %rcx      # 0x242f0
movl (%rcx,%rax,4), %edi
movq %r14, %rsi
callq 0x53f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x656b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x608f
testl %eax, %eax
jle 0x1c7ea
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x15039
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d4d
leaq 0x7ab9(%rip), %rsi      # 0x241b7
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1c9ad
movl %eax, (%rsp)
leaq 0x79bb(%rip), %rsi      # 0x240cf
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1c9ad
movl %eax, 0x4(%rsp)
leaq 0x7a90(%rip), %rsi      # 0x241bb
movq %rbx, %rdi
movl $0xc, %edx
xorl %ecx, %ecx
callq 0x1c9ad
movl %eax, 0x8(%rsp)
leaq 0x7a87(%rip), %rsi      # 0x241cc
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x1c9ad
movl %eax, 0xc(%rsp)
leaq 0x7a5c(%rip), %rsi      # 0x241c0
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x1c9ad
movl %eax, 0x10(%rsp)
leaq 0x7a45(%rip), %rsi      # 0x241c6
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x76c, %ecx            # imm = 0x76C
callq 0x1c9ad
movl %eax, 0x14(%rsp)
leaq 0x7a37(%rip), %rdx      # 0x241d5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6895
testl %eax, %eax
je 0x1c7be
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6333
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %rsp, %r15
movl %ebp, 0x20(%r15)
movq %r15, %rdi
callq 0x53a0
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c864
jmp 0x1c7f4
xorl %edi, %edi
callq 0x5330
movq %rax, %r14
cmpq $-0x1, %r14
jne 0x1c80b
leaq 0x797f(%rip), %rsi      # 0x24180
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f6
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x54a0
testq %rax, %rax
je 0x1c84d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x656b
movl $0x1, %eax
jmp 0x1c85e
leaq 0x7a71(%rip), %rsi      # 0x242c5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rsi
callq 0x64f6
leaq 0x793a(%rip), %rdx      # 0x241b7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x64f6
leaq 0x7832(%rip), %rdx      # 0x240cf
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movslq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x64f6
leaq 0x78fe(%rip), %rdx      # 0x241bb
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movslq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x64f6
leaq 0x78ef(%rip), %rdx      # 0x241cc
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movslq 0x10(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x64f6
leaq 0x78c0(%rip), %rdx      # 0x241c0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movslq 0x14(%r14), %rsi
addq $0x76c, %rsi            # imm = 0x76C
movq %rbx, %rdi
callq 0x64f6
leaq 0x789f(%rip), %rdx      # 0x241c6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movslq 0x18(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x64f6
leaq 0x7881(%rip), %rdx      # 0x241cb
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movslq 0x1c(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x64f6
leaq 0x7863(%rip), %rdx      # 0x241d0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movl 0x20(%r14), %esi
testl %esi, %esi
js 0x1c9a5
movq %rbx, %rdi
callq 0x6725
leaq 0x7844(%rip), %rdx      # 0x241d5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c66
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x6895
movl %eax, %r12d
leaq 0x4(%rsp), %r13
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r13, %rdx
callq 0x62e1
cmpl $0x0, (%r13)
je 0x1ca06
leaq 0x3fffffff(%rax), %rcx
cmpq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
jae 0x1ca14
subl %r15d, %eax
movl %eax, %ebp
jmp 0x1ca30
testl %r12d, %r12d
je 0x1ca2c
leaq 0x785a(%rip), %rsi      # 0x2426c
jmp 0x1ca1b
leaq 0x788f(%rip), %rsi      # 0x242aa
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x14a62
movl %eax, %ebp
jmp 0x1ca3d
testl %ebp, %ebp
js 0x1ca4e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7834(%rip), %rsi      # 0x24289
jmp 0x1ca1b
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
callq 0x14fff
movq %rax, %r14
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1518f
movq %rax, %r15
testq %rax, %rax
jns 0x1cb5a
movq (%rsp), %rax
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x1cb54
xorl %r15d, %r15d
jmp 0x1cb5a
addq %rax, %r15
incq %r15
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rdx
callq 0x1518f
movq (%rsp), %r12
testq %rax, %rax
jns 0x1cb88
movq %rax, %rcx
negq %rcx
cmpq %rcx, %r12
jae 0x1cb82
xorl %eax, %eax
jmp 0x1cb88
addq %r12, %rax
incq %rax
cmpq $0x2, %r15
movl $0x1, %r13d
cmovgeq %r15, %r13
cmpq %r12, %rax
cmovlq %rax, %r12
xorl %ebp, %ebp
movq %r12, %r15
subq %r13, %r15
jl 0x1cc03
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
jl 0x1cbc5
leaq 0x7985(%rip), %rsi      # 0x2453c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
movl %eax, %ebp
jmp 0x1cc03
leal 0x1(%r15), %ebp
leaq 0x796c(%rip), %rdx      # 0x2453c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14929
testl %r15d, %r15d
js 0x1cc03
addq %r13, %r14
decq %r14
subl %r13d, %r12d
incl %r12d
xorl %r15d, %r15d
movzbl (%r14,%r15), %esi
movq %rbx, %rdi
callq 0x64f6
incq %r15
cmpq %r15, %r12
jne 0x1cbee
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %rbx
callq 0x5d39
movl %eax, %r15d
movslq %eax, %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x154e4
movq %r14, (%rsp)
testl %r14d, %r14d
jle 0x1cc90
movq %rax, %r12
incl %r15d
movl $0x1, %r13d
leaq 0x78f3(%rip), %rbp      # 0x24552
movq %rbx, %rdi
movl %r13d, %esi
callq 0x15124
movq %rax, %r14
cmpq $0x100, %rax            # imm = 0x100
jb 0x1cc83
movq %rbx, %rdi
movl %r13d, %esi
movq %rbp, %rdx
callq 0x1497c
movb %r14b, -0x1(%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0x1cc5f
leaq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x15420
movl $0x1, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %rbx
movl $0x2, %esi
callq 0x6333
movl %eax, %r14d
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x15039
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d4d
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x154c8
leaq 0x17b4(%rip), %rsi      # 0x1e4c1
movq %rbx, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x7187
testl %eax, %eax
je 0x1cd34
leaq 0x783f(%rip), %rsi      # 0x24565
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
movl %eax, %ebp
jmp 0x1cd3e
leaq 0x8(%rsp), %rdi
callq 0x153c0
movl %ebp, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x14fff
movq %rax, %r14
movq %rsp, %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x14fff
movq %rax, %r13
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d4d
movl $0x240, %esi            # imm = 0x240
movq %rbx, %rdi
callq 0x73bd
movq (%r15), %rcx
addq %r14, %rcx
movq (%r12), %rdx
addq %r13, %rdx
movq %rbx, 0x30(%rax)
movl $0xc8, 0x38(%rax)
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %r14, (%rax)
movq %r13, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x1b35(%rip), %rsi      # 0x1eff1
movq %rbx, %rdi
movl $0x3, %edx
callq 0x66a8
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x14fff
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x64f6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x14fff
movq %rax, %rbx
movq (%r15), %rdx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x154e4
cmpq $0x0, (%r15)
je 0x1d9ca
movq %rax, %r14
xorl %r15d, %r15d
callq 0x5520
movq (%rax), %rcx
movzbl (%rbx,%r15), %edx
movb (%rcx,%rdx,4), %cl
movb %cl, (%r14,%r15)
incq %r15
movq 0x8(%rsp), %rsi
cmpq %rsi, %r15
jb 0x1d9ac
jmp 0x1d9cc
xorl %esi, %esi
leaq 0x10(%rsp), %rdi
callq 0x15420
movl $0x1, %eax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2038, %rsp           # imm = 0x2038
movq %rdi, %r13
movl $0x1, %ebp
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x14fff
movq %rax, %rbx
movq %r13, %rdi
movl $0x2, %esi
callq 0x15124
movq %rax, %r14
leaq 0x7357(%rip), %rdx      # 0x24d88
leaq 0x10(%rsp), %rcx
movq %r13, %rdi
movl $0x3, %esi
callq 0x14fa6
testq %r14, %r14
jle 0x1da84
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r15
movq %r15, %rsi
addq %rcx, %rsi
jb 0x1da6c
movq %rax, %r12
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %r14
cmpq %rax, %rsi
jbe 0x1da98
leaq 0x6d3f(%rip), %rsi      # 0x247b2
movq %r13, %rdi
xorl %eax, %eax
callq 0x14a62
movl %eax, %ebp
jmp 0x1db1d
leaq 0x72fd(%rip), %rsi      # 0x24d88
movq %r13, %rdi
callq 0x656b
jmp 0x1db1d
imulq %r14, %rcx
leaq -0x1(%r14), %rax
imulq %rax, %r15
addq %rcx, %r15
leaq 0x18(%rsp), %rsi
movq %r13, %rdi
movq %r15, %rdx
callq 0x154e4
movq %rax, %r13
cmpq $0x1, %r14
je 0x1dafb
incq %r14
movq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5310
addq 0x8(%rsp), %r13
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x1daf2
movq %r13, %rdi
movq %r12, %rsi
callq 0x5310
addq 0x10(%rsp), %r13
decq %r14
cmpq $0x2, %r14
ja 0x1dac3
movq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5310
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x15420
movl $0x1, %ebp
movl %ebp, %eax
addq $0x2038, %rsp           # imm = 0x2038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x14fff
movq %rax, %rbx
movq (%r15), %rdx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x154e4
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1db8a
decq %rbx
xorl %ecx, %ecx
movb (%rbx,%rsi), %dl
movb %dl, (%rax,%rcx)
incq %rcx
movq 0x8(%rsp), %rsi
decq %rbx
cmpq %rsi, %rcx
jb 0x1db72
jmp 0x1db8c
xorl %esi, %esi
leaq 0x10(%rsp), %rdi
callq 0x15420
movl $0x1, %eax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x14fff
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x15124
movq %rax, %r15
testq %rax, %rax
jns 0x1dbf6
movq 0x8(%rsp), %rax
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x1dbf0
xorl %r15d, %r15d
jmp 0x1dbf6
addq %rax, %r15
incq %r15
movq %rbx, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x1518f
movq 0x8(%rsp), %rdx
testq %rax, %rax
jns 0x1dc29
movq %rax, %rcx
negq %rcx
cmpq %rcx, %rdx
jae 0x1dc23
xorl %eax, %eax
jmp 0x1dc29
addq %rdx, %rax
incq %rax
cmpq $0x2, %r15
movl $0x1, %ecx
cmovgeq %r15, %rcx
cmpq %rdx, %rax
cmovlq %rax, %rdx
subq %rcx, %rdx
jge 0x1dc53
leaq 0x713f(%rip), %rsi      # 0x24d88
movq %rbx, %rdi
callq 0x656b
jmp 0x1dc65
leaq (%r14,%rcx), %rsi
decq %rsi
incq %rdx
movq %rbx, %rdi
callq 0x650a
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
movq %rax, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x20(%rsp)
cmpb $0x0, (%rax)
je 0x1e1f6
xorl %r14d, %r14d
leaq 0xc(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x1f063
movl %eax, %r15d
movslq 0x8(%rsp), %rax
movslq 0xc(%rsp), %r12
addq %rax, %r12
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
subq %r12, %rax
cmpq %rax, %r14
jbe 0x1e1cb
movq %rbx, %rdi
movl $0x1, %esi
leaq 0x6723(%rip), %rdx      # 0x248e9
callq 0x1497c
andl $0xe, %r15d
cmpl $0x4, %r15d
jne 0x1e1e9
movq %rbx, %rdi
movl $0x1, %esi
leaq 0x671d(%rip), %rdx      # 0x24901
callq 0x1497c
addq %r12, %r14
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x1e182
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f6
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x24(%rdi), %eax
testl %eax, %eax
movl $0x1, %ebp
cmovnel %eax, %ebp
testq %rsi, %rsi
cmovel %eax, %ebp
movq 0x18(%rdi), %rdi
leaq 0x5a0b(%rip), %rdx      # 0x245c5
movl %ebp, %esi
callq 0x14929
testl %ebp, %ebp
je 0x1ebe1
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1ef07
incl %r12d
cmpl %r12d, %ebp
jne 0x1ebc8
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x24(%rdi), %r12d
cmpq $0x20, %r12
jb 0x1ec1c
movq 0x18(%rbx), %rdi
leaq 0x59b0(%rip), %rsi      # 0x245c5
xorl %eax, %eax
callq 0x14a62
movl %r12d, %eax
shll $0x4, %eax
movq %r15, 0x28(%rbx,%rax)
movslq %ebp, %rcx
movq %rcx, 0x30(%rbx,%rax)
leal 0x1(%r12), %eax
movb %al, 0x24(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1e785
testq %rax, %rax
jne 0x1ec4d
decb 0x24(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1(%rsi), %rbx
movzbl (%rsi), %eax
cmpl $0x5b, %eax
je 0x1ec93
cmpl $0x25, %eax
jne 0x1ecdb
cmpq 0x10(%r14), %rbx
jne 0x1ec8a
movq 0x18(%r14), %rdi
leaq 0x599b(%rip), %rsi      # 0x2461e
xorl %eax, %eax
callq 0x14a62
addq $0x2, %r15
movq %r15, %rbx
jmp 0x1ecdb
cmpb $0x5e, 0x1(%r15)
leaq 0x2(%r15), %rax
cmoveq %rax, %rbx
leaq 0x599a(%rip), %r15      # 0x24641
cmpq 0x10(%r14), %rbx
jne 0x1ecbb
movq 0x18(%r14), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x14a62
leaq 0x1(%rbx), %rax
cmpb $0x25, (%rbx)
jne 0x1ecca
cmpq 0x10(%r14), %rax
jb 0x1eccf
movq %rax, %rbx
jmp 0x1ecd3
addq $0x2, %rbx
cmpb $0x5d, (%rbx)
jne 0x1eca7
incq %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1(%rsi), %r12
cmpb $0x5e, 0x1(%rsi)
sete %r14b
setne %r15b
cmovneq %rsi, %r12
leaq 0x1(%r12), %rax
cmpq %rdx, %rax
jae 0x1ed68
movq %rdx, %rbx
movl %edi, %ebp
movzbl 0x1(%r12), %ecx
movzbl 0x2(%r12), %esi
cmpl $0x25, %ecx
jne 0x1ed34
movl %ebp, %edi
callq 0x1edb4
testl %eax, %eax
jne 0x1ed65
addq $0x2, %r12
movq %r12, %rax
jmp 0x1ed58
cmpl $0x2d, %esi
jne 0x1ed54
addq $0x3, %r12
cmpq %rbx, %r12
jae 0x1ed54
cmpl %ebp, %ecx
jg 0x1ed2f
movzbl (%r12), %ecx
movq %r12, %rax
cmpl %ebp, %ecx
jb 0x1ed58
jmp 0x1ed65
cmpl %ebp, %ecx
je 0x1ed65
movq %rax, %r12
incq %rax
cmpq %rbx, %rax
jb 0x1ed0f
jmp 0x1ed68
movl %r15d, %r14d
movzbl %r14b, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: singlematch
static int singlematch (MatchState *ms, const char *s, const char *p,
                        const char *ep) {
  if (s >= ms->src_end)
    return 0;
  else {
    int c = uchar(*s);
    switch (*p) {
      case '.': return 1;  /* matches any char */
      case L_ESC: return match_class(c, uchar(*(p+1)));
      case '[': return matchbracketclass(c, p, ep-1);
      default:  return (uchar(*p) == c);
    }
  }
}

// Assembly:
xorl %eax, %eax
cmpq %rsi, %rdi
jbe 0x1edb3
movzbl (%rsi), %edi
movzbl (%rdx), %esi
cmpl $0x5b, %esi
je 0x1ed9d
cmpl $0x2e, %esi
je 0x1ed97
cmpl $0x25, %esi
jne 0x1edab
movzbl 0x1(%rdx), %esi
jmp 0x1edb4
movl $0x1, %eax
retq
decq %rcx
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x1ece4
xorl %eax, %eax
cmpb %dil, %sil
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: match_class
static int match_class (int c, int cl) {
  int res;
  switch (tolower(cl)) {
    case 'a' : res = isalpha(c); break;
    case 'c' : res = iscntrl(c); break;
    case 'd' : res = isdigit(c); break;
    case 'g' : res = isgraph(c); break;
    case 'l' : res = islower(c); break;
    case 'p' : res = ispunct(c); break;
    case 's' : res = isspace(c); break;
    case 'u' : res = isupper(c); break;
    case 'w' : res = isalnum(c); break;
    case 'x' : res = isxdigit(c); break;
    case 'z' : res = (c == 0); break;  /* deprecated option */
    default: return (cl == c);
  }
  return (islower(cl) ? res : !res);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl %esi, %edi
callq 0x5340
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0x1eefe
leaq 0x55da(%rip), %rcx      # 0x243b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x400, %r14d           # imm = 0x400
jmp 0x1eee3
xorl %r14d, %r14d
testl %ebp, %ebp
sete %r14b
callq 0x5530
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x200, %r14d           # imm = 0x200
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x4, %r14d
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x8000, %r14d          # imm = 0x8000
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x800, %r14d           # imm = 0x800
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x2, %r14d
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x2000, %r14d          # imm = 0x2000
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x100, %r14d           # imm = 0x100
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x1000, %r14d          # imm = 0x1000
jmp 0x1eee3
callq 0x5530
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x8, %r14d
movq (%rax), %rcx
movl %ebx, %edx
xorl %eax, %eax
testl %r14d, %r14d
sete %al
testb $0x2, 0x1(%rcx,%rdx,2)
cmovnel %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
cmpl %ebp, %ebx
sete %al
jmp 0x1eef9
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: push_onecapture
static void push_onecapture (MatchState *ms, int i, const char *s,
                                                    const char *e) {
  if (i >= ms->level) {
    if (i == 0)  /* ms->level == 0, too */
      lua_pushlstring(ms->L, s, e - s);  /* add whole match */
    else
      luaL_error(ms->L, "invalid capture index %%%d", i + 1);
  }
  else {
    ptrdiff_t l = ms->capture[i].len;
    if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
    if (l == CAP_POSITION)
      lua_pushinteger(ms->L, (ms->capture[i].init - ms->src_init) + 1);
    else
      lua_pushlstring(ms->L, ms->capture[i].init, l);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movzbl 0x24(%rdi), %esi
cmpl %eax, %esi
jle 0x1ef55
cltq
shlq $0x4, %rax
leaq (%rbx,%rax), %r15
addq $0x28, %r15
movq 0x8(%r15), %r14
cmpq $-0x2, %r14
je 0x1ef87
cmpq $-0x1, %r14
jne 0x1ef49
movq 0x18(%rbx), %rdi
leaq 0x573a(%rip), %rsi      # 0x2467c
xorl %eax, %eax
callq 0x14a62
movq 0x18(%rbx), %rdi
movq (%r15), %rsi
movq %r14, %rdx
jmp 0x1ef7d
movq 0x18(%rbx), %rdi
testl %eax, %eax
je 0x1ef74
incl %eax
leaq 0x56fb(%rip), %rsi      # 0x24661
movl %eax, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x14a62
subq %rdx, %rcx
movq %rdx, %rsi
movq %rcx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x650a
movq (%r15), %rsi
subq (%rbx), %rsi
movq 0x18(%rbx), %rdi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x64f6
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: gmatch_aux
static int gmatch_aux (lua_State *L) {
  GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3));
  const char *src;
  gm->ms.L = L;
  for (src = gm->src; src <= gm->ms.src_end; src++) {
    const char *e;
    reprepstate(&gm->ms);
    if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) {
      gm->src = gm->lastmatch = e;
      return push_captures(&gm->ms, src, e);
    }
  }
  return 0;  /* not found */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x644d
movq %r14, 0x30(%rax)
movq (%rax), %r14
cmpq 0x20(%rax), %r14
ja 0x1f041
movq %rax, %rbx
movq %rax, %r15
addq $0x18, %r15
movb $0x0, 0x3c(%rbx)
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e785
testq %rax, %rax
je 0x1f038
cmpq 0x10(%rbx), %rax
jne 0x1f049
incq %r14
cmpq 0x20(%rbx), %r14
jbe 0x1f01a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, 0x10(%rbx)
movq %rax, (%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1eb8a
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: getdetails
static KOption getdetails (Header *h, size_t totalsize,
                           const char **fmt, int *psize, int *ntoalign) {
  KOption opt = getoption(h, fmt, psize);
  int align = *psize;  /* usually, alignment follows size */
  if (opt == Kpaddalign) {  /* 'X' gets alignment from following option */
    if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0)
      luaL_argerror(h->L, 1, "invalid next option for option 'X'");
  }
  if (align <= 1 || opt == Kchar)  /* need no alignment? */
    *ntoalign = 0;
  else {
    if (align > h->maxalign)  /* enforce maximum alignment */
      align = h->maxalign;
    if ((align & (align - 1)) != 0)  /* is 'align' not a power of 2? */
      luaL_argerror(h->L, 1, "format asks for alignment not power of 2");
    *ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1);
  }
  return opt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x1f51d
movl %eax, %ebp
movl (%r13), %r13d
movl %r13d, 0x4(%rsp)
cmpl $0x7, %eax
jne 0x1f0df
movq (%r12), %rax
cmpb $0x0, (%rax)
je 0x1f0cb
leaq 0x4(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1f51d
cmpl $0x3, %eax
sete %al
movl (%r13), %r13d
testl %r13d, %r13d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1f0df
movq (%r15), %rdi
leaq 0x5762(%rip), %rdx      # 0x24837
movl $0x1, %esi
callq 0x1497c
cmpl $0x2, %r13d
setl %al
cmpl $0x3, %ebp
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x1f125
movl 0xc(%r15), %r12d
cmpl %r12d, %r13d
cmovll %r13d, %r12d
leal -0x1(%r12), %r13d
testl %r13d, %r12d
je 0x1f11c
movq (%r15), %rdi
leaq 0x5748(%rip), %rdx      # 0x2485a
movl $0x1, %esi
callq 0x1497c
andl %r13d, %r14d
subl %r14d, %r12d
andl %r13d, %r12d
movl %r12d, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: getnumlimit
static int getnumlimit (Header *h, const char **fmt, int df) {
  int sz = getnum(fmt, df);
  if (sz > MAXINTSIZE || sz <= 0)
    luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
                     sz, MAXINTSIZE);
  return sz;
}

// Assembly:
pushq %rbx
movl %edx, %ebx
movq (%rsi), %rax
movsbl (%rax), %ecx
addl $-0x3a, %ecx
cmpl $-0xa, %ecx
jb 0x1f728
incq %rax
xorl %ebx, %ebx
leal (%rbx,%rbx,4), %ecx
movq %rax, (%rsi)
movsbl -0x1(%rax), %edx
leal (%rdx,%rcx,2), %ebx
addl $-0x30, %ebx
movsbl (%rax), %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0x1f728
incq %rax
cmpl $0xccccccc, %ebx        # imm = 0xCCCCCCC
jl 0x1f702
leal -0x11(%rbx), %eax
cmpl $-0x11, %eax
ja 0x1f748
movq (%rdi), %rdi
leaq 0x5187(%rip), %rsi      # 0x248c1
movl %ebx, %edx
movl $0x10, %ecx
xorl %eax, %eax
callq 0x14a62
movl %ebx, %eax
popq %rbx
retq