LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x18940
cmpl $0x0, %eax
jne 0x18aea
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
addl $-0xd, %eax
subl $0x5, %eax
jb 0x18a47
jmp 0x18a1e
movl -0x34(%rbp), %eax
subl $0x13, %eax
je 0x18a47
jmp 0x18a28
movl -0x34(%rbp), %eax
subl $0x16, %eax
jne 0x18ad2
jmp 0x18a36
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9af0
movq -0x10(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x18a66
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x18a78
jmp 0x18aba
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x19780
cmpl $0x0, %eax
je 0x18aba
movq -0x18(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x18a97
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x18aa9
jmp 0x18aba
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x19780
cmpl $0x0, %eax
je 0x18aba
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9bb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1c71f(%rip), %rcx     # 0x351ec
callq 0x9b40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1c724(%rip), %rcx     # 0x35209
callq 0x9b40
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x24(%rbp), %r8d
callq 0x18940
cmpl $0x0, %eax
jne 0x18b32
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x18b7c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movb $0x1, %al
cmpl $0x0, 0x8(%rcx)
movb %al, -0x25(%rbp)
je 0x18b6f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
cmpl $0x1, 0x8(%rcx)
movb %al, -0x26(%rbp)
jne 0x18b69
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
je 0x18bbc
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x18bca
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x18bf3
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x1ba63(%rip), %ecx     # 0x3463b
cmpl %ecx, %eax
jne 0x18be9
leaq 0x1c699(%rip), %rax     # 0x3527c
movq %rax, -0x20(%rbp)
jmp 0x18bf1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x18bf3
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x18ca0
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x18e00
movq -0x50(%rbp), %rdi
movzbl %al, %esi
callq 0xcfb0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl $0x46, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0xb0b0
movq -0x8(%rbp), %rdi
callq 0xd2d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x18e30
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: checkHeader
static void checkHeader (LoadState *S) {
  checkliteral(S, LUA_SIGNATURE + 1, "not a");  /* 1st char already checked */
  if (LoadByte(S) != LUAC_VERSION)
    error(S, "version mismatch in");
  if (LoadByte(S) != LUAC_FORMAT)
    error(S, "format mismatch in");
  checkliteral(S, LUAC_DATA, "corrupted");
  checksize(S, int);
  checksize(S, size_t);
  checksize(S, Instruction);
  checksize(S, lua_Integer);
  checksize(S, lua_Number);
  if (LoadInteger(S) != LUAC_INT)
    error(S, "endianness mismatch in");
  if (LoadNumber(S) != LUAC_NUM)
    error(S, "float format mismatch in");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1b984(%rip), %rsi     # 0x3463b
addq $0x1, %rsi
leaq 0x1c5c8(%rip), %rdx     # 0x3528a
callq 0x18f10
movq -0x8(%rbp), %rdi
callq 0x18e00
movzbl %al, %eax
movsbl 0x1b9fa(%rip), %ecx     # 0x346d4
subl $0x30, %ecx
shll $0x4, %ecx
movsbl 0x1d47f(%rip), %edx     # 0x36166
subl $0x30, %edx
addl %edx, %ecx
cmpl %ecx, %eax
je 0x18d00
movq -0x8(%rbp), %rdi
leaq 0x1c595(%rip), %rsi     # 0x35290
callq 0x18f70
movq -0x8(%rbp), %rdi
callq 0x18e00
movzbl %al, %eax
cmpl $0x0, %eax
je 0x18d21
movq -0x8(%rbp), %rdi
leaq 0x1c5d9(%rip), %rsi     # 0x352f5
callq 0x18f70
movq -0x8(%rbp), %rdi
leaq 0x1b9aa(%rip), %rsi     # 0x346d6
leaq 0x1c571(%rip), %rdx     # 0x352a4
callq 0x18f10
movq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq 0x1e681(%rip), %rdx     # 0x373c9
callq 0x18fc0
movq -0x8(%rbp), %rdi
movl $0x8, %esi
leaq 0x1c551(%rip), %rdx     # 0x352ae
callq 0x18fc0
movq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq 0x1c543(%rip), %rdx     # 0x352b5
callq 0x18fc0
movq -0x8(%rbp), %rdi
movl $0x8, %esi
leaq 0x1c53a(%rip), %rdx     # 0x352c1
callq 0x18fc0
movq -0x8(%rbp), %rdi
movl $0x8, %esi
leaq 0x1c531(%rip), %rdx     # 0x352cd
callq 0x18fc0
movq -0x8(%rbp), %rdi
callq 0x19020
cmpq $0x5678, %rax           # imm = 0x5678
je 0x18dc2
movq -0x8(%rbp), %rdi
leaq 0x1c51b(%rip), %rsi     # 0x352d8
callq 0x18f70
movq -0x8(%rbp), %rdi
callq 0x19050
movsd 0x1b8a5(%rip), %xmm1    # 0x34678
ucomisd %xmm1, %xmm0
jne 0x18ddd
jp 0x18ddd
jmp 0x18ded
movq -0x8(%rbp), %rdi
leaq 0x1c507(%rip), %rsi     # 0x352ef
callq 0x18f70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: LoadFunction
static void LoadFunction (LoadState *S, Proto *f, TString *psource) {
  f->source = LoadString(S);
  if (f->source == NULL)  /* no source in dump? */
    f->source = psource;  /* reuse parent's source */
  f->linedefined = LoadInt(S);
  f->lastlinedefined = LoadInt(S);
  f->numparams = LoadByte(S);
  f->is_vararg = LoadByte(S);
  f->maxstacksize = LoadByte(S);
  LoadCode(S, f);
  LoadConstants(S, f);
  LoadUpvalues(S, f);
  LoadProtos(S, f);
  LoadDebug(S, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x190d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x18e6f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rdi
callq 0x18e00
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x8(%rbp), %rdi
callq 0x18e00
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xb(%rax)
movq -0x8(%rbp), %rdi
callq 0x18e00
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x191d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19240
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19400
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x194f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x195d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5150
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movq -0x30(%rbp), %rdx
shlq $0x0, %rdx
callq 0x19080
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5230
cmpl $0x0, %eax
je 0x18f69
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18f70
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18e00
movzbl %al, %eax
movq %rax, -0x18(%rbp)
cmpq $0xff, -0x18(%rbp)
jne 0x19108
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x19080
cmpq $0x0, -0x18(%rbp)
jne 0x19119
movq $0x0, -0x8(%rbp)
jmp 0x1918f
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x28, %rax
ja 0x1915a
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x0, %rdx
callq 0x19080
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16890
movq %rax, -0x8(%rbp)
jmp 0x1918f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x16920
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rdx
shlq $0x0, %rdx
callq 0x19080
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: LoadCode
static void LoadCode (LoadState *S, Proto *f) {
  int n = LoadInt(S);
  f->code = luaM_newvector(S->L, n, Instruction);
  f->sizecode = n;
  LoadVector(S, f->code, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rcx
shlq $0x2, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x2, %rdx
callq 0x19080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: LoadConstants
static void LoadConstants (LoadState *S, Proto *f) {
  int i;
  int n = LoadInt(S);
  f->k = luaM_newvector(S->L, n, TValue);
  f->sizek = n;
  for (i = 0; i < n; i++)
    setnilvalue(&f->k[i]);
  for (i = 0; i < n; i++) {
    TValue *o = &f->k[i];
    int t = LoadByte(S);
    switch (t) {
    case LUA_TNIL:
      setnilvalue(o);
      break;
    case LUA_TBOOLEAN:
      setbvalue(o, LoadByte(S));
      break;
    case LUA_TNUMFLT:
      setfltvalue(o, LoadNumber(S));
      break;
    case LUA_TNUMINT:
      setivalue(o, LoadInteger(S));
      break;
    case LUA_TSHRSTR:
    case LUA_TLNGSTR:
      setsvalue2n(S->L, o, LoadString(S));
      break;
    default:
      lua_assert(0);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x192c0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19293
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x193ec
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18e00
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x58(%rbp)
subq $0x14, %rax
ja 0x193da
movq -0x58(%rbp), %rax
leaq 0x1bf13(%rip), %rcx     # 0x35228
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x193dc
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18e00
movzbl %al, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x193dc
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19050
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
movl $0x3, 0x8(%rax)
jmp 0x193dc
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19020
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl $0x13, 0x8(%rax)
jmp 0x193dc
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x190d0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movzbl 0x8(%rax), %ecx
orl $0x40, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x193dc
jmp 0x193dc
jmp 0x193de
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x192c7
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: LoadUpvalues
static void LoadUpvalues (LoadState *S, Proto *f) {
  int i, n;
  n = LoadInt(S);
  f->upvalues = luaM_newvector(S->L, n, Upvaldesc);
  f->sizeupvalues = n;
  for (i = 0; i < n; i++)
    f->upvalues[i].name = NULL;
  for (i = 0; i < n; i++) {
    f->upvalues[i].instack = LoadByte(S);
    f->upvalues[i].idx = LoadByte(S);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x19480
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19453
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x194dc
movq -0x8(%rbp), %rdi
callq 0x18e00
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x18e00
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movb %cl, 0x9(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19487
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: LoadProtos
static void LoadProtos (LoadState *S, Proto *f) {
  int i;
  int n = LoadInt(S);
  f->p = luaM_newvector(S->L, n, Proto *);
  f->sizep = n;
  for (i = 0; i < n; i++)
    f->p[i] = NULL;
  for (i = 0; i < n; i++) {
    f->p[i] = luaF_newproto(S->L);
    LoadFunction(S, f->p[i], f->source);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1956a
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19543
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x195c4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd2d0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
callq 0x18e30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19571
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lundump.c
// Function: LoadDebug
static void LoadDebug (LoadState *S, Proto *f) {
  int i, n;
  n = LoadInt(S);
  f->lineinfo = luaM_newvector(S->L, n, int);
  f->sizelineinfo = n;
  LoadVector(S, f->lineinfo, n);
  n = LoadInt(S);
  f->locvars = luaM_newvector(S->L, n, LocVar);
  f->sizelocvars = n;
  for (i = 0; i < n; i++)
    f->locvars[i].varname = NULL;
  for (i = 0; i < n; i++) {
    f->locvars[i].varname = LoadString(S);
    f->locvars[i].startpc = LoadInt(S);
    f->locvars[i].endpc = LoadInt(S);
  }
  n = LoadInt(S);
  for (i = 0; i < n; i++)
    f->upvalues[i].name = LoadString(S);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rcx
shlq $0x2, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
movslq -0x18(%rbp), %rdx
shlq $0x2, %rdx
callq 0x19080
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x196a5
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19678
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x19723
movq -0x8(%rbp), %rdi
callq 0x190d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x196ac
movq -0x8(%rbp), %rdi
callq 0x191a0
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1976b
movq -0x8(%rbp), %rdi
callq 0x190d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19736
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x13, 0x8(%rax)
jne 0x197b7
movq -0x10(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1985d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x19856
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x108b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x19803
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0xb(%rax), %eax
movq %rax, -0x38(%rbp)
jmp 0x19812
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x19856
cmpl $0x13, -0x20(%rbp)
jne 0x19836
cvtsi2sdq -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x19840
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1985d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x19939
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x5440
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jne 0x198bd
jp 0x198bd
jmp 0x198eb
cmpl $0x0, -0x1c(%rbp)
jne 0x198cf
movl $0x0, -0x4(%rbp)
jmp 0x199dd
cmpl $0x1, -0x1c(%rbp)
jle 0x198e7
movsd 0x1ba63(%rip), %xmm0    # 0x35340
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x198e9
jmp 0x198eb
movsd -0x40(%rbp), %xmm0
xorl %eax, %eax
movsd 0x1b7ce(%rip), %xmm1    # 0x350c8
ucomisd %xmm1, %xmm0
movb %al, -0x41(%rbp)
jb 0x19929
xorl %eax, %eax
movsd 0x1b7cb(%rip), %xmm0    # 0x350d8
ucomisd -0x40(%rbp), %xmm0
movb %al, -0x41(%rbp)
jbe 0x19929
cvttsd2si -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x199dd
movq -0x10(%rbp), %rax
cmpl $0x13, 0x8(%rax)
jne 0x1995d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x199dd
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x199d2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
callq 0x108b0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x199a5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0xb(%rax), %eax
movq %rax, -0x58(%rbp)
jmp 0x199b4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x199d2
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x19883
jmp 0x199d4
jmp 0x199d6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x3, %eax
jne 0x19e84
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x3, %eax
jne 0x19e84
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19f10
movl %eax, -0x4(%rbp)
jmp 0x19efe
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x19ec5
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x19ec5
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x19ff0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x19efe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x14, %ecx
callq 0x18af0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x19ef4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9c30
jmp 0x19ef6
jmp 0x19ef8
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: LTnum
static int LTnum (const TValue *l, const TValue *r) {
  if (ttisinteger(l)) {
    lua_Integer li = ivalue(l);
    if (ttisinteger(r))
      return li < ivalue(r);  /* both are integers */
    else  /* 'l' is int and 'r' is float */
      return LTintfloat(li, fltvalue(r));  /* l < r ? */
  }
  else {
    lua_Number lf = fltvalue(l);  /* 'l' must be float */
    if (ttisfloat(r))
      return luai_numlt(lf, fltvalue(r));  /* both are float */
    else if (luai_numisnan(lf))  /* 'r' is int and 'l' is float */
      return 0;  /* NaN < i is always false */
    else  /* without NaN, (l < r)  <-->  not(r <= l) */
      return !LEintfloat(ivalue(r), lf);  /* not (r <= l) ? */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x13, 0x8(%rax)
jne 0x19f70
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x13, 0x8(%rax)
jne 0x19f5a
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x19fdf
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x1f350
movl %eax, -0x4(%rbp)
jmp 0x19fdf
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x19fa5
movsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x19fdf
movsd -0x28(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jne 0x19fb5
jp 0x19fb5
jmp 0x19fbe
movl $0x0, -0x4(%rbp)
jmp 0x19fdf
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x1f3f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x1a027
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %eax
movq %rax, -0x50(%rbp)
jmp 0x1a033
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x1a062
movq -0x18(%rbp), %rax
movzbl 0xb(%rax), %eax
movq %rax, -0x58(%rbp)
jmp 0x1a06e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5370
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x1a097
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a124
movq -0x20(%rbp), %rdi
callq 0x5150
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x1a0c8
movq -0x48(%rbp), %rdx
movq -0x28(%rbp), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1a124
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1a0db
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a124
jmp 0x1a0dd
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x1a076
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x3, %eax
jne 0x1a177
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x3, %eax
jne 0x1a177
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a260
movl %eax, -0x4(%rbp)
jmp 0x1a24c
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x1a1bb
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x1a1bb
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x19ff0
cmpl $0x0, %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1a24c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x15, %ecx
callq 0x18af0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jl 0x1a1e1
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a24c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movzbl 0x42(%rax), %ecx
orl $0x80, %ecx
movb %cl, 0x42(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x14, %ecx
callq 0x18af0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movzbl 0x42(%rax), %ecx
xorl $0x80, %ecx
movb %cl, 0x42(%rax)
cmpl $0x0, -0x24(%rbp)
jge 0x1a23b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9c30
cmpl $0x0, -0x24(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: LEnum
static int LEnum (const TValue *l, const TValue *r) {
  if (ttisinteger(l)) {
    lua_Integer li = ivalue(l);
    if (ttisinteger(r))
      return li <= ivalue(r);  /* both are integers */
    else  /* 'l' is int and 'r' is float */
      return LEintfloat(li, fltvalue(r));  /* l <= r ? */
  }
  else {
    lua_Number lf = fltvalue(l);  /* 'l' must be float */
    if (ttisfloat(r))
      return luai_numle(lf, fltvalue(r));  /* both are float */
    else if (luai_numisnan(lf))  /* 'r' is int and 'l' is float */
      return 0;  /*  NaN <= i is always false */
    else  /* without NaN, (l <= r)  <-->  not(r < l) */
      return !LTintfloat(ivalue(r), lf);  /* not (r < l) ? */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x13, 0x8(%rax)
jne 0x1a2c0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x13, 0x8(%rax)
jne 0x1a2aa
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1a32f
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x1f3f0
movl %eax, -0x4(%rbp)
jmp 0x1a32f
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x1a2f5
movsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1a32f
movsd -0x28(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jne 0x1a305
jp 0x1a305
jmp 0x1a30e
movl $0x0, -0x4(%rbp)
jmp 0x1a32f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x1f350
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: copy2buff
static void copy2buff (StkId top, int n, char *buff) {
  size_t tl = 0;  /* size already copied */
  do {
    size_t l = vslen(top - n);  /* length of string being copied */
    memcpy(buff + tl, svalue(top - n), l * sizeof(char));
    tl += l;
  } while (--n > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x1ac8c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movzbl 0xb(%rax), %eax
movq %rax, -0x30(%rbp)
jmp 0x1acab
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
addq $0x18, %rsi
movq -0x28(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5300
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jg 0x1ac4b
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3f, %eax
movl %eax, -0x44(%rbp)
subl $0x4, %eax
je 0x1adfd
jmp 0x1ad3c
movl -0x44(%rbp), %eax
subl $0x5, %eax
je 0x1ad57
jmp 0x1ad46
movl -0x44(%rbp), %eax
subl $0x14, %eax
je 0x1ae26
jmp 0x1ae4d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1ad75
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x1adbe
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movzbl 0xa(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1ad91
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x1adb6
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x100(%rax), %rdx
movl $0x4, %esi
callq 0x185d0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1add2
jmp 0x1ae83
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x18040
movslq %eax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl $0x13, 0x8(%rax)
jmp 0x1aea2
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl 0xb(%rax), %eax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x13, 0x8(%rax)
jmp 0x1aea2
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl $0x13, 0x8(%rax)
jmp 0x1aea2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x18640
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1ae81
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x1a6de(%rip), %rdx     # 0x3555a
callq 0x9870
jmp 0x1ae83
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x1, %r9d
callq 0x187d0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq $0x1, %rax
ja 0x1aef7
cmpq $0x0, -0x20(%rbp)
jne 0x1aeeb
movq -0x10(%rbp), %rdi
leaq 0x1a684(%rip), %rsi     # 0x35568
movb $0x0, %al
callq 0x98e0
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1af37
movq -0x18(%rbp), %rax
cqto
idivq -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
xorq -0x20(%rbp), %rax
cmpq $0x0, %rax
jge 0x1af2f
movq -0x18(%rbp), %rax
cqto
idivq -0x20(%rbp)
cmpq $0x0, %rdx
je 0x1af2f
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq $0x1, %rax
ja 0x1af95
cmpq $0x0, -0x20(%rbp)
jne 0x1af8b
movq -0x10(%rbp), %rdi
leaq 0x1a5fe(%rip), %rsi     # 0x35582
movb $0x0, %al
callq 0x98e0
movq $0x0, -0x8(%rbp)
jmp 0x1afcc
movq -0x18(%rbp), %rax
cqto
idivq -0x20(%rbp)
movq %rdx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1afc4
movq -0x18(%rbp), %rax
xorq -0x20(%rbp), %rax
cmpq $0x0, %rax
jge 0x1afc4
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x1b017
cmpq $-0x40, -0x18(%rbp)
jg 0x1b004
movq $0x0, -0x8(%rbp)
jmp 0x1b037
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
shrq %cl, %rax
movq %rax, -0x8(%rbp)
jmp 0x1b037
cmpq $0x40, -0x18(%rbp)
jl 0x1b028
movq $0x0, -0x8(%rbp)
jmp 0x1b037
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %cl, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lvm.c
// Function: forlimit
static int forlimit (const TValue *obj, lua_Integer *p, lua_Integer step,
                     int *stopnow) {
  *stopnow = 0;  /* usually, let loops run */
  if (!luaV_tointeger(obj, p, (step < 0 ? 2 : 1))) {  /* not fit in integer? */
    lua_Number n;  /* try to convert to float */
    if (!tonumber(obj, &n)) /* cannot convert to float? */
      return 0;  /* not a number */
    if (luai_numlt(0, n)) {  /* if true, float is larger than max integer */
      *p = LUA_MAXINTEGER;
      if (step < 0) *stopnow = 1;
    }
    else {  /* float is smaller than min integer */
      *p = LUA_MININTEGER;
      if (step >= 0) *stopnow = 1;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
movl $0x2, %eax
cmpq $0x0, %rcx
cmovll %eax, %edx
callq 0x19870
cmpl $0x0, %eax
jne 0x1f0ef
movq -0x10(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x1f07c
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x1f097
jmp 0x1f08e
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x19780
cmpl $0x0, %eax
jne 0x1f097
movl $0x0, -0x4(%rbp)
jmp 0x1f0f6
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1f0c9
movq -0x18(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
jge 0x1f0c7
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
jmp 0x1f0ed
movq -0x18(%rbp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
jl 0x1f0eb
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
jmp 0x1f0ed
jmp 0x1f0ef
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop