LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_callbinTM
int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
                    StkId res, TMS event) {
  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
  if (ttisnil(tm))
    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
  if (ttisnil(tm)) return 0;
  luaT_callTM(L, tm, p1, p2, res, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %r8d, %edx
callq 0x10304
cmpl $0x0, 0x8(%rax)
jne 0x10497
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x10304
cmpl $0x0, 0x8(%rax)
je 0x104be
movl $0x1, %ebp
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x103d7
jmp 0x104c0
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_trybinTM
void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
                    StkId res, TMS event) {
  if (!luaT_callbinTM(L, p1, p2, res, event)) {
    switch (event) {
      case TM_CONCAT:
        luaG_concaterror(L, p1, p2);
      /* call never returns, but to avoid warnings: *//* FALLTHROUGH */
      case TM_BAND: case TM_BOR: case TM_BXOR:
      case TM_SHL: case TM_SHR: case TM_BNOT: {
        lua_Number dummy;
        if (tonumber(p1, &dummy) && tonumber(p2, &dummy))
          luaG_tointerror(L, p1, p2);
        else
          luaG_opinterror(L, p1, p2, "perform bitwise operation on");
      }
      /* calls never return, but to avoid warnings: *//* FALLTHROUGH */
      default:
        luaG_opinterror(L, p1, p2, "perform arithmetic on");
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x10465
testl %eax, %eax
je 0x104f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leal -0xd(%r12), %eax
cmpl $0x5, %eax
jae 0x10511
cmpl $0x3, 0x8(%r14)
jne 0x1052b
movsd (%r14), %xmm0
movsd %xmm0, (%rsp)
jmp 0x1053a
cmpl $0x13, %r12d
je 0x104fe
cmpl $0x16, %r12d
jne 0x10571
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7eab
movq %rsp, %rsi
movq %r14, %rdi
callq 0x10da8
testl %eax, %eax
je 0x1055a
cmpl $0x3, 0x8(%rbx)
jne 0x1054b
movsd (%rbx), %xmm0
movsd %xmm0, (%rsp)
jmp 0x10563
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10da8
testl %eax, %eax
jne 0x10563
leaq 0x11813(%rip), %rcx     # 0x21d74
jmp 0x10578
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7f0e
leaq 0x11819(%rip), %rcx     # 0x21d91
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7ec8
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_callorderTM
int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
                      TMS event) {
  if (!luaT_callbinTM(L, p1, p2, L->top, event))
    return -1;  /* no metamethod */
  else
    return !l_isfalse(L->top);
}

// Assembly:
pushq %rbx
movl %ecx, %r8d
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
callq 0x10465
testl %eax, %eax
je 0x105b4
movq 0x10(%rbx), %rcx
movl 0x8(%rcx), %eax
testl %eax, %eax
je 0x105c0
cmpl $0x1, %eax
jne 0x105bb
xorl %eax, %eax
cmpl $0x0, (%rcx)
setne %al
jmp 0x105c0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x105c0
movl $0x1, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: luaU_undump
LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
  LoadState S;
  LClosure *cl;
  if (*name == '@' || *name == '=')
    S.name = name + 1;
  else if (*name == LUA_SIGNATURE[0])
    S.name = "binary string";
  else
    S.name = name;
  S.L = L;
  S.Z = Z;
  checkHeader(&S);
  cl = luaF_newLclosure(L, LoadByte(&S));
  setclLvalue(L, L->top, cl);
  luaD_inctop(L);
  cl->p = luaF_newproto(L);
  LoadFunction(&S, cl->p, NULL);
  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
  luai_verifycode(L, buff, cl->p);
  return cl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpl $0x1b, %eax
je 0x105e7
cmpl $0x40, %eax
je 0x105e2
cmpl $0x3d, %eax
jne 0x105ee
incq %rdx
jmp 0x105ee
leaq 0x11846(%rip), %rdx     # 0x21e34
leaq 0x8(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rbx, (%r14)
movq %rsi, 0x8(%r14)
leaq 0x10e9d(%rip), %rsi     # 0x214a2
leaq 0x11836(%rip), %rdx     # 0x21e42
movq %r14, %rdi
callq 0x10bf8
movq %rsp, %r15
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cd8
cmpb $0x53, (%r15)
jne 0x1077c
leaq 0x8(%rsp), %rdi
movq %rsp, %r14
movl $0x1, %edx
movq %r14, %rsi
callq 0x10cd8
cmpb $0x0, (%r14)
jne 0x10785
leaq 0x10e4f(%rip), %rsi     # 0x214a6
leaq 0x117fe(%rip), %rdx     # 0x21e5c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x10bf8
leaq 0x13386(%rip), %rdx     # 0x239f8
movl $0x4, %esi
movq %r14, %rdi
callq 0x10c80
leaq 0x117e0(%rip), %rdx     # 0x21e66
movl $0x8, %esi
movq %r14, %rdi
callq 0x10c80
leaq 0x117d3(%rip), %rdx     # 0x21e6d
movl $0x4, %esi
movq %r14, %rdi
callq 0x10c80
leaq 0x117cb(%rip), %rdx     # 0x21e79
movl $0x8, %esi
movq %r14, %rdi
callq 0x10c80
leaq 0x117c3(%rip), %rdx     # 0x21e85
movl $0x8, %esi
movq %r14, %rdi
callq 0x10c80
movq %rsp, %r15
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cd8
cmpq $0x5678, (%r15)         # imm = 0x5678
jne 0x1078e
leaq 0x8(%rsp), %rdi
movq %rsp, %r14
movl $0x8, %edx
movq %r14, %rsi
callq 0x10cd8
movsd (%r14), %xmm0
ucomisd 0x11707(%rip), %xmm0    # 0x21e18
jne 0x10797
jp 0x10797
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cd8
movzbl (%r15), %esi
movq %rbx, %rdi
callq 0x9b15
movq %rax, %r15
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movl $0x46, 0x8(%rax)
movq %rbx, %rdi
callq 0x87e7
movq %rbx, %rdi
callq 0x9cc0
movq %rax, 0x18(%r15)
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x107a8
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x116c5(%rip), %rsi     # 0x21e48
jmp 0x1079e
leaq 0x11721(%rip), %rsi     # 0x21ead
jmp 0x1079e
leaq 0x116fb(%rip), %rsi     # 0x21e90
jmp 0x1079e
leaq 0x11709(%rip), %rsi     # 0x21ea7
leaq 0x8(%rsp), %rdi
callq 0x10c57
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: checkliteral
static void checkliteral (LoadState *S, const char *s, const char *msg) {
  char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
  size_t len = strlen(s);
  LoadVector(S, buff, len);
  if (memcmp(s, buff, len) != 0)
    error(S, msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5150
movq %rax, %r12
leaq 0x4(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x10cd8
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x5390
testl %eax, %eax
jne 0x10c4c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10c57
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: LoadString
static TString *LoadString (LoadState *S) {
  size_t size = LoadByte(S);
  if (size == 0xFF)
    LoadVar(S, size);
  if (size == 0)
    return NULL;
  else if (--size <= LUAI_MAXSHORTLEN) {  /* short string? */
    char buff[LUAI_MAXSHORTLEN];
    LoadVector(S, buff, size);
    return luaS_newlstr(S->L, buff, size);
  }
  else {  /* long string */
    TString *ts = luaS_createlngstrobj(S->L, size);
    LoadVector(S, getstr(ts), size);  /* load directly in final place */
    return ts;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0x1, %edx
movq %r14, %rsi
callq 0x10cd8
movzbl (%r14), %eax
movq %rax, 0x8(%rsp)
cmpq $0xff, %rax
jne 0x10d3a
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x10cd8
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x10d78
leaq -0x1(%rax), %rdx
movq %rdx, 0x8(%rsp)
cmpq $0x29, %rax
ja 0x10d7d
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10cd8
movq (%rbx), %rdi
movq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0xf2f1
movq %rax, %r14
jmp 0x10d9c
xorl %r14d, %r14d
jmp 0x10d9c
movq (%rbx), %rdi
movq %rdx, %rsi
callq 0xf4c4
movq %rax, %r14
leaq 0x18(%rax), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x10cd8
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_tonumber_
int luaV_tonumber_ (const TValue *obj, lua_Number *n) {
  TValue v;
  if (ttisinteger(obj)) {
    *n = cast_num(ivalue(obj));
    return 1;
  }
  else if (cvt2num(obj) &&  /* string convertible to number? */
            luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) {
    *n = nvalue(&v);  /* convert result of 'luaO_str2num' to a float */
    return 1;
  }
  else
    return 0;  /* conversion failed */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl $0x13, %eax
jne 0x10dce
cvtsi2sdq (%r14), %xmm0
movsd %xmm0, (%rbx)
movl $0x1, %ebp
jmp 0x10e14
andl $0xf, %eax
xorl %ebp, %ebp
cmpl $0x4, %eax
jne 0x10e14
movq (%r14), %rdi
addq $0x18, %rdi
movq %rsp, %rsi
callq 0xb811
movq (%r14), %rcx
cmpb $0x4, 0x8(%rcx)
jne 0x10df6
movzbl 0xb(%rcx), %ecx
jmp 0x10dfa
movq 0x10(%rcx), %rcx
incq %rcx
cmpq %rcx, %rax
jne 0x10e14
cmpl $0x13, 0x8(%rsp)
movq (%rsp), %rax
je 0x10e1f
movq %rax, %xmm0
jmp 0x10dc3
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cvtsi2sd %rax, %xmm0
jmp 0x10dc3
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_tointeger
int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode) {
  TValue v;
 again:
  if (ttisfloat(obj)) {
    lua_Number n = fltvalue(obj);
    lua_Number f = l_floor(n);
    if (n != f) {  /* not an integral value? */
      if (mode == 0) return 0;  /* fails if mode demands integral value */
      else if (mode > 1)  /* needs ceil? */
        f += 1;  /* convert floor to ceil (remember: n != f) */
    }
    return lua_numbertointeger(f, p);
  }
  else if (ttisinteger(obj)) {
    *p = ivalue(obj);
    return 1;
  }
  else if (cvt2num(obj) &&
            luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) {
    obj = &v;
    goto again;  /* convert result from 'luaO_str2num' to an integer */
  }
  return 0;  /* conversion failed */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x10(%rsp), %r15
xorl %r14d, %r14d
movl 0x8(%r12), %eax
cmpl $0x13, %eax
je 0x10efe
cmpl $0x3, %eax
je 0x10e92
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x10f0b
movq (%r12), %rdi
addq $0x18, %rdi
movq %r15, %rsi
callq 0xb811
movq (%r12), %rcx
cmpb $0x4, 0x8(%rcx)
jne 0x10e81
movzbl 0xb(%rcx), %ecx
jmp 0x10e85
movq 0x10(%rcx), %rcx
incq %rcx
movq %r15, %r12
cmpq %rcx, %rax
je 0x10e42
jmp 0x10f0b
movsd (%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x5470
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x10eb1
jnp 0x10ec2
testl %ebp, %ebp
je 0x10f1b
cmpl $0x2, %ebp
jl 0x10ec2
addsd 0x11036(%rip), %xmm0    # 0x21ef8
movsd 0x10d66(%rip), %xmm1    # 0x21c30
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movsd 0x10d4d(%rip), %xmm1    # 0x21c28
cmplepd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
testb $0x1, %al
je 0x10ef4
cvttsd2si %xmm0, %rcx
movq %rcx, (%rbx)
movzbl %al, %r14d
andl $0x1, %r14d
jmp 0x10f0b
movq (%r12), %rax
movq %rax, (%rbx)
movl $0x1, %r14d
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x10f0b
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_finishget
void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
                      const TValue *slot) {
  int loop;  /* counter to avoid infinite loops */
  const TValue *tm;  /* metamethod */
  for (loop = 0; loop < MAXTAGLOOP; loop++) {
    if (slot == NULL) {  /* 't' is not a table? */
      lua_assert(!ttistable(t));
      tm = luaT_gettmbyobj(L, t, TM_INDEX);
      if (ttisnil(tm))
        luaG_typeerror(L, t, "index");  /* no metamethod */
      /* else will try the metamethod */
    }
    else {  /* 't' is a table */
      lua_assert(ttisnil(slot));
      tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);  /* table's metamethod */
      if (tm == NULL) {  /* no metamethod? */
        setnilvalue(val);  /* result is nil */
        return;
      }
      /* else will try the metamethod */
    }
    if (ttisfunction(tm)) {  /* is metamethod a function? */
      luaT_callTM(L, tm, t, key, val, 1);  /* call it */
      return;
    }
    t = tm;  /* else try to access 'tm[key]' */
    if (luaV_fastget(L,t,key,slot,luaH_get)) {  /* fast track? */
      setobj2s(L, val, slot);  /* done */
      return;
    }
    /* else repeat (tail call 'luaV_finishget') */
  }
  luaG_runerror(L, "'__index' chain too long; possible loop");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x7d0, %ebp            # imm = 0x7D0
testq %rax, %rax
je 0x10f7b
movq (%r12), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x10f6e
testb $0x1, 0xa(%rdi)
jne 0x10f6e
movq 0x18(%r14), %rax
movq 0xe0(%rax), %rdx
xorl %esi, %esi
callq 0x102d9
movq %rax, %r13
jmp 0x10f71
xorl %r13d, %r13d
testq %r13, %r13
jne 0x10f95
jmp 0x11002
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10304
movq %rax, %r13
cmpl $0x0, 0x8(%rax)
je 0x11020
movl 0x8(%r13), %eax
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0x6, %ecx
je 0x10fda
cmpl $0x45, %eax
jne 0x10fbc
movq (%r13), %rdi
movq %r15, %rsi
callq 0x10094
cmpl $0x0, 0x8(%rax)
je 0x10fbe
jmp 0x1100b
xorl %eax, %eax
movq %r13, %r12
decl %ebp
jne 0x10f3f
leaq 0x110d4(%rip), %rsi     # 0x220a4
movq %r14, %rdi
xorl %eax, %eax
callq 0x7cd8
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x103d7
movl $0x0, 0x8(%rbx)
jmp 0x11011
movups (%rax), %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11de0(%rip), %rdx     # 0x22e07
movq %r14, %rdi
movq %r12, %rsi
callq 0x7c9a
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_lessthan
int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
  int res;
  if (ttisnumber(l) && ttisnumber(r))  /* both operands are numbers? */
    return LTnum(l, r);
  else if (ttisstring(l) && ttisstring(r))  /* both are strings? */
    return l_strcmp(tsvalue(l), tsvalue(r)) < 0;
  else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0)  /* no metamethod? */
    luaG_ordererror(L, l, r);  /* error */
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rsi), %eax
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
je 0x1122f
cmpl $0x3, %ecx
jne 0x1124d
movl 0x8(%rbx), %edx
movl %edx, %esi
andl $0xf, %esi
cmpl $0x3, %esi
jne 0x1122a
cmpl $0x13, %eax
jne 0x11276
movq (%r14), %rcx
cmpl $0x13, %edx
jne 0x1128a
cmpq (%rbx), %rcx
setl %al
jmp 0x1133c
cmpl $0x4, %ecx
jne 0x1124d
movl 0x8(%rbx), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x1124d
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x11345
shrl $0x1f, %eax
jmp 0x1133f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x14, %ecx
callq 0x10586
testl %eax, %eax
jns 0x1133f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7f64
movsd (%r14), %xmm0
cmpl $0x3, %edx
jne 0x112bb
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jmp 0x112b3
movsd (%rbx), %xmm0
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rcx, %rax
movabsq $0x40000000000001, %rdx # imm = 0x40000000000001
cmpq %rdx, %rax
jae 0x112ee
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
seta %al
jmp 0x1133c
ucomisd %xmm0, %xmm0
jp 0x1132b
movq (%rbx), %rcx
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rcx, %rax
movabsq $0x40000000000001, %rdx # imm = 0x40000000000001
cmpq %rdx, %rax
jae 0x11311
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
setae %al
jmp 0x1133a
movb $0x1, %al
ucomisd 0x10938(%rip), %xmm0    # 0x21c30
jae 0x1133c
ucomisd 0x10926(%rip), %xmm0    # 0x21c28
jbe 0x1132b
cvttsd2si %xmm0, %rax
cmpq %rax, %rcx
jmp 0x11222
movb $0x1, %al
ucomisd 0x10915(%rip), %xmm0    # 0x21c30
jae 0x1133a
ucomisd 0x10903(%rip), %xmm0    # 0x21c28
jae 0x1132f
xorl %eax, %eax
jmp 0x1133a
xorl %eax, %eax
jmp 0x1133c
cvttsd2si %xmm0, %rax
cmpq %rax, %rcx
setle %al
xorb $0x1, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: l_strcmp
static int l_strcmp (const TString *ls, const TString *rs) {
  const char *l = getstr(ls);
  size_t ll = tsslen(ls);
  const char *r = getstr(rs);
  size_t lr = tsslen(rs);
  for (;;) {  /* for each segment */
    int temp = strcoll(l, r);
    if (temp != 0)  /* not equal? */
      return temp;  /* done */
    else {  /* strings are equal up to a '\0' */
      size_t len = strlen(l);  /* index of first '\0' in both strings */
      if (len == lr)  /* 'rs' is finished? */
        return (len == ll) ? 0 : 1;  /* check 'ls' */
      else if (len == ll)  /* 'ls' is finished? */
        return -1;  /* 'ls' is smaller than 'rs' ('rs' is not finished) */
      /* both strings longer than 'len'; go on comparing after the '\0' */
      len++;
      l += len; ll -= len; r += len; lr -= len;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x4, 0x8(%rdi)
jne 0x11360
movzbl 0xb(%r14), %r15d
jmp 0x11364
movq 0x10(%r14), %r15
cmpb $0x4, 0x8(%rbx)
jne 0x11371
movzbl 0xb(%rbx), %r12d
jmp 0x11375
movq 0x10(%rbx), %r12
addq $0x18, %r14
addq $0x18, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x53a0
testl %eax, %eax
je 0x11392
xorl %ecx, %ecx
movl %eax, %ebp
jmp 0x113d0
movq %r14, %rdi
callq 0x5150
cmpq %r12, %rax
jne 0x113aa
xorl %ebp, %ebp
cmpq %r15, %rax
setne %bpl
jmp 0x113b4
cmpq %r15, %rax
jne 0x113b8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
jmp 0x113d0
leaq 0x1(%rax), %rcx
addq %rax, %r14
incq %r14
subq %rcx, %r15
addq %rax, %rbx
incq %rbx
subq %rcx, %r12
movb $0x1, %cl
testb %cl, %cl
jne 0x1137d
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_lessequal
int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
  int res;
  if (ttisnumber(l) && ttisnumber(r))  /* both operands are numbers? */
    return LEnum(l, r);
  else if (ttisstring(l) && ttisstring(r))  /* both are strings? */
    return l_strcmp(tsvalue(l), tsvalue(r)) <= 0;
  else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0)  /* try 'le' */
    return res;
  else {  /* try 'lt': */
    L->ci->callstatus |= CIST_LEQ;  /* mark it is doing 'lt' for 'le' */
    res = luaT_callorderTM(L, r, l, TM_LT);
    L->ci->callstatus ^= CIST_LEQ;  /* clear mark */
    if (res < 0)
      luaG_ordererror(L, l, r);
    return !res;  /* result is negated */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rsi), %eax
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
je 0x11431
cmpl $0x3, %ecx
jne 0x11455
movl 0x8(%rbx), %edx
movl %edx, %esi
andl $0xf, %esi
cmpl $0x3, %esi
jne 0x1142c
cmpl $0x13, %eax
jne 0x114a6
movq (%r14), %rcx
cmpl $0x13, %edx
jne 0x114ba
cmpq (%rbx), %rcx
setle %al
jmp 0x1156c
cmpl $0x4, %ecx
jne 0x11455
movl 0x8(%rbx), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x11455
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x11345
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setle %al
jmp 0x1156f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x15, %ecx
callq 0x10586
testl %eax, %eax
jns 0x1156f
movq 0x20(%r15), %rax
orb $-0x80, 0x42(%rax)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x14, %ecx
callq 0x10586
movq 0x20(%r15), %rcx
xorb $-0x80, 0x42(%rcx)
testl %eax, %eax
js 0x11575
sete %al
movzbl %al, %eax
jmp 0x1156f
movsd (%r14), %xmm0
cmpl $0x3, %edx
jne 0x114eb
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jmp 0x114e3
movsd (%rbx), %xmm0
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rcx, %rax
movabsq $0x40000000000001, %rdx # imm = 0x40000000000001
cmpq %rdx, %rax
jae 0x1151e
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
setae %al
jmp 0x1156c
ucomisd %xmm0, %xmm0
jp 0x11534
movq (%rbx), %rcx
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rcx, %rax
movabsq $0x40000000000001, %rdx # imm = 0x40000000000001
cmpq %rdx, %rax
jae 0x11538
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
seta %al
jmp 0x1156a
movb $0x1, %al
ucomisd 0x10708(%rip), %xmm0    # 0x21c30
jae 0x1156c
ucomisd 0x106f6(%rip), %xmm0    # 0x21c28
jae 0x1155b
xorl %eax, %eax
jmp 0x1156c
movb $0x1, %al
ucomisd 0x106ee(%rip), %xmm0    # 0x21c30
jae 0x1156a
ucomisd 0x106dc(%rip), %xmm0    # 0x21c28
jbe 0x11568
cvttsd2si %xmm0, %rax
cmpq %rax, %rcx
setl %al
jmp 0x1156a
cvttsd2si %xmm0, %rax
cmpq %rax, %rcx
jmp 0x11424
xorl %eax, %eax
xorb $0x1, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7f64
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_objlen
void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
  const TValue *tm;
  switch (ttype(rb)) {
    case LUA_TTABLE: {
      Table *h = hvalue(rb);
      tm = fasttm(L, h->metatable, TM_LEN);
      if (tm) break;  /* metamethod? break switch to call it */
      setivalue(ra, luaH_getn(h));  /* else primitive len */
      return;
    }
    case LUA_TSHRSTR: {
      setivalue(ra, tsvalue(rb)->shrlen);
      return;
    }
    case LUA_TLNGSTR: {
      setivalue(ra, tsvalue(rb)->u.lnglen);
      return;
    }
    default: {  /* try metamethod */
      tm = luaT_gettmbyobj(L, rb, TM_LEN);
      if (ttisnil(tm))  /* no metamethod? */
        luaG_typeerror(L, rb, "get length of");
      break;
    }
  }
  luaT_callTM(L, tm, rb, rb, ra, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl 0x8(%rdx), %eax
andl $0x3f, %eax
cmpl $0x4, %eax
je 0x11aa8
cmpl $0x14, %eax
je 0x11a9f
movq %rdi, %r15
cmpl $0x5, %eax
jne 0x11ab1
movq (%r14), %r12
movq 0x28(%r12), %rdi
testq %rdi, %rdi
je 0x11adc
testb $0x10, 0xa(%rdi)
jne 0x11adc
movq 0x18(%r15), %rax
movq 0x100(%rax), %rdx
movl $0x4, %esi
callq 0x102d9
movq %rax, %rsi
jmp 0x11ade
movq (%r14), %rax
movq 0x10(%rax), %rax
jmp 0x11b0f
movq (%r14), %rax
movzbl 0xb(%rax), %eax
jmp 0x11b0f
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x10304
movq %rax, %rsi
cmpl $0x0, 0x8(%rax)
jne 0x11ae3
leaq 0x1063d(%rip), %rdx     # 0x2210e
movq %r15, %rdi
movq %r14, %rsi
callq 0x7c9a
xorl %esi, %esi
testq %rsi, %rsi
je 0x11b05
movq %r15, %rdi
movq %r14, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x103d7
movq %r12, %rdi
callq 0x1012b
cltq
movq %rax, (%rbx)
movl $0x13, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_div
lua_Integer luaV_div (lua_State *L, lua_Integer m, lua_Integer n) {
  if (l_castS2U(n) + 1u <= 1u) {  /* special cases: -1 or 0 */
    if (n == 0)
      luaG_runerror(L, "attempt to divide by zero");
    return intop(-, 0, m);   /* n==-1; avoid overflow with 0x80000...//-1 */
  }
  else {
    lua_Integer q = m / n;  /* perform C division */
    if ((m ^ n) < 0 && m % n != 0)  /* 'm/n' would be negative non-integer? */
      q -= 1;  /* correct result for different rounding */
    return q;
  }
}

// Assembly:
movq %rdx, %rcx
leaq 0x1(%rdx), %rax
cmpq $0x1, %rax
ja 0x11b3e
testq %rcx, %rcx
je 0x11b55
negq %rsi
movq %rsi, %rax
retq
movq %rsi, %rax
cqto
idivq %rcx
xorq %rsi, %rcx
js 0x11b4c
retq
cmpq $0x1, %rdx
adcq $-0x1, %rax
retq
pushq %rax
leaq 0x105bf(%rip), %rsi     # 0x2211c
xorl %eax, %eax
callq 0x7cd8
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_mod
lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) {
  if (l_castS2U(n) + 1u <= 1u) {  /* special cases: -1 or 0 */
    if (n == 0)
      luaG_runerror(L, "attempt to perform 'n%%0'");
    return 0;   /* m % -1 == 0; avoid overflow with 0x80000...%-1 */
  }
  else {
    lua_Integer r = m % n;
    if (r != 0 && (m ^ n) < 0)  /* 'm/n' would be non-integer negative? */
      r += n;  /* correct result for different rounding */
    return r;
  }
}

// Assembly:
movq %rdx, %rcx
leaq 0x1(%rdx), %rax
cmpq $0x1, %rax
ja 0x11b85
testq %rcx, %rcx
jne 0x11ba3
pushq %rax
leaq 0x105b8(%rip), %rsi     # 0x22136
xorl %eax, %eax
callq 0x7cd8
movq %rsi, %rax
cqto
idivq %rcx
testq %rdx, %rdx
je 0x11ba3
movq %rdx, %rax
xorq %rcx, %rsi
sarq $0x3f, %rsi
andq %rcx, %rsi
addq %rsi, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: luaV_shiftl
lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) {
  if (y < 0) {  /* shift right? */
    if (y <= -NBITS) return 0;
    else return intop(>>, x, -y);
  }
  else {  /* shift left */
    if (y >= NBITS) return 0;
    else return intop(<<, x, y);
  }
}

// Assembly:
movq %rdi, %rax
testq %rsi, %rsi
js 0x11bbe
movl %esi, %ecx
shlq %cl, %rax
xorl %ecx, %ecx
cmpq $0x40, %rsi
cmovgeq %rcx, %rax
retq
cmpq $-0x3f, %rsi
jge 0x11bc7
xorl %eax, %eax
retq
negb %sil
movl %esi, %ecx
shrq %cl, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lzio.c
// Function: luaZ_init
void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
  z->L = L;
  z->reader = reader;
  z->data = data;
  z->n = 0;
  z->p = NULL;
}

// Assembly:
movq %rdi, 0x20(%rsi)
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lzio.c
// Function: luaZ_read
size_t luaZ_read (ZIO *z, void *b, size_t n) {
  while (n) {
    size_t m;
    if (z->n == 0) {  /* no bytes in buffer? */
      if (luaZ_fill(z) == EOZ)  /* try to read more */
        return n;  /* no more input; return number of missing bytes */
      else {
        z->n++;  /* luaZ_fill consumed first byte; put it back */
        z->p--;
      }
    }
    m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
    memcpy(b, z->p, m);
    z->n -= m;
    z->p += m;
    b = (char *)b + m;
    n -= m;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rbx, %rbx
je 0x13b98
cmpq $0x0, (%r15)
jne 0x13b63
movq %r15, %rdi
callq 0x13ad0
cmpl $-0x1, %eax
je 0x13b91
incq (%r15)
decq 0x8(%r15)
movq (%r15), %r13
movq 0x8(%r15), %rsi
cmpq %r13, %rbx
cmovbq %rbx, %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0x5320
subq %r13, (%r15)
addq %r13, 0x8(%r15)
addq %r13, %r14
subq %r13, %rbx
movb $0x1, %al
testb %al, %al
jne 0x13b44
jmp 0x13b9b
xorl %eax, %eax
movq %rbx, %r12
jmp 0x13b8b
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_checkstack
LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {
  if (!lua_checkstack(L, space)) {
    if (msg)
      luaL_error(L, "stack overflow (%s)", msg);
    else
      luaL_error(L, "stack overflow");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x5c28
testl %eax, %eax
je 0x13e70
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %r14, %r14
je 0x13e90
leaq 0xe402(%rip), %rsi      # 0x2227e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13f8e
leaq 0xd582(%rip), %rsi      # 0x21419
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13f8e
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_argerror
LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
  lua_Debug ar;
  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
    return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
  lua_getinfo(L, "n", &ar);
  if (strcmp(ar.namewhat, "method") == 0) {
    arg--;  /* do not count 'self' */
    if (arg == 0)  /* error is in the self argument itself? */
      return luaL_error(L, "calling '%s' on bad self (%s)",
                           ar.name, extramsg);
  }
  if (ar.name == NULL)
    ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
  return luaL_error(L, "bad argument #%d to '%s' (%s)",
                        arg, ar.name, extramsg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0x75ba
testl %eax, %eax
je 0x13f26
leaq 0xddee(%rip), %rsi      # 0x21cc2
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x782a
movq 0x10(%r15), %rdi
leaq 0xd48f(%rip), %rsi      # 0x2137e
callq 0x5290
testl %eax, %eax
jne 0x13efc
decl %ebp
je 0x13f3e
cmpq $0x0, 0x10(%rsp)
jne 0x13f65
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1404a
testl %eax, %eax
je 0x13f59
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6249
jmp 0x13f60
leaq 0xe2db(%rip), %rsi      # 0x22208
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x13f8e
jmp 0x13f80
movq 0x10(%rsp), %rdx
leaq 0xe2d4(%rip), %rsi      # 0x2221e
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x13f8e
jmp 0x13f80
leaq 0xd406(%rip), %rax      # 0x21366
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
leaq 0xe2cb(%rip), %rsi      # 0x2223c
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0x13f8e
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_error
LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
  va_list argp;
  va_start(argp, fmt);
  luaL_where(L, 1);
  lua_pushvfstring(L, fmt, argp);
  va_end(argp);
  lua_concat(L, 2);
  return lua_error(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x13ff0
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r15
movq %rsi, 0x10(%r15)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r15)
movl $0x1, %esi
callq 0x1412a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x64bb
movq %r14, %rdi
movl $0x2, %esi
callq 0x71d3
movq %r14, %rdi
callq 0x7196
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: pushglobalfuncname
static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
  int top = lua_gettop(L);
  lua_getinfo(L, "f", ar);  /* push function */
  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
  if (findfield(L, top + 1, 2)) {
    const char *name = lua_tostring(L, -1);
    if (strncmp(name, "_G.", 3) == 0) {  /* name start with '_G.'? */
      lua_pushstring(L, name + 3);  /* push name without prefix */
      lua_remove(L, -2);  /* remove original name */
    }
    lua_copy(L, -1, top + 1);  /* move name to proper place */
    lua_pop(L, 2);  /* remove pushed values */
    return 1;
  }
  else {
    lua_settop(L, top);  /* remove function and global table */
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5d3d
movl %eax, %r14d
leaq 0xe33a(%rip), %rsi      # 0x223a0
movq %rbx, %rdi
movq %r15, %rdx
callq 0x782a
leaq 0xe2a1(%rip), %rdx      # 0x22319
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6777
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x1549f
testl %eax, %eax
je 0x14110
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6249
movq %rax, %r14
leaq 0xe31f(%rip), %rsi      # 0x223d4
movl $0x3, %edx
movq %rax, %rdi
callq 0x50b0
testl %eax, %eax
jne 0x140f4
addq $0x3, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x645b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5da2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %ebp, %edx
callq 0x5f00
movl $0x1, %ebp
movl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
jmp 0x14112
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5d51
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_where
LUALIB_API void luaL_where (lua_State *L, int level) {
  lua_Debug ar;
  if (lua_getstack(L, level, &ar)) {  /* check function at level */
    lua_getinfo(L, "Sl", &ar);  /* get info about it */
    if (ar.currentline > 0) {  /* is there info? */
      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
      return;
    }
  }
  lua_pushfstring(L, "");  /* else, no information available... */
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x75ba
testl %eax, %eax
je 0x1417c
leaq 0xe10e(%rip), %rsi      # 0x2225a
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x782a
movl 0x28(%r14), %ecx
testl %ecx, %ecx
jle 0x1417c
leaq 0x40(%rsp), %rdx
leaq 0xe0ed(%rip), %rsi      # 0x2225d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x64e8
jmp 0x1418d
leaq 0xfb45(%rip), %rsi      # 0x23cc8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x64e8
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_fileresult
LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {
  int en = errno;  /* calls to Lua API may change this value */
  if (stat) {
    lua_pushboolean(L, 1);
    return 1;
  }
  else {
    lua_pushnil(L);
    if (fname)
      lua_pushfstring(L, "%s: %s", fname, strerror(en));
    else
      lua_pushstring(L, strerror(en));
    lua_pushinteger(L, en);
    return 3;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
callq 0x5090
testl %ebp, %ebp
je 0x141c4
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x660e
jmp 0x14210
movslq (%rax), %r14
movq %rbx, %rdi
callq 0x63bd
movl %r14d, %edi
callq 0x54d0
testq %r15, %r15
je 0x141f5
leaq 0xe276(%rip), %rsi      # 0x22459
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x64e8
jmp 0x14200
movq %rbx, %rdi
movq %rax, %rsi
callq 0x645b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63e6
movl $0x3, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_execresult
LUALIB_API int luaL_execresult (lua_State *L, int stat) {
  const char *what = "exit";  /* type of termination */
  if (stat == -1)  /* error? */
    return luaL_fileresult(L, 0, NULL);
  else {
    l_inspectstat(stat, what);  /* interpret result */
    if (*what == 'e' && stat == 0)  /* successful termination? */
      lua_pushboolean(L, 1);
    else
      lua_pushnil(L);
    lua_pushstring(L, what);
    lua_pushinteger(L, stat);
    return 3;  /* return true/nil,what,code */
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0x14240
cmpl $-0x1, %ebp
jne 0x1424f
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x14198
movq %rbx, %rdi
movl $0x1, %esi
callq 0x660e
jmp 0x14257
movq %rbx, %rdi
callq 0x63bd
leaq 0xe007(%rip), %rsi      # 0x22265
movq %rbx, %rdi
callq 0x645b
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x63e6
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_newmetatable
LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
  if (luaL_getmetatable(L, tname) != LUA_TNIL)  /* name already in use? */
    return 0;  /* leave previous value on top, but return 0 */
  lua_pop(L, 1);
  lua_createtable(L, 0, 2);  /* create metatable */
  lua_pushstring(L, tname);
  lua_setfield(L, -2, "__name");  /* metatable.__name = tname */
  lua_pushvalue(L, -1);
  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x6777
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x142f9
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x68d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x645b
leaq 0xdaa3(%rip), %rdx      # 0x21d6d
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f5b
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x6b3f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_testudata
LUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) {
  void *p = lua_touserdata(L, ud);
  if (p != NULL) {  /* value is a userdata? */
    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
      luaL_getmetatable(L, tname);  /* get correct metatable */
      if (!lua_rawequal(L, -1, -2))  /* not the same? */
        p = NULL;  /* value is a userdata with wrong metatable */
      lua_pop(L, 2);  /* remove both metatables */
      return p;
    }
  }
  return NULL;  /* value is not a userdata with a metatable */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
callq 0x633d
testq %rax, %rax
je 0x14383
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x6935
testl %eax, %eax
je 0x14383
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x6777
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x603d
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rcx, %rbx
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x5d51
jmp 0x14385
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: typeerror
static int typeerror (lua_State *L, int arg, const char *tname) {
  const char *msg;
  const char *typearg;  /* name for the type of the actual argument */
  if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)
    typearg = lua_tostring(L, -1);  /* use the given type name */
  else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)
    typearg = "light userdata";  /* special name for messages */
  else
    typearg = luaL_typename(L, arg);  /* standard name */
  msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);
  return luaL_argerror(L, arg, msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0xd98f(%rip), %rdx      # 0x21d6d
callq 0x14eb2
movq %r14, %rdi
cmpl $0x4, %eax
jne 0x143f9
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6249
jmp 0x14422
movl %ebx, %esi
callq 0x5f7f
cmpl $0x2, %eax
jne 0x1440e
leaq 0xdfcc(%rip), %rcx      # 0x223d8
jmp 0x14425
movq %r14, %rdi
movl %ebx, %esi
callq 0x5f7f
movq %r14, %rdi
movl %eax, %esi
callq 0x5fa0
movq %rax, %rcx
leaq 0xdfbb(%rip), %rsi      # 0x223e7
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x64e8
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x13ea8
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_checkoption
LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,
                                 const char *const lst[]) {
  const char *name = (def) ? luaL_optstring(L, arg, def) :
                             luaL_checkstring(L, arg);
  int i;
  for (i=0; lst[i]; i++)
    if (strcmp(lst[i], name) == 0)
      return i;
  return luaL_argerror(L, arg,
                       lua_pushfstring(L, "invalid option '%s'", name));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
testq %rdx, %rdx
je 0x14472
movq %rdx, %r12
movq %r14, %rdi
movl %ebx, %esi
callq 0x5f7f
testl %eax, %eax
jle 0x14481
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x14535
movq %rax, %r12
movq (%r15), %rdi
testq %rdi, %rdi
je 0x144a5
xorl %r13d, %r13d
movq %r12, %rsi
callq 0x5290
testl %eax, %eax
je 0x144cf
movq 0x8(%r15,%r13,8), %rdi
incq %r13
testq %rdi, %rdi
jne 0x1448c
leaq 0xddbe(%rip), %rsi      # 0x2226a
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x64e8
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13ea8
movl %r13d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_optlstring
LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,
                                        const char *def, size_t *len) {
  if (lua_isnoneornil(L, arg)) {
    if (len)
      *len = (def ? strlen(def) : 0);
    return def;
  }
  else return luaL_checklstring(L, arg, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x5f7f
testl %eax, %eax
jle 0x1450e
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14535
testq %rbx, %rbx
je 0x14527
testq %r14, %r14
je 0x14522
movq %r14, %rdi
callq 0x5150
jmp 0x14524
xorl %eax, %eax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_checknumber
LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {
  int isnum;
  lua_Number d = lua_tonumberx(L, arg, &isnum);
  if (!isnum)
    tag_error(L, arg, LUA_TNUMBER);
  return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x6182
cmpl $0x0, (%r15)
jne 0x1461b
movq %r14, %rdi
movl $0x3, %esi
movsd %xmm0, (%rsp)
callq 0x5fa0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x143ca
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_checkinteger
LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {
  int isnum;
  lua_Integer d = lua_tointegerx(L, arg, &isnum);
  if (!isnum) {
    interror(L, arg);
  }
  return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movq %r15, %rdx
callq 0x61d3
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x146b7
movq %r14, %rdi
movl %ebp, %esi
callq 0x5fdf
testl %eax, %eax
je 0x1469d
leaq 0xdd6a(%rip), %rdx      # 0x223fb
movq %r14, %rdi
movl %ebp, %esi
callq 0x13ea8
jmp 0x146b7
movq %r14, %rdi
movl $0x3, %esi
callq 0x5fa0
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x143ca
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_prepbuffsize
LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
  lua_State *L = B->L;
  if (B->size - B->n < sz) {  /* not enough space? */
    char *newbuff;
    size_t newsize = B->size * 2;  /* double buffer size */
    if (newsize - B->n < sz)  /* not big enough? */
      newsize = B->n + sz;
    if (newsize < B->n || newsize - B->n < sz)
      luaL_error(L, "buffer too large");
    /* create larger buffer */
    if (buffonstack(B))
      newbuff = (char *)resizebox(L, -1, newsize);
    else {  /* no buffer yet */
      newbuff = (char *)newbox(L, newsize);
      memcpy(newbuff, B->b, B->n * sizeof(char));  /* copy original content */
    }
    B->b = newbuff;
    B->size = newsize;
  }
  return &B->b[B->n];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
movq %rcx, %rdx
subq %rax, %rdx
cmpq %rsi, %rdx
jae 0x147ef
addq %rcx, %rcx
movq %rcx, %rdx
subq %rax, %rdx
leaq (%rax,%rsi), %r14
cmpq %rsi, %rdx
cmovaeq %rcx, %r14
movq 0x18(%rbx), %r15
movq %r14, %rcx
subq %rax, %rcx
setb %al
notb %al
cmpq %rsi, %rcx
setae %cl
testb %cl, %al
jne 0x14750
leaq 0xdb5b(%rip), %rsi      # 0x222a1
movq %r15, %rdi
xorl %eax, %eax
callq 0x13f8e
leaq 0x20(%rbx), %rax
cmpq %rax, (%rbx)
je 0x1476e
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x147fc
movq %rax, %r15
jmp 0x147e8
movl $0x10, %esi
movq %r15, %rdi
callq 0x727a
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0xdcc0(%rip), %rsi      # 0x22448
movq %r15, %rdi
callq 0x1427d
testl %eax, %eax
je 0x147b9
leaq 0xe1c(%rip), %rsi       # 0x155b7
movq %r15, %rdi
xorl %edx, %edx
callq 0x6591
leaq 0xd538(%rip), %rdx      # 0x21ce4
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d47
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x147fc
movq %rax, %r15
movq (%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x5320
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
addq 0x10(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: resizebox
static void *resizebox (lua_State *L, int idx, size_t newsize) {
  void *ud;
  lua_Alloc allocf = lua_getallocf(L, &ud);
  UBox *box = (UBox *)lua_touserdata(L, idx);
  void *temp = allocf(ud, box->box, box->bsize, newsize);
  if (temp == NULL && newsize > 0) {  /* allocation error? */
    resizebox(L, idx, 0);  /* free buffer */
    luaL_error(L, "not enough memory for buffer allocation");
  }
  box->box = temp;
  box->bsize = newsize;
  return temp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %r12
movq %r12, %rsi
callq 0x7256
movq %rax, %r13
movq %r14, %rdi
movl %ebp, %esi
callq 0x633d
movq %rax, %r15
movq (%r12), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rcx
callq *%r13
movq %rax, %r12
testq %rbx, %rbx
je 0x14865
testq %r12, %r12
jne 0x14865
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x147fc
leaq 0xdbc5(%rip), %rsi      # 0x22420
movq %r14, %rdi
xorl %eax, %eax
callq 0x13f8e
movq %r12, (%r15)
movq %rbx, 0x8(%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_addlstring
LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
  if (l > 0) {  /* avoid 'memcpy' when 's' can be NULL */
    char *b = luaL_prepbuffsize(B, l);
    memcpy(b, s, l * sizeof(char));
    luaL_addsize(B, l);
  }
}

// Assembly:
testq %rdx, %rdx
je 0x148b0
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0x146f3
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5320
addq %rbx, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq