LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_init
void luaS_init (lua_State *L) {
  global_State *g = G(L);
  int i, j;
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  /* pre-create memory-error message */
  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
  luaC_fix(L, obj2gco(g->memerrmsg));  /* it should never be collected */
  for (i = 0; i < STRCACHE_N; i++)  /* fill cache with valid strings */
    for (j = 0; j < STRCACHE_M; j++)
      g->strcache[i][j] = g->memerrmsg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movl $0x80, %esi
callq 0xf689
leaq 0x134a0(%rip), %rsi     # 0x22c7b
movl $0x11, %edx
movq %rbx, %rdi
callq 0xf828
movq %rax, 0xd8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa276
movq 0xd8(%r14), %rax
xorl %ecx, %ecx
movq %rax, 0x1e8(%r14,%rcx)
movq %rax, 0x1f0(%r14,%rcx)
addq $0x10, %rcx
cmpq $0x350, %rcx            # imm = 0x350
jne 0xf803
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_newlstr
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
  if (l <= LUAI_MAXSHORTLEN)  /* short string? */
    return internshrstr(L, str, l);
  else {
    TString *ts;
    if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
      luaM_toobig(L);
    ts = luaS_createlngstrobj(L, l);
    memcpy(getstr(ts), str, l * sizeof(char));
    return ts;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpq $0x28, %rdx
ja 0xf8d5
movq %rdi, (%rsp)
movq 0x18(%rdi), %r8
movl 0x50(%r8), %ebp
xorl %ebx, %ebp
testq %rbx, %rbx
je 0xf887
movq %rbx, %rax
shrq $0x5, %rax
movq %rax, %rcx
notq %rcx
movq %rbx, %rdx
movl %ebp, %esi
shll $0x5, %esi
movl %ebp, %edi
shrl $0x2, %edi
addl %esi, %edi
movzbl -0x1(%r14,%rdx), %esi
addl %edi, %esi
xorl %esi, %ebp
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0xf869
movq 0x30(%r8), %rcx
movq %r8, 0x8(%rsp)
movl 0x3c(%r8), %r13d
leal -0x1(%r13), %eax
andl %ebp, %eax
movslq %eax, %r15
movq %rcx, 0x10(%rsp)
movq (%rcx,%r15,8), %r12
testq %r12, %r12
je 0xf929
movzbl 0xb(%r12), %eax
cmpq %rbx, %rax
jne 0xf8ce
leaq 0x18(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5380
testl %eax, %eax
je 0xf977
movq 0x10(%r12), %r12
jmp 0xf8a6
movabsq $0x7fffffffffffffe7, %rax # imm = 0x7FFFFFFFFFFFFFE7
cmpq %rax, %rbx
jae 0xf9f6
movq 0x18(%rdi), %rax
movl 0x50(%rax), %ebp
leaq 0x19(%rbx), %rdx
movl $0x14, %esi
callq 0xa297
movq %rax, %r12
movl %ebp, 0xc(%rax)
xorl %eax, %eax
movb %al, 0xa(%r12)
leaq 0x18(%r12), %rdi
movb %al, 0x18(%r12,%rbx)
movq %rbx, 0x10(%r12)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5310
jmp 0xf9e4
movq 0x10(%rsp), %rax
leaq (%rax,%r15,8), %r15
cmpl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
jg 0xf994
movq 0x8(%rsp), %r12
cmpl %r13d, 0x38(%r12)
movq (%rsp), %rdi
jl 0xf99d
addl %r13d, %r13d
movq (%rsp), %rdi
movl %r13d, %esi
callq 0xf689
movq (%rsp), %rdi
movslq 0x3c(%r12), %rax
decq %rax
movslq %ebp, %r15
andq %rax, %r15
shlq $0x3, %r15
addq 0x30(%r12), %r15
jmp 0xf99d
movb 0x9(%r12), %al
xorb $0x3, %al
movq 0x8(%rsp), %rcx
movb 0x54(%rcx), %cl
xorb $0x3, %cl
testb %al, %cl
jne 0xf9e4
movb %al, 0x9(%r12)
jmp 0xf9e4
movq 0x8(%rsp), %r12
movq (%rsp), %rdi
leaq 0x19(%rbx), %rdx
movl $0x4, %esi
callq 0xa297
movq %r12, %r13
movq %rax, %r12
movl %ebp, 0xc(%rax)
xorl %eax, %eax
movb %al, 0xa(%r12)
leaq 0x18(%r12), %rdi
movb %al, 0x18(%r12,%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5310
movb %bl, 0xb(%r12)
movq (%r15), %rax
movq %rax, 0x10(%r12)
movq %r12, (%r15)
incl 0x38(%r13)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb914
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_remove
void luaS_remove (lua_State *L, TString *ts) {
  stringtable *tb = &G(L)->strt;
  TString **p = &tb->hash[lmod(ts->hash, tb->size)];
  while (*p != ts)  /* find previous element */
    p = &(*p)->u.hnext;
  *p = (*p)->u.hnext;  /* remove element from its list */
  tb->nuse--;
}

// Assembly:
movq 0x18(%rdi), %rax
movslq 0xc(%rsi), %rdx
movslq 0x3c(%rax), %rcx
decq %rcx
andq %rdx, %rcx
shlq $0x3, %rcx
addq 0x30(%rax), %rcx
movq %rcx, %rdx
movq (%rcx), %rdi
leaq 0x10(%rdi), %rcx
cmpq %rsi, %rdi
jne 0xfa47
movq (%rcx), %rcx
movq %rcx, (%rdx)
decl 0x38(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_new
TString *luaS_new (lua_State *L, const char *str) {
  unsigned int i = point2uint(str) % STRCACHE_N;  /* hash */
  int j;
  TString **p = G(L)->strcache[i];
  for (j = 0; j < STRCACHE_M; j++) {
    if (strcmp(str, getstr(p[j])) == 0)  /* hit? */
      return p[j];  /* that is it */
  }
  /* normal route */
  for (j = STRCACHE_M - 1; j > 0; j--)
    p[j] = p[j - 1];  /* move out last element */
  /* new element is first in the list */
  p[0] = luaS_newlstr(L, str, strlen(str));
  return p[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %ebx, %eax
imulq $0x3521cfb3, %rax, %rax # imm = 0x3521CFB3
shrq $0x20, %rax
movl %ebx, %ecx
subl %eax, %ecx
shrl %ecx
addl %eax, %ecx
shrl $0x5, %ecx
imull $0x35, %ecx, %eax
movl %ebx, %ecx
subl %eax, %ecx
movq 0x18(%rdi), %rax
shll $0x4, %ecx
leaq (%rax,%rcx), %r12
addq $0x1e8, %r12            # imm = 0x1E8
movb $0x1, %bpl
xorl %eax, %eax
movq (%r12,%rax,8), %r15
leaq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x5280
testl %eax, %eax
je 0xfaee
movl $0x1, %eax
testb $0x1, %bpl
movl $0x0, %ebp
jne 0xfaa4
movq (%r12), %rax
movq %rax, 0x8(%r12)
movq %rbx, %rdi
callq 0x5140
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf828
movq %rax, %r15
movq %rax, (%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_newudata
Udata *luaS_newudata (lua_State *L, size_t s) {
  Udata *u;
  GCObject *o;
  if (s > MAX_SIZE - sizeof(Udata))
    luaM_toobig(L);
  o = luaC_newobj(L, LUA_TUSERDATA, sizeludata(s));
  u = gco2u(o);
  u->len = s;
  u->metatable = NULL;
  setuservalue(L, u, luaO_nilobject);
  return u;
}

// Assembly:
pushq %rbx
movabsq $0x7fffffffffffffd8, %rax # imm = 0x7FFFFFFFFFFFFFD8
cmpq %rax, %rsi
jae 0xfb3d
movq %rsi, %rbx
leaq 0x28(%rsi), %rdx
movl $0x7, %esi
callq 0xa297
movq %rbx, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq 0x12b22(%rip), %rcx     # 0x22650
movq %rcx, 0x20(%rax)
movb 0x12b20(%rip), %cl      # 0x22658
movb %cl, 0xa(%rax)
popq %rbx
retq
callq 0xb914
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_next
int luaH_next (lua_State *L, Table *t, StkId key) {
  unsigned int i = findindex(L, t, key);  /* find original element */
  for (; i < t->sizearray; i++) {  /* try first array part */
    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
      setivalue(key, i + 1);
      setobj2s(L, key+1, &t->array[i]);
      return 1;
    }
  }
  for (i -= t->sizearray; cast_int(i) < sizenode(t); i++) {  /* hash part */
    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
      setobj2s(L, key, gkey(gnode(t, i)));
      setobj2s(L, key+1, gval(gnode(t, i)));
      return 1;
    }
  }
  return 0;  /* no more elements */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdx), %eax
cmpl $0x13, %eax
je 0xfb6f
testl %eax, %eax
jne 0xfb93
movl 0xc(%r14), %eax
xorl %edx, %edx
jmp 0xfc18
movq (%rbx), %rdx
movabsq $-0x80000001, %rax      # imm = 0xFFFFFFFF7FFFFFFF
addq %rdx, %rax
cmpq $-0x80000000, %rax      # imm = 0x80000000
jb 0xfb93
movl 0xc(%r14), %eax
cmpl %edx, %eax
jae 0xfc18
movq %r14, %rdi
movq %rbx, %rsi
callq 0x104a6
movq %rax, %r12
movq %rax, %r13
addq $0x10, %r13
xorl %edi, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x11deb
testl %eax, %eax
je 0xfbbe
movq %r12, %rbp
jmp 0xfc07
cmpl $0xa, 0x18(%r12)
jne 0xfbd5
testb $0x40, 0x8(%rbx)
je 0xfbd5
movq (%r13), %rax
cmpq (%rbx), %rax
je 0xfbb9
movslq 0x1c(%r12), %rax
testq %rax, %rax
je 0xfcb1
shlq $0x5, %rax
leaq (%r12,%rax), %rbp
leaq (%r12,%rax), %r13
addq $0x10, %r13
xorl %edi, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x11deb
movq %rbp, %r12
testl %eax, %eax
je 0xfbbe
subq 0x18(%r14), %rbp
shrq $0x5, %rbp
movl 0xc(%r14), %eax
leal (%rax,%rbp), %edx
incl %edx
movl %eax, %esi
subl %edx, %esi
jbe 0xfc42
movq 0x10(%r14), %rdi
movl %edx, %edx
movq %rdx, %rcx
shlq $0x4, %rcx
incq %rdx
cmpl $0x0, 0x8(%rdi,%rcx)
jne 0xfc71
addq $0x10, %rcx
incq %rdx
decl %esi
jne 0xfc2e
movl %eax, %edx
movb 0xb(%r14), %cl
movl $0x1, %esi
shll %cl, %esi
subl %eax, %edx
xorl %eax, %eax
cmpl %esi, %edx
jge 0xfca2
movq 0x18(%r14), %rcx
movl %edx, %edx
movq %rdx, %rdi
shlq $0x5, %rdi
cmpl $0x0, 0x8(%rcx,%rdi)
jne 0xfc87
incl %edx
cmpl %edx, %esi
jne 0xfc59
jmp 0xfca2
movl %edx, %eax
movq %rax, (%rbx)
movl $0x13, 0x8(%rbx)
movq 0x10(%r14), %rax
movups (%rax,%rcx), %xmm0
jmp 0xfc99
addq %rdi, %rcx
movups 0x10(%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x18(%r14), %rax
movups (%rax,%rdi), %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13046(%rip), %rsi     # 0x22cfe
movq %r15, %rdi
xorl %eax, %eax
callq 0x7dd3
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: setnodevector
static void setnodevector (lua_State *L, Table *t, unsigned int size) {
  int lsize;
  if (size == 0) {  /* no elements to hash part? */
    t->node = cast(Node *, dummynode);  /* use common 'dummynode' */
    lsize = 0;
  }
  else {
    int i;
    lsize = luaO_ceillog2(size);
    if (lsize > MAXHBITS)
      luaG_runerror(L, "table overflow");
    size = twoto(lsize);
    t->node = luaM_newvector(L, size, Node);
    for (i = 0; i < (int)size; i++) {
      Node *n = gnode(t, i);
      gnext(n) = 0;
      setnilvalue(wgkey(n));
      setnilvalue(gval(n));
    }
  }
  t->lsizenode = cast_byte(lsize);
  t->lastfree = gnode(t, size);  /* all positions are free */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
je 0xffc3
movq %rdi, %r15
movl %edx, %edi
callq 0xb98d
cmpl $0x1f, %eax
jge 0xffef
movl %eax, %r14d
movl $0x1, %r12d
movl %r14d, %ecx
shll %cl, %r12d
movq %r12, %rcx
shlq $0x5, %rcx
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb897
movq %rax, 0x18(%rbx)
movl $0x1c, %eax
movq %r12, %rcx
movq 0x18(%rbx), %rdx
movq $0x0, -0x4(%rdx,%rax)
movl $0x0, -0x14(%rdx,%rax)
addq $0x20, %rax
decq %rcx
jne 0xff9f
movq 0x18(%rbx), %rax
jmp 0xffd4
leaq 0x12cee(%rip), %rax     # 0x22cb8
movq %rax, 0x18(%rbx)
xorl %r14d, %r14d
xorl %r12d, %r12d
movb %r14b, 0xb(%rbx)
shlq $0x5, %r12
addq %rax, %r12
movq %r12, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x12d1e(%rip), %rsi     # 0x22d14
movq %r15, %rdi
xorl %eax, %eax
callq 0x7dd3
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_setint
void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
  const TValue *p = luaH_getint(t, key);
  TValue *cell;
  if (p != luaO_nilobject)
    cell = cast(TValue *, p);
  else {
    TValue k;
    setivalue(&k, key);
    cell = luaH_newkey(L, t, &k);
  }
  setobj2t(L, cell, value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x105a5
leaq 0x12627(%rip), %rcx     # 0x22650
cmpq %rcx, %rax
jne 0x10048
leaq 0x8(%rsp), %rdx
movq %r12, (%rdx)
movl $0x13, 0x8(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x10155
movups (%rbx), %xmm0
movups %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_set
TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
  const TValue *p = luaH_get(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else return luaH_newkey(L, t, key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x106ef
leaq 0x125d6(%rip), %rcx     # 0x22650
cmpq %rcx, %rax
je 0x10085
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x10155
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_new
Table *luaH_new (lua_State *L) {
  GCObject *o = luaC_newobj(L, LUA_TTABLE, sizeof(Table));
  Table *t = gco2t(o);
  t->metatable = NULL;
  t->flags = cast_byte(~0);
  t->array = NULL;
  t->sizearray = 0;
  setnodevector(L, t, 0);
  return t;
}

// Assembly:
pushq %rax
movl $0x38, %edx
movl $0x5, %esi
callq 0xa297
xorl %ecx, %ecx
movq %rcx, 0x28(%rax)
movw $0xff, 0xa(%rax)
movq %rcx, 0x10(%rax)
movl $0x0, 0xc(%rax)
leaq 0x12bd0(%rip), %rcx     # 0x22cb8
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_free
void luaH_free (lua_State *L, Table *t) {
  if (!isdummy(t->node))
    luaM_freearray(L, t->node, cast(size_t, sizenode(t)));
  luaM_freearray(L, t->array, t->sizearray);
  luaM_free(L, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
leaq 0x12bb1(%rip), %rax     # 0x22cb8
cmpq %rax, %rsi
je 0x10127
movb 0xb(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdx
shlq $0x5, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb897
movq 0x10(%rbx), %rsi
movl 0xc(%rbx), %edx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb897
movl $0x38, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb897
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: mainposition
static Node *mainposition (const Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TNUMINT:
      return hashint(t, ivalue(key));
    case LUA_TNUMFLT:
      return hashmod(t, l_hashfloat(fltvalue(key)));
    case LUA_TSHRSTR:
      return hashstr(t, tsvalue(key));
    case LUA_TLNGSTR:
      return hashpow2(t, luaS_hashlongstr(tsvalue(key)));
    case LUA_TBOOLEAN:
      return hashboolean(t, bvalue(key));
    case LUA_TLIGHTUSERDATA:
      return hashpointer(t, pvalue(key));
    case LUA_TLCF:
      return hashpointer(t, fvalue(key));
    default:
      lua_assert(!ttisdeadkey(key));
      return hashpointer(t, gcvalue(key));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x8(%rsi), %eax
andl $0x3f, %eax
movq 0x18(%rdi), %rbx
cmpl $0x12, %eax
jg 0x1052f
decl %eax
cmpl $0x3, %eax
ja 0x1054f
leaq 0x127da(%rip), %rcx     # 0x22ca8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd (%rsi), %xmm0
leaq 0x4(%rsp), %rdi
callq 0x5260
mulsd 0x127a3(%rip), %xmm0    # 0x22c90
xorl %eax, %eax
ucomisd 0x127a1(%rip), %xmm0    # 0x22c98
jb 0x10517
movsd 0x1279f(%rip), %xmm1    # 0x22ca0
ucomisd %xmm0, %xmm1
jbe 0x10517
cvttsd2si %xmm0, %rcx
addl 0x4(%rsp), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
movb 0xb(%r14), %cl
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shll %cl, %esi
notl %esi
orl $0x1, %esi
cltd
idivl %esi
movslq %edx, %rdx
jmp 0x10593
cmpl $0x16, %eax
je 0x1054f
cmpl $0x14, %eax
je 0x1057c
cmpl $0x13, %eax
jne 0x1054f
movb 0xb(%r14), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
andl (%rsi), %edx
jmp 0x10593
movb 0xb(%r14), %cl
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
shll %cl, %edi
movl (%rsi), %eax
notl %edi
orl $0x1, %edi
xorl %edx, %edx
divl %edi
jmp 0x10593
movb 0xb(%r14), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
movq (%rsi), %rax
notl %edx
andl 0xc(%rax), %edx
jmp 0x10593
movq (%rsi), %rdi
callq 0xf637
movb 0xb(%r14), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
andl %eax, %edx
shlq $0x5, %rdx
addq %rdx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_getint
const TValue *luaH_getint (Table *t, lua_Integer key) {
  /* (1 <= key && key <= t->sizearray) */
  if (l_castS2U(key) - 1 < t->sizearray)
    return &t->array[key - 1];
  else {
    Node *n = hashint(t, key);
    for (;;) {  /* check whether 'key' is somewhere in the chain */
      if (ttisinteger(gkey(n)) && ivalue(gkey(n)) == key)
        return gval(n);  /* that's it */
      else {
        int nx = gnext(n);
        if (nx == 0) break;
        n += nx;
      }
    }
    return luaO_nilobject;
  }
}

// Assembly:
leaq -0x1(%rsi), %rax
movl 0xc(%rdi), %ecx
cmpq %rcx, %rax
jae 0x105ba
shlq $0x4, %rax
addq 0x10(%rdi), %rax
retq
movb 0xb(%rdi), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
movl %esi, %eax
andl %edx, %eax
shlq $0x5, %rax
addq 0x18(%rdi), %rax
leaq 0x12077(%rip), %rcx     # 0x22650
cmpl $0x13, 0x18(%rax)
jne 0x105e5
cmpq %rsi, 0x10(%rax)
je 0x105b9
movslq 0x1c(%rax), %rdx
movq %rdx, %rdi
shlq $0x5, %rdi
addq %rdi, %rax
testq %rdx, %rdx
jne 0x105d9
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_getshortstr
const TValue *luaH_getshortstr (Table *t, TString *key) {
  Node *n = hashstr(t, key);
  lua_assert(key->tt == LUA_TSHRSTR);
  for (;;) {  /* check whether 'key' is somewhere in the chain */
    const TValue *k = gkey(n);
    if (ttisshrstring(k) && eqshrstr(tsvalue(k), key))
      return gval(n);  /* that's it */
    else {
      int nx = gnext(n);
      if (nx == 0)
        return luaO_nilobject;  /* not found */
      n += nx;
    }
  }
}

// Assembly:
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rsi), %eax
shlq $0x5, %rax
addq 0x18(%rdi), %rax
leaq 0x12036(%rip), %rcx     # 0x22650
cmpl $0x44, 0x18(%rax)
jne 0x10626
cmpq %rsi, 0x10(%rax)
je 0x1063c
movslq 0x1c(%rax), %rdx
movq %rdx, %rdi
shlq $0x5, %rdi
addq %rdi, %rax
testq %rdx, %rdx
jne 0x1061a
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_getstr
const TValue *luaH_getstr (Table *t, TString *key) {
  if (key->tt == LUA_TSHRSTR)
    return luaH_getshortstr(t, key);
  else {  /* for long strings, use generic case */
    TValue ko;
    setsvalue(cast(lua_State *, NULL), &ko, key);
    return getgeneric(t, &ko);
  }
}

// Assembly:
subq $0x18, %rsp
movzbl 0x8(%rsi), %ecx
cmpl $0x4, %ecx
jne 0x1068c
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rsi), %eax
shlq $0x5, %rax
addq 0x18(%rdi), %rax
leaq 0x11fe8(%rip), %rcx     # 0x22650
cmpl $0x44, 0x18(%rax)
jne 0x10674
cmpq %rsi, 0x10(%rax)
je 0x106a2
movslq 0x1c(%rax), %rdx
movq %rdx, %rdi
shlq $0x5, %rdi
addq %rdi, %rax
testq %rdx, %rdx
jne 0x10668
movq %rcx, %rax
jmp 0x106a2
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
orl $0x40, %ecx
movl %ecx, 0x8(%rax)
movq %rax, %rsi
callq 0x106a7
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: getgeneric
static const TValue *getgeneric (Table *t, const TValue *key) {
  Node *n = mainposition(t, key);
  for (;;) {  /* check whether 'key' is somewhere in the chain */
    if (luaV_rawequalobj(gkey(n), key))
      return gval(n);  /* that's it */
    else {
      int nx = gnext(n);
      if (nx == 0)
        return luaO_nilobject;  /* not found */
      n += nx;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x104a6
movq %rax, %r14
leaq 0x11f92(%rip), %r15     # 0x22650
leaq 0x10(%r14), %rsi
xorl %edi, %edi
movq %rbx, %rdx
callq 0x11deb
testl %eax, %eax
jne 0x106e6
movslq 0x1c(%r14), %rax
movq %rax, %rcx
shlq $0x5, %rcx
addq %rcx, %r14
testq %rax, %rax
jne 0x106be
movq %r15, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_get
const TValue *luaH_get (Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TSHRSTR: return luaH_getshortstr(t, tsvalue(key));
    case LUA_TNUMINT: return luaH_getint(t, ivalue(key));
    case LUA_TNIL: return luaO_nilobject;
    case LUA_TNUMFLT: {
      lua_Integer k;
      if (luaV_tointeger(key, &k, 0)) /* index is int? */
        return luaH_getint(t, k);  /* use specialized version */
      /* else... */
    }  /* FALLTHROUGH */
    default:
      return getgeneric(t, key);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %ecx
andl $0x3f, %ecx
leaq 0x11f4a(%rip), %rax     # 0x22650
cmpl $0x3, %ecx
jg 0x10733
testl %ecx, %ecx
je 0x10783
cmpl $0x3, %ecx
jne 0x10778
movq %rsp, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x116b2
testl %eax, %eax
je 0x10778
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x105a5
jmp 0x10783
cmpl $0x13, %ecx
je 0x1078b
cmpl $0x4, %ecx
jne 0x10778
movb 0xb(%rbx), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
movq (%r14), %rcx
notl %edx
andl 0xc(%rcx), %edx
shlq $0x5, %rdx
addq 0x18(%rbx), %rdx
cmpl $0x44, 0x18(%rdx)
jne 0x10763
cmpq %rcx, 0x10(%rdx)
je 0x1079d
movslq 0x1c(%rdx), %rsi
movq %rsi, %rdi
shlq $0x5, %rdi
addq %rdi, %rdx
testq %rsi, %rsi
jne 0x10757
jmp 0x10783
movq %rbx, %rdi
movq %r14, %rsi
callq 0x106a7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x105a5
movq %rdx, %rax
jmp 0x10783
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_getn
int luaH_getn (Table *t) {
  unsigned int j = t->sizearray;
  if (j > 0 && ttisnil(&t->array[j - 1])) {
    /* there is a boundary in the array part: (binary) search for it */
    unsigned int i = 0;
    while (j - i > 1) {
      unsigned int m = (i+j)/2;
      if (ttisnil(&t->array[m - 1])) j = m;
      else i = m;
    }
    return i;
  }
  /* else must find a boundary in hash part */
  else if (isdummy(t->node))  /* hash part is empty? */
    return j;  /* that is easy... */
  else return unbound_search(t, j);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r12d
testl %r12d, %r12d
je 0x107ca
movq 0x10(%rbx), %rax
leal -0x1(%r12), %ecx
shlq $0x4, %rcx
cmpl $0x0, 0x8(%rax,%rcx)
je 0x1081b
leaq 0x124e7(%rip), %rax     # 0x22cb8
cmpq %rax, 0x18(%rbx)
je 0x10892
leal 0x1(%r12), %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x105a5
cmpl $0x0, 0x8(%rax)
je 0x10856
cmpl $0x40000000, %r14d      # imm = 0x40000000
jae 0x10897
leal (%r14,%r14), %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x105a5
cmpl $0x0, 0x8(%rax)
movl %r14d, %r12d
movl %r15d, %r14d
jne 0x107f1
jmp 0x10859
xorl %r14d, %r14d
cmpl $0x1, %r12d
je 0x108b2
xorl %ecx, %ecx
leal (%rcx,%r12), %r14d
shrl %r14d
leal -0x1(%r14), %edx
shlq $0x4, %rdx
cmpl $0x0, 0x8(%rax,%rdx)
jne 0x10846
movl %r14d, %r12d
movl %ecx, %r14d
movl %r12d, %edx
subl %r14d, %edx
movl %r14d, %ecx
cmpl $0x1, %edx
ja 0x1082a
jmp 0x108b2
movl %r14d, %r15d
movl %r15d, %eax
subl %r12d, %eax
cmpl $0x2, %eax
jb 0x10892
leal (%r15,%r12), %r14d
shrl %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x105a5
cmpl $0x0, 0x8(%rax)
jne 0x10882
movl %r14d, %r15d
movl %r12d, %r14d
movl %r15d, %eax
subl %r14d, %eax
movl %r14d, %r12d
cmpl $0x1, %eax
ja 0x10864
jmp 0x108b2
movl %r12d, %r14d
jmp 0x108b2
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leal 0x2(%r14), %esi
movq %rbx, %rdi
callq 0x105a5
incl %r14d
cmpl $0x0, 0x8(%rax)
jne 0x1089d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: countint
static int countint (const TValue *key, unsigned int *nums) {
  unsigned int k = arrayindex(key);
  if (k != 0) {  /* is 'key' an appropriate array index? */
    nums[luaO_ceillog2(k)]++;  /* count as such */
    return 1;
  }
  else
    return 0;
}

// Assembly:
xorl %eax, %eax
cmpl $0x13, 0x8(%rdi)
jne 0x108f6
movq (%rdi), %rdi
movabsq $-0x80000001, %rcx      # imm = 0xFFFFFFFF7FFFFFFF
addq %rdi, %rcx
cmpq $-0x80000000, %rcx      # imm = 0x80000000
jb 0x108f6
pushq %rbx
movq %rsi, %rbx
callq 0xb98d
cltq
incl (%rbx,%rax,4)
movl $0x1, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_init
void luaT_init (lua_State *L) {
  static const char *const luaT_eventname[] = {  /* ORDER TM */
    "__index", "__newindex",
    "__gc", "__mode", "__len", "__eq",
    "__add", "__sub", "__mul", "__mod", "__pow",
    "__div", "__idiv",
    "__band", "__bor", "__bxor", "__shl", "__shr",
    "__unm", "__bnot", "__lt", "__le",
    "__concat", "__call"
  };
  int i;
  for (i=0; i<TM_N; i++) {
    G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
    luaC_fix(L, obj2gco(G(L)->tmname[i]));  /* never collect these names */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x1251a(%rip), %r15     # 0x22e24
movslq (%r14,%r15), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0xfa60
movq 0x18(%rbx), %rcx
movq %rax, 0xe0(%rcx,%r14,2)
movq 0x18(%rbx), %rax
movq 0xe0(%rax,%r14,2), %rsi
movq %rbx, %rdi
callq 0xa276
addq $0x4, %r14
cmpq $0x60, %r14
jne 0x1090a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_gettm
const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
  const TValue *tm = luaH_getshortstr(events, ename);
  lua_assert(event <= TM_EQ);
  if (ttisnil(tm)) {  /* no tag method? */
    events->flags |= cast_byte(1u<<event);  /* cache this fact */
    return NULL;
  }
  else return tm;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x105fc
cmpl $0x0, 0x8(%rax)
jne 0x1096d
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
orb %al, 0xa(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_gettmbyobj
const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
  Table *mt;
  switch (ttnov(o)) {
    case LUA_TTABLE:
      mt = hvalue(o)->metatable;
      break;
    case LUA_TUSERDATA:
      mt = uvalue(o)->metatable;
      break;
    default:
      mt = G(L)->mt[ttnov(o)];
  }
  return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject);
}

// Assembly:
movl 0x8(%rsi), %eax
andl $0xf, %eax
cmpq $0x7, %rax
je 0x1098e
cmpl $0x5, %eax
jne 0x10997
movq (%rsi), %rax
addq $0x28, %rax
jmp 0x109a5
movq (%rsi), %rax
addq $0x10, %rax
jmp 0x109a5
movq 0x18(%rdi), %rcx
leaq (%rcx,%rax,8), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq (%rax), %rax
testq %rax, %rax
je 0x109c3
movq 0x18(%rdi), %rcx
movl %edx, %edx
movq 0xe0(%rcx,%rdx,8), %rsi
movq %rax, %rdi
jmp 0x105fc
leaq 0x11c86(%rip), %rax     # 0x22650
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_objtypename
const char *luaT_objtypename (lua_State *L, const TValue *o) {
  Table *mt;
  if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) ||
      (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) {
    const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name"));
    if (ttisstring(name))  /* is '__name' a string? */
      return getstr(tsvalue(name));  /* use it as type name */
  }
  return ttypename(ttnov(o));  /* else use standard type name */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x47, %eax
je 0x109f2
cmpl $0x45, %eax
jne 0x10a33
movq (%rbx), %rax
movq 0x28(%rax), %r14
testq %r14, %r14
jne 0x109fe
movl $0x45, %eax
jmp 0x10a33
movq (%rbx), %rax
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x10a2e
leaq 0x123d8(%rip), %rsi     # 0x22ddd
callq 0xfa60
movq %r14, %rdi
movq %rax, %rsi
callq 0x105fc
movl 0x8(%rax), %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
jne 0x10a29
movq (%rax), %rax
addq $0x18, %rax
jmp 0x10a42
movl 0x8(%rbx), %eax
jmp 0x10a33
movl $0x47, %eax
andl $0xf, %eax
leaq 0x1e6a3(%rip), %rcx     # 0x2f0e0
movq 0x8(%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_callTM
void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
                  const TValue *p2, TValue *p3, int hasres) {
  ptrdiff_t result = savestack(L, p3);
  StkId func = L->top;
  setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
  setobj2s(L, func + 1, p1);  /* 1st argument */
  setobj2s(L, func + 2, p2);  /* 2nd argument */
  L->top += 3;
  if (!hasres)  /* no result? 'p3' is third argument */
    setobj2s(L, L->top++, p3);  /* 3rd argument */
  /* metamethod may yield only when called from Lua code */
  if (isLua(L->ci))
    luaD_call(L, func, hasres);
  else
    luaD_callnoyield(L, func, hasres);
  if (hasres) {  /* if has result, move it to its place */
    p3 = restorestack(L, result);
    setobjs2s(L, p3, --L->top);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r9d, %ebp
movq %rdi, %rbx
movq %r8, %r14
subq 0x38(%rdi), %r14
movq %rsi, %rax
movq 0x10(%rdi), %rsi
movups (%rax), %xmm0
movups %xmm0, (%rsi)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%rsi)
movups (%rcx), %xmm0
movups %xmm0, 0x20(%rsi)
movq 0x10(%rdi), %rcx
leaq 0x30(%rcx), %rax
movq %rax, 0x10(%rdi)
testl %r9d, %r9d
jne 0x10a96
addq $0x40, %rcx
movq %rcx, 0x10(%rbx)
movups (%r8), %xmm0
movups %xmm0, (%rax)
movq 0x20(%rbx), %rax
testb $0x2, 0x42(%rax)
jne 0x10aac
movq %rbx, %rdi
movl %ebp, %edx
callq 0x90be
jmp 0x10ab6
movq %rbx, %rdi
movl %ebp, %edx
callq 0x905c
testl %ebp, %ebp
je 0x10ad3
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq -0x10(%rax), %rdx
movq %rdx, 0x10(%rbx)
movups -0x10(%rax), %xmm0
movups %xmm0, (%rcx,%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10974
cmpl $0x0, 0x8(%rax)
jne 0x10b10
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x10974
cmpl $0x0, 0x8(%rax)
je 0x10b3a
movl $0x1, %ebp
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x10a4a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x10b2f
// File: /workspace/github_c_makefile_star2_O3/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 0x10ad8
testl %eax, %eax
je 0x10b67
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leal -0xd(%r12), %eax
cmpl $0x5, %eax
jae 0x10b84
cmpl $0x3, 0x8(%r14)
jne 0x10b9e
movsd (%r14), %xmm0
movsd %xmm0, (%rsp)
jmp 0x10bad
cmpl $0x13, %r12d
je 0x10b71
cmpl $0x16, %r12d
jne 0x10be4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7f83
movq %rsp, %rsi
movq %r14, %rdi
callq 0x11634
testl %eax, %eax
je 0x10bcd
cmpl $0x3, 0x8(%rbx)
jne 0x10bbe
movsd (%rbx), %xmm0
movsd %xmm0, (%rsp)
jmp 0x10bd6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x11634
testl %eax, %eax
jne 0x10bd6
leaq 0x12210(%rip), %rcx     # 0x22de4
jmp 0x10beb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7fe6
leaq 0x12216(%rip), %rcx     # 0x22e01
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7fa0
// File: /workspace/github_c_makefile_star2_O3/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 0x10ad8
testl %eax, %eax
je 0x10c27
movq 0x10(%rbx), %rcx
movl 0x8(%rcx), %eax
testl %eax, %eax
je 0x10c33
cmpl $0x1, %eax
jne 0x10c2e
xorl %eax, %eax
cmpl $0x0, (%rcx)
setne %al
jmp 0x10c33
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x10c33
movl $0x1, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x10c5b
cmpl $0x40, %eax
je 0x10c56
cmpl $0x3d, %eax
jne 0x10c62
incq %rdx
jmp 0x10c62
leaq 0x12262(%rip), %rdx     # 0x22ec4
leaq 0x8(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rbx, (%r14)
movq %rsi, 0x8(%r14)
leaq 0x11855(%rip), %rsi     # 0x224ce
leaq 0x12252(%rip), %rdx     # 0x22ed2
movq %r14, %rdi
callq 0x11482
movq %rsp, %r15
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x11562
cmpb $0x53, (%r15)
jne 0x10df0
leaq 0x8(%rsp), %rdi
movq %rsp, %r14
movl $0x1, %edx
movq %r14, %rsi
callq 0x11562
cmpb $0x0, (%r14)
jne 0x10df9
leaq 0x11807(%rip), %rsi     # 0x224d2
leaq 0x1221a(%rip), %rdx     # 0x22eec
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x11482
leaq 0x13dca(%rip), %rdx     # 0x24ab0
movl $0x4, %esi
movq %r14, %rdi
callq 0x1150a
leaq 0x121fc(%rip), %rdx     # 0x22ef6
movl $0x8, %esi
movq %r14, %rdi
callq 0x1150a
leaq 0x121ef(%rip), %rdx     # 0x22efd
movl $0x4, %esi
movq %r14, %rdi
callq 0x1150a
leaq 0x121e7(%rip), %rdx     # 0x22f09
movl $0x8, %esi
movq %r14, %rdi
callq 0x1150a
leaq 0x121df(%rip), %rdx     # 0x22f15
movl $0x8, %esi
movq %r14, %rdi
callq 0x1150a
movq %rsp, %r15
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x11562
cmpq $0x5678, (%r15)         # imm = 0x5678
jne 0x10e02
leaq 0x8(%rsp), %rdi
movq %rsp, %r14
movl $0x8, %edx
movq %r14, %rsi
callq 0x11562
movsd (%r14), %xmm0
ucomisd 0x12103(%rip), %xmm0    # 0x22e88
jne 0x10e0b
jp 0x10e0b
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x11562
movzbl (%r15), %esi
movq %rbx, %rdi
callq 0x9e79
movq %rax, %r15
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movl $0x46, 0x8(%rax)
movq %rbx, %rdi
callq 0x89bd
movq %rbx, %rdi
callq 0xa024
movq %rax, 0x18(%r15)
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x10e1c
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x120e1(%rip), %rsi     # 0x22ed8
jmp 0x10e12
leaq 0x1213d(%rip), %rsi     # 0x22f3d
jmp 0x10e12
leaq 0x12117(%rip), %rsi     # 0x22f20
jmp 0x10e12
leaq 0x12125(%rip), %rsi     # 0x22f37
leaq 0x8(%rsp), %rdi
callq 0x114e1
// File: /workspace/github_c_makefile_star2_O3/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 0x5140
movq %rax, %r12
leaq 0x4(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11562
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x5380
testl %eax, %eax
jne 0x114d6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x114e1
// File: /workspace/github_c_makefile_star2_O3/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 0x11562
movzbl (%r14), %eax
movq %rax, 0x8(%rsp)
cmpq $0xff, %rax
jne 0x115ca
leaq 0x8(%rsp), %r14
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11562
movq (%r14), %rax
testq %rax, %rax
je 0x11603
leaq -0x1(%rax), %rdx
movq %rdx, 0x8(%rsp)
cmpq $0x29, %rax
ja 0x11608
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11562
movq (%rbx), %rdi
movq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0xf828
movq %rax, %r14
jmp 0x11627
xorl %r14d, %r14d
jmp 0x11627
movq (%rbx), %rdi
movq %rdx, %rsi
callq 0xf9fb
movq %rax, %r14
leaq 0x18(%rax), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x11562
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1165a
cvtsi2sdq (%r14), %xmm0
movsd %xmm0, (%rbx)
movl $0x1, %ebp
jmp 0x116a0
andl $0xf, %eax
xorl %ebp, %ebp
cmpl $0x4, %eax
jne 0x116a0
movq (%r14), %rdi
addq $0x18, %rdi
movq %rsp, %rsi
callq 0xbcb7
movq (%r14), %rcx
cmpb $0x4, 0x8(%rcx)
jne 0x11682
movzbl 0xb(%rcx), %ecx
jmp 0x11686
movq 0x10(%rcx), %rcx
incq %rcx
cmpq %rcx, %rax
jne 0x116a0
cmpl $0x13, 0x8(%rsp)
movq (%rsp), %rax
je 0x116ab
movq %rax, %xmm0
jmp 0x1164f
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cvtsi2sd %rax, %xmm0
jmp 0x1164f
// File: /workspace/github_c_makefile_star2_O3/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 0x1178a
cmpl $0x3, %eax
je 0x1171e
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x11797
movq (%r12), %rdi
addq $0x18, %rdi
movq %r15, %rsi
callq 0xbcb7
movq (%r12), %rcx
cmpb $0x4, 0x8(%rcx)
jne 0x1170d
movzbl 0xb(%rcx), %ecx
jmp 0x11711
movq 0x10(%rcx), %rcx
incq %rcx
movq %r15, %r12
cmpq %rcx, %rax
je 0x116ce
jmp 0x11797
movsd (%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x5460
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1173d
jnp 0x1174e
testl %ebp, %ebp
je 0x117a7
cmpl $0x2, %ebp
jl 0x1174e
addsd 0x1183a(%rip), %xmm0    # 0x22f88
movsd 0x1154a(%rip), %xmm1    # 0x22ca0
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movsd 0x11531(%rip), %xmm1    # 0x22c98
cmplepd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
testb $0x1, %al
je 0x11780
cvttsd2si %xmm0, %rcx
movq %rcx, (%rbx)
movzbl %al, %r14d
andl $0x1, %r14d
jmp 0x11797
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 0x11797
// File: /workspace/github_c_makefile_star2_O3/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 0x11802
movq (%r12), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x1185a
testb $0x1, 0xa(%rdi)
jne 0x1185a
movq 0x18(%r14), %rax
movq 0xe0(%rax), %rdx
xorl %esi, %esi
callq 0x10949
testq %rax, %rax
je 0x1185a
movq %rax, %r13
movl 0x8(%rax), %eax
jmp 0x1181d
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10974
movq %rax, %r13
movl 0x8(%rax), %eax
testl %eax, %eax
je 0x118a0
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0x6, %ecx
je 0x11863
cmpl $0x45, %eax
jne 0x11840
movq (%r13), %rdi
movq %r15, %rsi
callq 0x106ef
cmpl $0x0, 0x8(%rax)
je 0x11842
jmp 0x1188b
xorl %eax, %eax
movq %r13, %r12
decl %ebp
jne 0x117cb
leaq 0x118e4(%rip), %rsi     # 0x23134
movq %r14, %rdi
xorl %eax, %eax
callq 0x7dd3
movl $0x0, 0x8(%rbx)
jmp 0x11891
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 0x10a4a
movups (%rax), %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x125f0(%rip), %rdx     # 0x23e97
movq %r14, %rdi
movq %r12, %rsi
callq 0x7d95
// File: /workspace/github_c_makefile_star2_O3/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 0x11aab
cmpl $0x3, %ecx
jne 0x11ac9
movl 0x8(%rbx), %edx
movl %edx, %ecx
andl $0xf, %ecx
cmpl $0x3, %ecx
jne 0x11ac9
cmpl $0x13, %eax
jne 0x11af2
movq (%r14), %rcx
cmpl $0x13, %edx
jne 0x11b06
cmpq (%rbx), %rcx
setl %al
jmp 0x11bb8
movl 0x8(%rbx), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x11ac9
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x11bc1
shrl $0x1f, %eax
jmp 0x11bbb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x14, %ecx
callq 0x10bf9
testl %eax, %eax
jns 0x11bbb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x803c
movsd (%r14), %xmm0
cmpl $0x3, %edx
jne 0x11b37
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jmp 0x11b2f
movsd (%rbx), %xmm0
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rcx, %rax
movabsq $0x40000000000001, %rdx # imm = 0x40000000000001
cmpq %rdx, %rax
jae 0x11b6a
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
seta %al
jmp 0x11bb8
ucomisd %xmm0, %xmm0
jp 0x11ba7
movq (%rbx), %rcx
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rcx, %rax
movabsq $0x40000000000001, %rdx # imm = 0x40000000000001
cmpq %rdx, %rax
jae 0x11b8d
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
setae %al
jmp 0x11bb6
movb $0x1, %al
ucomisd 0x1112c(%rip), %xmm0    # 0x22ca0
jae 0x11bb8
ucomisd 0x1111a(%rip), %xmm0    # 0x22c98
jbe 0x11ba7
cvttsd2si %xmm0, %rax
cmpq %rax, %rcx
jmp 0x11aa3
movb $0x1, %al
ucomisd 0x11109(%rip), %xmm0    # 0x22ca0
jae 0x11bb6
ucomisd 0x110f7(%rip), %xmm0    # 0x22c98
jae 0x11bab
xorl %eax, %eax
jmp 0x11bb6
xorl %eax, %eax
jmp 0x11bb8
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_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x4, 0x8(%rdi)
jne 0x11bd9
movzbl 0xb(%rbx), %r15d
jmp 0x11bdd
movq 0x10(%rbx), %r15
addq $0x18, %rbx
leaq 0x18(%rsi), %r14
cmpb $0x4, 0x8(%rsi)
jne 0x11bf2
movzbl 0xb(%rsi), %r12d
jmp 0x11c20
movq 0x10(%rsi), %r12
jmp 0x11c20
movq %rbx, %rdi
callq 0x5140
cmpq %r12, %rax
je 0x11c3b
cmpq %r15, %rax
je 0x11c45
leaq 0x1(%rax), %rcx
addq %rax, %rbx
incq %rbx
subq %rcx, %r15
addq %rax, %r14
incq %r14
subq %rcx, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5390
testl %eax, %eax
je 0x11bf8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
cmpq %r15, %r12
setne %al
jmp 0x11c2f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x11c2f