LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_findupval
UpVal *luaF_findupval (lua_State *L, StkId level) {
  UpVal **pp = &L->openupval;
  UpVal *p;
  UpVal *uv;
  lua_assert(isintwups(L) || L->openupval == NULL);
  while (*pp != NULL && (p = *pp)->v >= level) {
    lua_assert(upisopen(p));
    if (p->v == level)  /* found a corresponding upvalue? */
      return p;  /* return it */
    pp = &p->u.open.next;
  }
  /* not found: create a new upvalue */
  uv = luaM_new(L, UpVal);
  uv->refcount = 0;
  uv->u.open.next = *pp;  /* link it to list of open upvalues */
  uv->u.open.touched = 1;
  *pp = uv;
  uv->v = level;  /* current value lives in the stack */
  if (!isintwups(L)) {  /* thread not in list of threads with upvalues? */
    L->twups = G(L)->twups;  /* link it to the list */
    G(L)->twups = L;
  }
  return uv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rdi), %r15
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
je 0x9f6e
movq (%rcx), %rdx
cmpq %r14, %rdx
jb 0x9f6e
movq %rcx, %rax
cmpq %r14, %rdx
je 0x9fb7
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x9f67
movq (%rcx), %rdx
cmpq %r14, %rdx
jae 0x9f4e
addq $0x10, %rax
movq %rax, %r15
movl $0x20, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb897
movq $0x0, 0x8(%rax)
movq (%r15), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, 0x18(%rax)
movq %rax, (%r15)
movq %r14, (%rax)
cmpq %rbx, 0x50(%rbx)
jne 0x9fb7
movq 0x18(%rbx), %rcx
movq 0xa8(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rbx, 0xa8(%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_close
void luaF_close (lua_State *L, StkId level) {
  UpVal *uv;
  while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
    lua_assert(upisopen(uv));
    L->openupval = uv->u.open.next;  /* remove from 'open' list */
    if (uv->refcount == 0)  /* no references? */
      luaM_free(L, uv);  /* free upvalue */
    else {
      setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
      uv->v = &uv->u.value;  /* now current value lives here */
      luaC_upvalbarrier(L, uv);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x40(%rdi), %rsi
testq %rsi, %rsi
je 0xa01c
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rbx, %rax
jb 0xa01c
movq 0x10(%rsi), %rcx
movq %rcx, 0x40(%r14)
cmpq $0x0, 0x8(%rsi)
je 0xa004
leaq 0x10(%rsi), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq %rcx, (%rsi)
testb $0x40, 0x18(%rsi)
je 0xa013
movq %r14, %rdi
callq 0xa25b
jmp 0xa013
movl $0x20, %edx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb897
movq 0x40(%r14), %rsi
testq %rsi, %rsi
jne 0x9fd0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_freeproto
void luaF_freeproto (lua_State *L, Proto *f) {
  luaM_freearray(L, f->code, f->sizecode);
  luaM_freearray(L, f->p, f->sizep);
  luaM_freearray(L, f->k, f->sizek);
  luaM_freearray(L, f->lineinfo, f->sizelineinfo);
  luaM_freearray(L, f->locvars, f->sizelocvars);
  luaM_freearray(L, f->upvalues, f->sizeupvalues);
  luaM_free(L, f);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rsi
movslq 0x18(%rbx), %rdx
shlq $0x2, %rdx
xorl %ecx, %ecx
callq 0xb897
movq 0x40(%rbx), %rsi
movslq 0x20(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb897
movq 0x30(%rbx), %rsi
movslq 0x14(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb897
movq 0x48(%rbx), %rsi
movslq 0x1c(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb897
movq 0x50(%rbx), %rsi
movslq 0x24(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb897
movq 0x58(%rbx), %rsi
movslq 0x10(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb897
movl $0x78, %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/lfunc.c
// Function: luaF_getlocalname
const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
  int i;
  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
    if (pc < f->locvars[i].endpc) {  /* is variable active? */
      local_number--;
      if (local_number == 0)
        return getstr(f->locvars[i].varname);
    }
  }
  return NULL;  /* not found */
}

// Assembly:
movslq 0x24(%rdi), %rcx
testq %rcx, %rcx
jle 0xa131
movq 0x50(%rdi), %rdi
shlq $0x4, %rcx
xorl %eax, %eax
xorl %r8d, %r8d
cmpl %edx, 0x8(%rdi,%r8)
jg 0xa130
cmpl %edx, 0xc(%rdi,%r8)
jle 0xa127
decl %esi
je 0xa134
addq $0x10, %r8
cmpq %r8, %rcx
jne 0xa115
retq
xorl %eax, %eax
retq
movq (%rdi,%r8), %rax
addq $0x18, %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_barrier_
void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) {
  global_State *g = G(L);
  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
  if (keepinvariant(g))  /* must keep invariant? */
    reallymarkobject(g, v);  /* restore invariant */
  else {  /* sweep phase */
    lua_assert(issweepphase(g));
    makewhite(g, o);  /* mark main obj. as white to avoid other barriers */
  }
}

// Assembly:
movq 0x18(%rdi), %rdi
cmpb $0x1, 0x55(%rdi)
ja 0xa14f
movq %rdx, %rsi
jmp 0xa160
movb 0x9(%rsi), %al
andb $-0x8, %al
movb 0x54(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: reallymarkobject
static void reallymarkobject (global_State *g, GCObject *o) {
 reentry:
  white2gray(o);
  switch (o->tt) {
    case LUA_TSHRSTR: {
      gray2black(o);
      g->GCmemtrav += sizelstring(gco2ts(o)->shrlen);
      break;
    }
    case LUA_TLNGSTR: {
      gray2black(o);
      g->GCmemtrav += sizelstring(gco2ts(o)->u.lnglen);
      break;
    }
    case LUA_TUSERDATA: {
      TValue uvalue;
      markobjectN(g, gco2u(o)->metatable);  /* mark its metatable */
      gray2black(o);
      g->GCmemtrav += sizeudata(gco2u(o));
      getuservalue(g->mainthread, gco2u(o), &uvalue);
      if (valiswhite(&uvalue)) {  /* markvalue(g, &uvalue); */
        o = gcvalue(&uvalue);
        goto reentry;
      }
      break;
    }
    case LUA_TLCL: {
      linkgclist(gco2lcl(o), g->gray);
      break;
    }
    case LUA_TCCL: {
      linkgclist(gco2ccl(o), g->gray);
      break;
    }
    case LUA_TTABLE: {
      linkgclist(gco2t(o), g->gray);
      break;
    }
    case LUA_TTHREAD: {
      linkgclist(gco2th(o), g->gray);
      break;
    }
    case LUA_TPROTO: {
      linkgclist(gco2p(o), g->gray);
      break;
    }
    default: lua_assert(0); break;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x9(%rsi), %al
andb $-0x4, %al
movb %al, 0x9(%r14)
movzbl 0x8(%r14), %ecx
cmpl $0x7, %ecx
jne 0xa1ca
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xa198
testb $0x3, 0x9(%rsi)
je 0xa198
movq %rbx, %rdi
callq 0xa160
movb 0x9(%r14), %al
orb $0x4, %al
movb %al, 0x9(%r14)
movq 0x18(%r14), %rax
movq 0x20(%rbx), %rcx
addq %rcx, %rax
addq $0x28, %rax
movq %rax, 0x20(%rbx)
testb $0x40, 0xa(%r14)
je 0xa23e
movq 0x20(%r14), %r14
movb 0x9(%r14), %al
testb $0x3, %al
jne 0xa16d
jmp 0xa23e
leal -0x4(%rcx), %edx
cmpl $0x5, %edx
ja 0xa1ef
leaq 0x18303(%rip), %rcx     # 0x224dc
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
orb $0x4, %al
movb %al, 0x9(%r14)
movzbl 0xb(%r14), %eax
jmp 0xa22f
cmpl $0x14, %ecx
je 0xa225
cmpl $0x26, %ecx
jne 0xa23e
movq 0x70(%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0xa21f
movq 0x70(%rbx), %rax
movq %rax, 0x30(%r14)
jmp 0xa21f
movq 0x70(%rbx), %rax
movq %rax, 0x48(%r14)
jmp 0xa21f
movq 0x70(%rbx), %rax
movq %rax, 0x70(%r14)
movq %r14, 0x70(%rbx)
jmp 0xa23e
orb $0x4, %al
movb %al, 0x9(%r14)
movq 0x10(%r14), %rax
movq 0x20(%rbx), %rcx
addq %rcx, %rax
addq $0x19, %rax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_newobj
GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
  global_State *g = G(L);
  GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz));
  o->marked = luaC_white(g);
  o->tt = tt;
  o->next = g->allgc;
  g->allgc = o;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movl %esi, %ebx
movq 0x18(%rdi), %r14
movl %esi, %edx
andl $0xf, %edx
xorl %esi, %esi
callq 0xb897
movb 0x54(%r14), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb %bl, 0x8(%rax)
movq 0x58(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_checkfinalizer
void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
  global_State *g = G(L);
  if (tofinalize(o) ||                 /* obj. is already marked... */
      gfasttm(g, mt, TM_GC) == NULL)   /* or has no finalizer? */
    return;  /* nothing to be done */
  else {  /* move 'o' to 'finobj' list */
    GCObject **p;
    if (issweepphase(g)) {
      makewhite(g, o);  /* "sweep" object 'o' */
      if (g->sweepgc == &o->next)  /* should not remove 'sweepgc' object */
        g->sweepgc = sweeptolive(L, g->sweepgc);  /* change 'sweepgc' */
    }
    /* search for pointer pointing to 'o' */
    for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ }
    *p = o->next;  /* remove 'o' from 'allgc' list */
    o->next = g->finobj;  /* link it in 'finobj' list */
    g->finobj = o;
    l_setbit(o->marked, FINALIZEDBIT);  /* mark it as such */
  }
}

// Assembly:
testq %rdx, %rdx
je 0xa39b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movb 0x9(%rsi), %al
andb $0x8, %al
jne 0xa396
testb $0x4, 0xa(%rdx)
jne 0xa396
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0xf0(%r15), %rax
movq %rdx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x10949
testq %rax, %rax
je 0xa396
movb 0x55(%r15), %al
addb $-0x2, %al
cmpb $0x3, %al
ja 0xa372
movb 0x9(%rbx), %al
andb $-0x8, %al
movb 0x54(%r15), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rbx)
movq 0x60(%r15), %rax
cmpq %rbx, %rax
jne 0xa372
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xa452
cmpq %rbx, %rax
je 0xa359
movq %rax, 0x60(%r15)
leaq 0x58(%r15), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
cmpq %rbx, %rcx
jne 0xa376
movq (%rbx), %rcx
movq %rcx, (%rax)
movq 0x68(%r15), %rax
movq %rax, (%rbx)
movq %rbx, 0x68(%r15)
orb $0x8, 0x9(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_freeallobjects
void luaC_freeallobjects (lua_State *L) {
  global_State *g = G(L);
  separatetobefnz(g, 1);  /* separate all objects with finalizers */
  lua_assert(g->finobj == NULL);
  callallpendingfinalizers(L);
  lua_assert(g->tobefnz == NULL);
  g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
  g->gckind = KGC_NORMAL;
  sweepwholelist(L, &g->finobj);
  sweepwholelist(L, &g->allgc);
  sweepwholelist(L, &g->fixedgc);  /* collect fixed objects */
  lua_assert(g->strt.nuse == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x98(%r14), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0xa3b2
leaq 0x68(%r14), %r15
movq 0x68(%r14), %rcx
movq %r14, %r12
testq %rcx, %rcx
je 0xa3f7
movq (%rcx), %rdx
movq %rdx, (%r15)
movq (%rax), %rdx
movq %rdx, (%rcx)
movq %rcx, (%rax)
movq %rcx, %rax
movq (%r15), %rcx
testq %rcx, %rcx
jne 0xa3cd
movq 0x18(%rbx), %r12
jmp 0xa3f7
movq %rbx, %rdi
xorl %esi, %esi
callq 0xabf7
cmpq $0x0, 0x98(%r12)
jne 0xa3ed
movb $0x3, 0x54(%r14)
movb $0x0, 0x56(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq $-0x1, %rdx
callq 0xa452
leaq 0x58(%r14), %rsi
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0xa452
addq $0xa0, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa452
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: sweeplist
static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
  global_State *g = G(L);
  int ow = otherwhite(g);
  int white = luaC_white(g);  /* current white */
  while (*p != NULL && count-- > 0) {
    GCObject *curr = *p;
    int marked = curr->marked;
    if (isdeadm(ow, marked)) {  /* is 'curr' dead? */
      *p = curr->next;  /* remove 'curr' from list */
      freeobj(L, curr);  /* erase 'curr' */
    }
    else {  /* change mark to 'white' */
      curr->marked = cast_byte((marked & maskcolors) | white);
      p = &curr->next;  /* go to next element */
    }
  }
  return (*p == NULL) ? NULL : p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r12
testq %r12, %r12
je 0xa5a2
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rax
movb 0x54(%rax), %bpl
movl %ebp, %r13d
xorb $0x3, %r13b
andb $0x3, %bpl
subq $0x1, %r14
jb 0xa5a4
movb 0x9(%r12), %al
movl %eax, %ecx
xorb $0x3, %cl
testb %r13b, %cl
je 0xa4b0
andb $-0x8, %al
orb %bpl, %al
movb %al, 0x9(%r12)
movq %r12, %rbx
jmp 0xa593
movq (%r12), %rax
movq %rax, (%rbx)
movzbl 0x8(%r12), %ecx
leal -0x4(%rcx), %edx
cmpl $0x10, %edx
ja 0xa4e8
leaq 0x18028(%rip), %rsi     # 0x224f4
movslq (%rsi,%rdx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0xfa2d
movzbl 0xb(%r12), %edx
jmp 0xa508
cmpl $0x26, %ecx
jne 0xa596
movzbl 0xa(%r12), %edx
shll $0x4, %edx
addq $0x20, %rdx
jmp 0xa586
movq 0x10(%r12), %rdx
addq $0x19, %rdx
jmp 0xa586
movb 0xa(%r12), %al
testb %al, %al
je 0xa581
movb %bpl, 0x7(%rsp)
xorl %ebp, %ebp
movq 0x20(%r12,%rbp,8), %rsi
testq %rsi, %rsi
je 0xa535
movq %r15, %rdi
callq 0xa2d0
movb 0xa(%r12), %al
incq %rbp
movzbl %al, %ecx
cmpq %rcx, %rbp
jb 0xa51e
leaq 0x20(,%rcx,8), %rdx
movb 0x7(%rsp), %bpl
jmp 0xa586
movq 0x18(%r12), %rdx
addq $0x28, %rdx
jmp 0xa586
movq %r15, %rdi
movq %r12, %rsi
callq 0x100f2
jmp 0xa593
movq %r15, %rdi
movq %r12, %rsi
callq 0xf248
jmp 0xa593
movq %r15, %rdi
movq %r12, %rsi
callq 0xa05b
jmp 0xa593
movl $0x20, %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xb897
movq (%rbx), %rax
movq %rax, %r12
testq %rax, %rax
jne 0xa485
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_step
void luaC_step (lua_State *L) {
  global_State *g = G(L);
  l_mem debt = getdebt(g);  /* GC deficit (be paid now) */
  if (!g->gcrunning) {  /* not running? */
    luaE_setdebt(g, -GCSTEPSIZE * 10);  /* avoid being called too often */
    return;
  }
  do {  /* repeat until pause or enough "credit" (negative debt) */
    lu_mem work = singlestep(L);  /* perform one single step */
    debt -= work;
  } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
  if (g->gcstate == GCSpause)
    setpause(g);  /* pause until next cycle */
  else {
    debt = (debt / g->gcstepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
    luaE_setdebt(g, debt);
    runafewfinalizers(L);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movabsq $0x7fffffffffffffff, %r12 # imm = 0x7FFFFFFFFFFFFFFF
movq 0x18(%rdi), %rbx
movq 0x18(%rbx), %rax
movabsq $0x28f5c28f5c28f5c3, %r13 # imm = 0x28F5C28F5C28F5C3
testq %rax, %rax
jle 0xaa2d
movslq 0xb8(%rbx), %r15
shrq $0x3, %rax
mulq %r13
movq %rdx, %rcx
shrq $0x2, %rcx
incq %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %r15
imulq %rcx, %r15
cmpq %rax, %rcx
cmovgeq %r12, %r15
jmp 0xaa30
xorl %r15d, %r15d
cmpb $0x0, 0x57(%rbx)
je 0xaa53
movq %r14, %rdi
callq 0xa5e6
subq %rax, %r15
movb 0x55(%rbx), %al
cmpq $-0x95f, %r15           # imm = 0xF6A1
jl 0xaa5f
cmpb $0x7, %al
jne 0xaa36
jmp 0xaa63
movq %rbx, %rdi
movq $-0x5dc0, %rsi          # imm = 0xA240
jmp 0xaaa4
cmpb $0x7, %al
jne 0xaab2
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rax
shrq $0x2, %rax
mulq %r13
movq %rdx, %rcx
shrq $0x2, %rcx
movslq 0xb4(%rbx), %rdi
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
divq %rcx
imulq %rdi, %rcx
cmpq %rdi, %rax
cmovgq %rcx, %r12
addq 0x10(%rbx), %rsi
subq %r12, %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xefdc
movslq 0xb8(%rbx), %rcx
movq %r15, %rax
cqto
idivq %rcx
imulq $0xc8, %rax, %rsi
movq %rbx, %rdi
callq 0xefdc
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xaade
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: runafewfinalizers
static int runafewfinalizers (lua_State *L) {
  global_State *g = G(L);
  unsigned int i;
  lua_assert(!g->tobefnz || g->gcfinnum > 0);
  for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
    GCTM(L, 1);  /* call one finalizer */
  g->gcfinnum = (!g->tobefnz) ? 0  /* nothing more to finalize? */
                    : g->gcfinnum * 2;  /* else call a few more next time */
  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %r15
cmpq $0x0, 0x98(%r15)
je 0xab1c
movq %rdi, %r14
xorl %ebx, %ebx
movl 0xb0(%r15), %eax
cmpl %eax, %ebx
jae 0xab22
movq %r14, %rdi
movl $0x1, %esi
callq 0xabf7
incl %ebx
cmpq $0x0, 0x98(%r15)
jne 0xaaf6
jmp 0xab1e
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0xab24
addl %eax, %eax
movl %eax, 0xb0(%r15)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_fullgc
void luaC_fullgc (lua_State *L, int isemergency) {
  global_State *g = G(L);
  lua_assert(g->gckind == KGC_NORMAL);
  if (isemergency) g->gckind = KGC_EMERGENCY;  /* set flag */
  if (keepinvariant(g)) {  /* black objects? */
    entersweep(L); /* sweep everything to turn them back to white */
  }
  /* finish any pending sweep phase to start a new cycle */
  luaC_runtilstate(L, bitmask(GCSpause));
  luaC_runtilstate(L, ~bitmask(GCSpause));  /* start new collection */
  luaC_runtilstate(L, bitmask(GCScallfin));  /* run up to finalizers */
  /* estimate must be correct after a full GC cycle */
  lua_assert(g->GCestimate == gettotalbytes(g));
  luaC_runtilstate(L, bitmask(GCSpause));  /* finish collection */
  g->gckind = KGC_NORMAL;
  setpause(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
je 0xab46
movb $0x1, 0x56(%rbx)
cmpb $0x1, 0x55(%rbx)
ja 0xab65
movb $0x2, 0x55(%rbx)
leaq 0x58(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0xa452
movq %rax, 0x60(%rbx)
movq %r14, %rdi
movl $0x80, %esi
callq 0xa5b6
movq %r14, %rdi
movl $0xffffff7f, %esi       # imm = 0xFFFFFF7F
callq 0xa5b6
movq %r14, %rdi
movl $0x40, %esi
callq 0xa5b6
movq %r14, %rdi
movl $0x80, %esi
callq 0xa5b6
movb $0x0, 0x56(%rbx)
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
movq %rdx, %rcx
shrq $0x2, %rcx
movslq 0xb4(%rbx), %r8
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
imulq %r8, %rcx
cmpq %r8, %rax
cmovleq %rdi, %rcx
addq 0x10(%rbx), %rsi
subq %rcx, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xefdc
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: GCTM
static void GCTM (lua_State *L, int propagateerrors) {
  global_State *g = G(L);
  const TValue *tm;
  TValue v;
  setgcovalue(L, &v, udata2finalize(g));
  tm = luaT_gettmbyobj(L, &v, TM_GC);
  if (tm != NULL && ttisfunction(tm)) {  /* is there a finalizer? */
    int status;
    lu_byte oldah = L->allowhook;
    int running  = g->gcrunning;
    L->allowhook = 0;  /* stop debug hooks during GC metamethod */
    g->gcrunning = 0;  /* avoid GC steps */
    setobj2s(L, L->top, tm);  /* push finalizer... */
    setobj2s(L, L->top + 1, &v);  /* ... and its argument */
    L->top += 2;  /* and (next line) call the finalizer */
    status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0);
    L->allowhook = oldah;  /* restore hooks */
    g->gcrunning = running;  /* restore state */
    if (status != LUA_OK && propagateerrors) {  /* error while running __gc? */
      if (status == LUA_ERRRUN) {  /* is there an error object? */
        const char *msg = (ttisstring(L->top - 1))
                            ? svalue(L->top - 1)
                            : "no message";
        luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
        status = LUA_ERRGCMM;  /* error in __gc metamethod */
      }
      luaD_throw(L, status);  /* re-throw error */
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x58(%r14), %rcx
movq 0x98(%r14), %rax
movq (%rax), %rdx
movq %rdx, 0x98(%r14)
movq %rcx, (%rax)
movq %rax, 0x58(%r14)
movb 0x9(%rax), %cl
movl %ecx, %edx
andb $-0x9, %dl
movb %dl, 0x9(%rax)
movb 0x55(%r14), %dl
addb $-0x2, %dl
cmpb $0x3, %dl
ja 0xac4e
andb $-0x10, %cl
movb 0x54(%r14), %dl
andb $0x3, %dl
orb %cl, %dl
movb %dl, 0x9(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
movl %eax, 0x8(%rsi)
movq %rbx, %rdi
movl $0x2, %edx
callq 0x10974
testq %rax, %rax
je 0xacdf
movl 0x8(%rax), %ecx
andl $0xf, %ecx
cmpl $0x6, %ecx
jne 0xacdf
movb 0xcc(%rbx), %r15b
movb 0x57(%r14), %r12b
xorl %ecx, %ecx
movb %cl, 0xcc(%rbx)
movb %cl, 0x57(%r14)
movq 0x10(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rbx), %rax
movups (%rsp), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x10(%rbx), %rcx
leaq 0x20(%rcx), %rax
movq %rax, 0x10(%rbx)
subq 0x38(%rbx), %rcx
leaq 0x72(%rip), %rsi        # 0xad31
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x9416
movb %r15b, 0xcc(%rbx)
movb %r12b, 0x57(%r14)
testl %ebp, %ebp
je 0xacdf
testl %eax, %eax
jne 0xacec
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
jne 0xad27
movq 0x10(%rbx), %rax
movl -0x8(%rax), %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
jne 0xad0a
movq -0x10(%rax), %rdx
addq $0x18, %rdx
jmp 0xad11
leaq 0x1785b(%rip), %rdx     # 0x2256c
leaq 0x1785f(%rip), %rsi     # 0x22577
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc391
movl $0x5, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x8578
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: sweepstep
static lu_mem sweepstep (lua_State *L, global_State *g,
                         int nextstate, GCObject **nextlist) {
  if (g->sweepgc) {
    l_mem olddebt = g->GCdebt;
    g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
    if (g->sweepgc)  /* is there still something to sweep? */
      return (GCSWEEPMAX * GCSWEEPCOST);
  }
  /* else enter next state */
  g->gcstate = nextstate;
  g->sweepgc = nextlist;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq 0x60(%rsi), %rsi
testq %rsi, %rsi
je 0xb45b
movq 0x18(%r14), %r15
movl $0x55, %edx
callq 0xa452
movq %rax, %rcx
movq %rax, 0x60(%r14)
movq 0x18(%r14), %rax
subq %r15, %rax
addq %rax, 0x28(%r14)
movl $0x253, %eax            # imm = 0x253
testq %rcx, %rcx
jne 0xb465
movb %bpl, 0x55(%r14)
movq %rbx, 0x60(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: iscleared
static int iscleared (global_State *g, const TValue *o) {
  if (!iscollectable(o)) return 0;
  else if (ttisstring(o)) {
    markobject(g, tsvalue(o));  /* strings are 'values', so are never weak */
    return 0;
  }
  else return iswhite(gcvalue(o));
}

// Assembly:
pushq %rbx
movl 0x8(%rsi), %eax
xorl %ebx, %ebx
testb $0x40, %al
je 0xb660
andl $0xf, %eax
movq (%rsi), %rsi
movzbl 0x9(%rsi), %ecx
andl $0x3, %ecx
cmpl $0x4, %eax
jne 0xb65e
testb %cl, %cl
je 0xb660
callq 0xa160
jmp 0xb660
movl %ecx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: convergeephemerons
static void convergeephemerons (global_State *g) {
  int changed;
  do {
    GCObject *w;
    GCObject *next = g->ephemeron;  /* get ephemeron list */
    g->ephemeron = NULL;  /* tables may return to this list when traversed */
    changed = 0;
    while ((w = next) != NULL) {
      next = gco2t(w)->gclist;
      if (traverseephemeron(g, gco2t(w))) {  /* traverse marked some value? */
        propagateall(g);  /* propagate changes */
        changed = 1;  /* will have to revisit all ephemeron tables */
      }
    }
  } while (changed);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x88(%rbx), %r14
movq $0x0, 0x88(%rbx)
testq %r14, %r14
je 0xb6b6
xorl %ebp, %ebp
movq %r14, %rsi
movq 0x30(%r14), %r14
movq %rbx, %rdi
callq 0xb4da
testl %eax, %eax
je 0xb6ad
movl $0x1, %ebp
cmpq $0x0, 0x70(%rbx)
je 0xb6ad
movq %rbx, %rdi
callq 0xad40
jmp 0xb69c
testq %r14, %r14
jne 0xb684
testl %ebp, %ebp
jne 0xb66b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: clearvalues
static void clearvalues (global_State *g, GCObject *l, GCObject *f) {
  for (; l != f; l = gco2t(l)->gclist) {
    Table *h = gco2t(l);
    Node *n, *limit = gnodelast(h);
    unsigned int i;
    for (i = 0; i < h->sizearray; i++) {
      TValue *o = &h->array[i];
      if (iscleared(g, o))  /* value was collected? */
        setnilvalue(o);  /* remove value */
    }
    for (n = gnode(h, 0); n < limit; n++) {
      if (!ttisnil(gval(n)) && iscleared(g, gval(n))) {
        setnilvalue(gval(n));  /* remove value ... */
        removeentry(n);  /* and remove entry from table */
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
cmpq %rdx, %rsi
je 0xb793
movq %rsi, %r14
movq %rdi, %r15
movb 0xb(%r14), %cl
movl $0x1, %eax
shll %cl, %eax
movq 0x18(%r14), %r13
cmpl $0x0, 0xc(%r14)
movq %r13, %r12
je 0xb734
movl %eax, 0xc(%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x10(%r14), %rbp
leaq (%r12,%rbp), %rsi
movq %r15, %rdi
callq 0xb637
testl %eax, %eax
je 0xb71c
movl $0x0, 0x8(%rbp,%r12)
incq %rbx
movl 0xc(%r14), %eax
addq $0x10, %r12
cmpq %rax, %rbx
jb 0xb6ff
movq 0x18(%r14), %r12
movl 0xc(%rsp), %eax
cltq
shlq $0x5, %rax
addq %rax, %r13
cmpq %r13, %r12
jae 0xb784
cmpl $0x0, 0x8(%r12)
je 0xb77e
movq %r15, %rdi
movq %r12, %rsi
callq 0xb637
testl %eax, %eax
je 0xb77e
movl $0x0, 0x8(%r12)
testb $0x40, 0x18(%r12)
je 0xb77e
movq 0x10(%r12), %rax
testb $0x3, 0x9(%rax)
je 0xb77e
movl $0xa, 0x18(%r12)
addq $0x20, %r12
jmp 0xb73d
movq 0x30(%r14), %r14
cmpq 0x10(%rsp), %r14
jne 0xb6dd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: clearkeys
static void clearkeys (global_State *g, GCObject *l, GCObject *f) {
  for (; l != f; l = gco2t(l)->gclist) {
    Table *h = gco2t(l);
    Node *n, *limit = gnodelast(h);
    for (n = gnode(h, 0); n < limit; n++) {
      if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
        setnilvalue(gval(n));  /* remove value ... */
        removeentry(n);  /* and remove entry from table */
      }
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0xb834
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0xb(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
cmpb $0x1f, %cl
je 0xb820
movq 0x18(%rbx), %r15
movslq %eax, %r12
shlq $0x5, %r12
addq %r15, %r12
addq $0x10, %r15
cmpl $0x0, -0x8(%r15)
je 0xb810
movq %r14, %rdi
movq %r15, %rsi
callq 0xb637
testl %eax, %eax
je 0xb810
movl $0x0, -0x8(%r15)
testb $0x40, 0x8(%r15)
je 0xb810
movq (%r15), %rax
testb $0x3, 0x9(%rax)
je 0xb810
movl $0xa, 0x8(%r15)
leaq 0x20(%r15), %rax
addq $0x10, %r15
cmpq %r12, %r15
movq %rax, %r15
jb 0xb7da
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0xb7b9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmem.c
// Function: luaM_growaux_
void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
                     int limit, const char *what) {
  void *newblock;
  int newsize;
  if (*size >= limit/2) {  /* cannot double it? */
    if (*size >= limit)  /* cannot grow even a little? */
      luaG_runerror(L, "too many %s (limit is %d)", what, limit);
    newsize = limit;  /* still have at least one free place */
  }
  else {
    newsize = (*size)*2;
    if (newsize < MINSIZEARRAY)
      newsize = MINSIZEARRAY;  /* minimum size */
  }
  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
  *size = newsize;  /* update only when everything else is OK */
  return newblock;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movslq (%rdx), %rdx
movl %r8d, %eax
shrl $0x1f, %eax
addl %r8d, %eax
sarl %eax
cmpl %eax, %edx
jge 0xb863
leal (%rdx,%rdx), %eax
cmpl $0x5, %eax
movl $0x4, %r8d
cmovgel %eax, %r8d
jmp 0xb868
cmpl %r8d, %edx
jge 0xb883
imulq %rcx, %rdx
movslq %r8d, %r14
imulq %r14, %rcx
callq 0xb897
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x16d0b(%rip), %rsi     # 0x22595
movq %r9, %rdx
movl %r8d, %ecx
xorl %eax, %eax
callq 0x7dd3
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  void *newblock;
  global_State *g = G(L);
  size_t realosize = (block) ? osize : 0;
  lua_assert((realosize == 0) == (block == NULL));
#if defined(HARDMEMTESTS)
  if (nsize > realosize && g->gcrunning)
    luaC_fullgc(L, 1);  /* force a GC whenever possible */
#endif
  newblock = (*g->frealloc)(g->ud, block, osize, nsize);
  if (newblock == NULL && nsize > 0) {
    lua_assert(nsize > realosize);  /* cannot fail when shrinking a block */
    if (g->version) {  /* is state fully built? */
      luaC_fullgc(L, 1);  /* try to free some memory... */
      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
    }
    if (newblock == NULL)
      luaD_throw(L, LUA_ERRMEM);
  }
  lua_assert((nsize == 0) == (newblock == NULL));
  g->GCdebt = (g->GCdebt + nsize) - realosize;
  return newblock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdi), %r13
movq 0x8(%r13), %rdi
callq *(%r13)
testq %rbx, %rbx
je 0xb8ef
testq %rax, %rax
jne 0xb8ef
cmpq $0x0, 0xd0(%r13)
je 0xb907
movq %r12, %rdi
movl $0x1, %esi
callq 0xab33
movq 0x8(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *(%r13)
testq %rax, %rax
je 0xb907
testq %r15, %r15
cmoveq %r15, %r14
subq %r14, %rbx
addq %rbx, 0x18(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
movl $0x4, %esi
callq 0x8578
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* exponent */
  if (x < 8) return x;
  while (x >= (8 << 4)) {  /* coarse steps */
    x = (x + 0xf) >> 4;  /* x = ceil(x / 16) */
    e += 4;
  }
  while (x >= (8 << 1)) {  /* fine steps */
    x = (x + 1) >> 1;  /* x = ceil(x / 2) */
    e++;
  }
  return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
movl %edi, %eax
cmpl $0x8, %edi
jb 0xb971
xorl %ecx, %ecx
cmpl $0x80, %eax
jb 0xb94c
xorl %ecx, %ecx
addl $0xf, %eax
movl %eax, %edx
shrl $0x4, %edx
addl $0x4, %ecx
cmpl $0x7ff, %eax            # imm = 0x7FF
movl %edx, %eax
ja 0xb936
jmp 0xb94e
movl %eax, %edx
cmpl $0x10, %edx
jb 0xb963
leal 0x1(%rdx), %eax
shrl %eax
incl %ecx
cmpl $0x1e, %edx
movl %eax, %edx
ja 0xb953
jmp 0xb965
movl %edx, %eax
leal 0x8(,%rcx,8), %ecx
addl $-0x8, %eax
orl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_ceillog2
int luaO_ceillog2 (unsigned int x) {
  static const lu_byte log_2[256] = {  /* log_2[i] = ceil(log2(i - 1)) */
    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
  };
  int l = 0;
  x--;
  while (x >= 256) { l += 8; x >>= 8; }
  return l + log_2[x];
}

// Assembly:
decl %edi
xorl %ecx, %ecx
cmpl $0x100, %edi            # imm = 0x100
jb 0xb9af
xorl %ecx, %ecx
movl %edi, %eax
addl $0x8, %ecx
shrl $0x8, %eax
cmpl $0xffff, %edi           # imm = 0xFFFF
movl %eax, %edi
ja 0xb99d
jmp 0xb9b1
movl %edi, %eax
movl %eax, %eax
leaq 0x16ca6(%rip), %rdx     # 0x22660
movzbl (%rax,%rdx), %eax
addl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: intarith
static lua_Integer intarith (lua_State *L, int op, lua_Integer v1,
                                                   lua_Integer v2) {
  switch (op) {
    case LUA_OPADD: return intop(+, v1, v2);
    case LUA_OPSUB:return intop(-, v1, v2);
    case LUA_OPMUL:return intop(*, v1, v2);
    case LUA_OPMOD: return luaV_mod(L, v1, v2);
    case LUA_OPIDIV: return luaV_div(L, v1, v2);
    case LUA_OPBAND: return intop(&, v1, v2);
    case LUA_OPBOR: return intop(|, v1, v2);
    case LUA_OPBXOR: return intop(^, v1, v2);
    case LUA_OPSHL: return luaV_shiftl(v1, v2);
    case LUA_OPSHR: return luaV_shiftl(v1, -v2);
    case LUA_OPUNM: return intop(-, 0, v1);
    case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1);
    default: lua_assert(0); return 0;
  }
}

// Assembly:
xorl %eax, %eax
cmpl $0xd, %esi
ja 0xbbd2
movl %esi, %esi
leaq 0x16a37(%rip), %r8      # 0x225e0
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
addq %rdx, %rcx
jmp 0xbbdb
negq %rdx
jmp 0xbbcf
imulq %rdx, %rcx
jmp 0xbbdb
andq %rdx, %rcx
jmp 0xbbdb
notq %rdx
jmp 0xbbcf
subq %rcx, %rdx
movq %rdx, %rax
retq
orq %rdx, %rcx
jmp 0xbbdb
xorq %rdx, %rcx
movq %rcx, %rax
retq
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x123d1
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x12392
negq %rcx
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0x12413
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: numarith
static lua_Number numarith (lua_State *L, int op, lua_Number v1,
                                                  lua_Number v2) {
  switch (op) {
    case LUA_OPADD: return luai_numadd(L, v1, v2);
    case LUA_OPSUB: return luai_numsub(L, v1, v2);
    case LUA_OPMUL: return luai_nummul(L, v1, v2);
    case LUA_OPDIV: return luai_numdiv(L, v1, v2);
    case LUA_OPPOW: return luai_numpow(L, v1, v2);
    case LUA_OPIDIV: return luai_numidiv(L, v1, v2);
    case LUA_OPUNM: return luai_numunm(L, v1);
    case LUA_OPMOD: {
      lua_Number m;
      luai_nummod(L, v1, v2, m);
      return m;
    }
    default: lua_assert(0); return 0;
  }
}

// Assembly:
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
cmpl $0xc, %edi
ja 0xbc8f
movl %edi, %eax
leaq 0x169ff(%rip), %rcx     # 0x22618
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
jmp 0xbc4f
divsd %xmm1, %xmm2
jmp 0xbc4f
subsd %xmm1, %xmm2
jmp 0xbc4f
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
jmp 0x5460
xorpd 0x16b17(%rip), %xmm2    # 0x22760
jmp 0xbc4f
mulsd %xmm1, %xmm2
movapd %xmm2, %xmm0
retq
subq $0x18, %rsp
movapd %xmm2, %xmm0
movaps %xmm1, (%rsp)
callq 0x51e0
movapd %xmm0, %xmm1
movapd (%rsp), %xmm3
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm3
xorpd %xmm2, %xmm2
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm0
orpd %xmm3, %xmm0
addq $0x18, %rsp
retq
movapd %xmm2, %xmm0
jmp 0x5110
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_str2num
size_t luaO_str2num (const char *s, TValue *o) {
  lua_Integer i; lua_Number n;
  const char *e;
  if ((e = l_str2int(s, &i)) != NULL) {  /* try as an integer */
    setivalue(o, i);
  }
  else if ((e = l_str2d(s, &n)) != NULL) {  /* else try as a float */
    setfltvalue(o, n);
  }
  else
    return 0;  /* conversion failed */
  return (e - s) + 1;  /* success; return string size */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x179be(%rip), %rcx     # 0x23690
movq %rdi, %rax
movzbl (%rax), %edi
incq %rax
testb $0x8, 0x1(%rdi,%rcx)
jne 0xbcd5
cmpl $0x2b, %edi
je 0xbcf8
movl $0x1, %edx
cmpl $0x2d, %edi
je 0xbcfa
decq %rax
xorl %edx, %edx
jmp 0xbcfd
xorl %edx, %edx
movb (%rax), %dil
cmpb $0x30, %dil
jne 0xbd58
movzbl 0x1(%rax), %esi
orl $0x20, %esi
cmpl $0x78, %esi
jne 0xbd58
movzbl 0x2(%rax), %edi
addq $0x2, %rax
testb $0x10, 0x1(%rdi,%rcx)
je 0xbd63
xorl %esi, %esi
movsbl %dil, %edi
movsbq %dil, %r8
testb $0x2, 0x1(%r8,%rcx)
je 0xbd35
addl $-0x30, %edi
jmp 0xbd3b
orl $0x20, %edi
addl $-0x57, %edi
movq %rsi, %r8
shlq $0x4, %r8
movslq %edi, %rsi
addq %r8, %rsi
movzbl 0x1(%rax), %edi
incq %rax
testb $0x10, 0x1(%rdi,%rcx)
jne 0xbd20
jmp 0xbdac
movzbl %dil, %esi
testb $0x2, 0x1(%rsi,%rcx)
jne 0xbd69
xorl %edi, %edi
xorl %esi, %esi
jmp 0xbdaf
movabsq $0xccccccccccccccb, %r8 # imm = 0xCCCCCCCCCCCCCCB
leal 0x7(%rdx), %r9d
xorl %esi, %esi
leaq 0x1(%r8), %r10
movsbl %dil, %edi
addl $-0x30, %edi
cmpq %r8, %rsi
jbe 0xbd93
cmpq %r10, %rsi
jne 0xbde4
cmpl %r9d, %edi
jg 0xbde4
leaq (%rsi,%rsi,4), %rsi
movslq %edi, %rdi
leaq (%rdi,%rsi,2), %rsi
movzbl 0x1(%rax), %edi
incq %rax
testb $0x2, 0x1(%rdi,%rcx)
jne 0xbd7d
movb $0x1, %dil
decq %rax
movzbl 0x1(%rax), %r8d
incq %rax
testb $0x8, 0x1(%r8,%rcx)
jne 0xbdb2
testb %r8b, %r8b
setne %cl
xorb $0x1, %dil
orb %cl, %dil
jne 0xbde4
movq %rsi, %rcx
negq %rcx
testl %edx, %edx
cmoveq %rsi, %rcx
movl $0x13, %edx
jmp 0xbe20
leaq 0x169e3(%rip), %rsi     # 0x227ce
movq %rbx, %rdi
callq 0x53c0
testq %rax, %rax
je 0xbe04
movb (%rax), %al
andb $-0x21, %al
cmpb $0x4e, %al
je 0xbea1
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc546
testq %rax, %rax
je 0xbe2f
movl $0x3, %edx
movq 0x8(%rsp), %rcx
movq %rcx, (%r14)
movl %edx, 0x8(%r14)
subq %rbx, %rax
incq %rax
jmp 0xbea3
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x5160
movq %rax, %r15
movq %rbx, %rdi
callq 0x5140
cmpq $0xc9, %rax
setb %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xbea1
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x50b0
callq 0x50f0
movq (%rax), %rax
movb (%rax), %al
subq %rbx, %r15
movb %al, 0x10(%rsp,%r15)
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0xc546
testq %rax, %rax
je 0xbea1
testq %rbx, %rbx
je 0xbea1
subq %r12, %rax
addq %rbx, %rax
jmp 0xbe16
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_utf8esc
int luaO_utf8esc (char *buff, unsigned long x) {
  int n = 1;  /* number of bytes put in buffer (backwards) */
  lua_assert(x <= 0x10FFFF);
  if (x < 0x80)  /* ascii? */
    buff[UTF8BUFFSZ - 1] = cast(char, x);
  else {  /* need continuation bytes */
    unsigned int mfb = 0x3f;  /* maximum that fits in first byte */
    do {  /* add continuation bytes */
      buff[UTF8BUFFSZ - (n++)] = cast(char, 0x80 | (x & 0x3f));
      x >>= 6;  /* remove added bits */
      mfb >>= 1;  /* now there is one less bit available in first byte */
    } while (x > mfb);  /* still needs continuation byte? */
    buff[UTF8BUFFSZ - n] = cast(char, (~mfb << 1) | x);  /* add first byte */
  }
  return n;
}

// Assembly:
cmpq $0x80, %rsi
jae 0xbec7
movl $0x1, %eax
movl $0x7, %ecx
jmp 0xbf17
movl $0x3f, %edx
movabsq $0x700000000, %rcx      # imm = 0x700000000
xorl %r8d, %r8d
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
movl %esi, %r9d
andb $0x3f, %r9b
orb $-0x80, %r9b
movb %r9b, 0x7(%rdi,%r8)
shrq $0x6, %rsi
shrl %edx
decq %r8
cmpq %rdx, %rsi
ja 0xbee3
movl $0x1, %eax
subl %r8d, %eax
notl %edx
addl %edx, %edx
orq %rdx, %rsi
sarq $0x20, %rcx
movb %sil, (%rdi,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_tostring
void luaO_tostring (lua_State *L, StkId obj) {
  char buff[MAXNUMBER2STR];
  size_t len;
  lua_assert(ttisnumber(obj));
  if (ttisinteger(obj))
    len = lua_integer2str(buff, sizeof(buff), ivalue(obj));
  else {
    len = lua_number2str(buff, sizeof(buff), fltvalue(obj));
#if !defined(LUA_COMPAT_FLOATSTRING)
    if (buff[strspn(buff, "-0123456789")] == '\0') {  /* looks like an int? */
      buff[len++] = lua_getlocaledecpoint();
      buff[len++] = '0';  /* adds '.0' to result */
    }
#endif
  }
  setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x13, 0x8(%rsi)
jne 0xbf51
movq (%rbx), %rcx
leaq 0x16833(%rip), %rdx     # 0x22770
movq %rsp, %rdi
movl $0x32, %esi
xorl %eax, %eax
callq 0x5180
movslq %eax, %r15
jmp 0xbf9e
movsd (%rbx), %xmm0
leaq 0x16819(%rip), %rdx     # 0x22775
movq %rsp, %r12
movl $0x32, %esi
movq %r12, %rdi
movb $0x1, %al
callq 0x5180
movslq %eax, %r15
leaq 0x16803(%rip), %rsi     # 0x2277b
movq %r12, %rdi
callq 0x51f0
cmpb $0x0, (%rsp,%rax)
jne 0xbf9e
callq 0x50f0
movq (%rax), %rax
movb (%rax), %al
movb %al, (%rsp,%r15)
movb $0x30, 0x1(%rsp,%r15)
addq $0x2, %r15
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xf828
movq %rax, (%rbx)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
movl %eax, 0x8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_chunkid
void luaO_chunkid (char *out, const char *source, size_t bufflen) {
  size_t l = strlen(source);
  if (*source == '=') {  /* 'literal' source */
    if (l <= bufflen)  /* small enough? */
      memcpy(out, source + 1, l * sizeof(char));
    else {  /* truncate it */
      addstr(out, source + 1, bufflen - 1);
      *out = '\0';
    }
  }
  else if (*source == '@') {  /* file name */
    if (l <= bufflen)  /* small enough? */
      memcpy(out, source + 1, l * sizeof(char));
    else {  /* add '...' before rest of name */
      addstr(out, RETS, LL(RETS));
      bufflen -= LL(RETS);
      memcpy(out, source + 1 + l - bufflen, bufflen * sizeof(char));
    }
  }
  else {  /* string; format as [string "source"] */
    const char *nl = strchr(source, '\n');  /* find first new line (if any) */
    addstr(out, PRE, LL(PRE));  /* add prefix */
    bufflen -= LL(PRE RETS POS) + 1;  /* save space for prefix+suffix+'\0' */
    if (l < bufflen && nl == NULL) {  /* small one-line source? */
      addstr(out, source, l);  /* keep it */
    }
    else {
      if (nl != NULL) l = nl - source;  /* stop at first newline */
      if (l > bufflen) l = bufflen;
      addstr(out, source, l);
      addstr(out, RETS, LL(RETS));
    }
    memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5140
movq %rax, %r12
movzbl (%r14), %eax
cmpl $0x40, %eax
je 0xc466
cmpl $0x3d, %eax
jne 0xc491
incq %r14
cmpq %r15, %r12
jbe 0xc4e0
leaq -0x1(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5310
movb $0x0, -0x1(%rbx,%r15)
jmp 0xc53c
cmpq %r15, %r12
jbe 0xc4dd
movb $0x2e, 0x2(%rbx)
movw $0x2e2e, (%rbx)         # imm = 0x2E2E
addq $0x3, %rbx
addq %r12, %r14
subq %r15, %r14
addq $-0x3, %r15
addq $0x4, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
jmp 0xc4e9
movq %r14, %rdi
movl $0xa, %esi
callq 0x5160
movabsq $0x20676e697274735b, %rcx # imm = 0x20676E697274735B
movq %rcx, (%rbx)
movb $0x22, 0x8(%rbx)
addq $0x9, %rbx
addq $-0xf, %r15
cmpq %r15, %r12
setb %cl
testq %rax, %rax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xc4f7
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5310
addq %rbx, %r12
jmp 0xc52f
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5310
movq %rax, %r13
subq %r14, %r13
testq %rax, %rax
cmoveq %r12, %r13
cmpq %r15, %r13
cmovaeq %r15, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5310
leaq (%rbx,%r13), %r12
addq $0x3, %r12
movw $0x2e2e, -0x3(%r12)     # imm = 0x2E2E
movb $0x2e, -0x1(%r12)
movb $0x0, 0x2(%r12)
movw $0x5d22, (%r12)         # imm = 0x5D22
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: l_str2dloc
static const char *l_str2dloc (const char *s, lua_Number *result, int mode) {
  char *endptr;
  *result = (mode == 'x') ? lua_strx2number(s, &endptr)  /* try to convert */
                          : lua_str2number(s, &endptr);
  if (endptr == s) return NULL;  /* nothing recognized? */
  while (lisspace(cast_uchar(*endptr))) endptr++;  /* skip trailing spaces */
  return (*endptr == '\0') ? endptr : NULL;  /* OK if no trailing characters */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x50e0
movsd %xmm0, (%rbx)
movq (%r15), %rcx
cmpq %r14, %rcx
je 0xc590
decq %rcx
leaq 0x17118(%rip), %rax     # 0x23690
movzbl 0x1(%rcx), %edx
incq %rcx
testb $0x8, 0x1(%rdx,%rax)
jne 0xc578
xorl %eax, %eax
testb %dl, %dl
cmoveq %rcx, %rax
jmp 0xc592
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: newupvalue
static int newupvalue (FuncState *fs, TString *name, expdesc *v) {
  Proto *f = fs->f;
  int oldsize = f->sizeupvalues;
  checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");
  luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues,
                  Upvaldesc, MAXUPVAL, "upvalues");
  while (oldsize < f->sizeupvalues)
    f->upvalues[oldsize++].name = NULL;
  f->upvalues[fs->nups].instack = (v->k == VLOCAL);
  f->upvalues[fs->nups].idx = cast_byte(v->u.info);
  f->upvalues[fs->nups].name = name;
  luaC_objbarrier(fs->ls->L, f, name);
  return fs->nups++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzbl 0x3b(%rdi), %eax
cmpl $0xff, %eax
je 0xc8c8
movq %rdx, %r12
movq %rsi, %r14
movq (%rbx), %r15
movslq 0x10(%r15), %r13
cmpl %eax, %r13d
jg 0xc86c
leaq 0x10(%r15), %rdx
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x58(%r15), %rsi
leaq 0x16c00(%rip), %r9      # 0x233a0
movl $0x10, %ecx
movl $0xff, %r8d
callq 0xb838
movq %rax, 0x58(%r15)
movslq 0x10(%r15), %rdx
cmpl %edx, %r13d
jge 0xc86c
movq 0x58(%r15), %rax
subq %r13, %rdx
leaq 0x1(%rdx), %rcx
andq $-0x2, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shlq $0x4, %r13
leaq (%rax,%r13), %rdx
addq $0x10, %rdx
xorl %esi, %esi
movdqa 0x158fd(%rip), %xmm1    # 0x220f0
movdqa 0x15905(%rip), %xmm2    # 0x22100
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0xc847
movq $0x0, -0x10(%rdx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0xc85d
movq $0x0, (%rdx)
addq $0x2, %rsi
addq $0x20, %rdx
cmpq %rsi, %rcx
jne 0xc803
jmp 0xc870
movq 0x58(%r15), %rax
movzbl 0x3b(%rbx), %ecx
movl %ecx, %edx
shll $0x4, %edx
cmpl $0x8, (%r12)
sete 0x8(%rax,%rdx)
movb 0x8(%r12), %sil
movb %sil, 0x9(%rax,%rdx)
movq %r14, (%rax,%rdx)
testb $0x4, 0x9(%r15)
je 0xc8b5
testb $0x3, 0x9(%r14)
je 0xc8b5
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xa140
movb 0x3b(%rbx), %cl
leal 0x1(%rcx), %eax
movb %al, 0x3b(%rbx)
movzbl %cl, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x16ad1(%rip), %rdx     # 0x233a0
movq %rbx, %rdi
movl $0xff, %esi
callq 0xca81