LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: checkmode
static void checkmode (lua_State *L, const char *mode, const char *x) {
  if (mode && strchr(mode, x[0]) == NULL) {
    luaO_pushfstring(L,
       "attempt to load a %s chunk (mode is " LUA_QS ")", x, mode);
    luaD_throw(L, LUA_ERRSYNTAX);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xba4e
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rdx), %esi
movq %r14, %rdi
callq 0x6190
testq %rax, %rax
je 0xba54
popq %rbx
popq %r14
popq %r15
retq
leaq 0x12ed1(%rip), %rsi     # 0x1e92c
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0xff79
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xad18
nop
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldump.c
// Function: luaU_dump
int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
{
 DumpState D;
 D.L=L;
 D.writer=w;
 D.data=data;
 D.strip=strip;
 D.status=0;
 DumpHeader(&D);
 DumpFunction(f,&D);
 return D.status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rsp), %r13
movq %rdi, (%r13)
movq %rdx, 0x8(%r13)
movq %rcx, 0x10(%r13)
movl %r8d, 0x18(%r13)
movq %rsp, %rbp
movq %rbp, %rdi
callq 0x16e37
pushq $0x12
popq %rdx
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq *%r14
movl %eax, 0x1c(%r13)
movq %r15, %rdi
movq %r13, %rsi
callq 0xbae3
movl 0x1c(%r13), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldump.c
// Function: DumpString
static void DumpString(const TString* s, DumpState* D)
{
 if (s==NULL)
 {
  size_t size=0;
  DumpVar(size,D);
 }
 else
 {
  size_t size=s->tsv.len+1;		/* include trailing '\0' */
  DumpVar(size,D);
  DumpBlock(getstr(s),size*sizeof(char),D);
 }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0xbdea
movq %rdi, %r14
movq 0x10(%rdi), %rax
incq %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
pushq $0x8
popq %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xbd34
addq $0x18, %r14
movq (%r15), %rsi
movq %r14, %rdi
jmp 0xbdf6
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
pushq $0x8
popq %rsi
movq %rbx, %rdx
callq 0xbd34
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lfunc.c
// Function: luaF_newLclosure
Closure *luaF_newLclosure (lua_State *L, int n) {
  Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl;
  c->l.p = NULL;
  c->l.nupvalues = cast_byte(n);
  while (n--) c->l.upvals[n] = NULL;
  return c;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
leal 0x20(,%rbx,8), %eax
movslq %eax, %rdx
pushq $0x6
popq %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc26a
andq $0x0, 0x18(%rax)
movb %bl, 0xa(%rax)
movslq %ebx, %rcx
addq $0x3, %rcx
cmpq $0x3, %rcx
je 0xbe61
andq $0x0, (%rax,%rcx,8)
decq %rcx
jmp 0xbe51
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lfunc.c
// Function: luaF_newupval
UpVal *luaF_newupval (lua_State *L) {
  UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv;
  uv->v = &uv->u.value;
  setnilvalue(uv->v);
  return uv;
}

// Assembly:
pushq %rax
pushq $0xa
popq %rsi
pushq $0x28
popq %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc26a
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
andl $0x0, 0x20(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lfunc.c
// Function: luaF_findupval
UpVal *luaF_findupval (lua_State *L, StkId level) {
  global_State *g = G(L);
  GCObject **pp = &L->openupval;
  UpVal *p;
  UpVal *uv;
  while (*pp != NULL && (p = gco2uv(*pp))->v >= level) {
    GCObject *o = obj2gco(p);
    lua_assert(p->v != &p->u.value);
    lua_assert(!isold(o) || isold(obj2gco(L)));
    if (p->v == level) {  /* found a corresponding upvalue? */
      if (isdead(g, o))  /* is it dead? */
        changewhite(o);  /* resurrect it */
      return p;
    }
    pp = &p->next;
  }
  /* not found: create a new one */
  uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv;
  uv->v = level;  /* current value lives in the stack */
  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
  uv->u.l.next = g->uvhead.u.l.next;
  uv->u.l.next->u.l.prev = uv;
  g->uvhead.u.l.next = uv;
  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
  return uv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x60(%rdi), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0xbeba
cmpq %rbx, 0x10(%rax)
jb 0xbeba
movq %rax, %rcx
jne 0xbe91
movb 0x9(%rax), %cl
xorb $0x3, %cl
movb 0x54(%r14), %dl
xorb $0x3, %dl
testb %cl, %dl
jne 0xbeed
movb %cl, 0x9(%rax)
jmp 0xbeed
pushq $0xa
popq %rsi
pushq $0x28
popq %rdx
xorl %r8d, %r8d
callq 0xc26a
movq %rbx, 0x10(%rax)
leaq 0xb0(%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0xd0(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rcx)
movq %rax, 0xd0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lfunc.c
// Function: luaF_close
void luaF_close (lua_State *L, StkId level) {
  UpVal *uv;
  global_State *g = G(L);
  while (L->openupval != NULL && (uv = gco2uv(L->openupval))->v >= level) {
    GCObject *o = obj2gco(uv);
    lua_assert(!isblack(o) && uv->v != &uv->u.value);
    L->openupval = uv->next;  /* remove from `open' list */
    if (isdead(g, o))
      luaF_freeupval(L, uv);  /* free upvalue */
    else {
      unlinkupval(uv);  /* remove upvalue from 'uvhead' list */
      setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
      uv->v = &uv->u.value;  /* now current value lives here */
      gch(o)->next = g->allgc;  /* link upvalue into 'allgc' list */
      g->allgc = o;
      luaC_checkupvalcolor(g, uv);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0x60(%r14), %rsi
testq %rsi, %rsi
je 0xbf9e
cmpq %rbx, 0x10(%rsi)
jb 0xbf9e
movq (%rsi), %rax
movq %rax, 0x60(%r14)
movb 0x9(%rsi), %al
xorb $0x3, %al
movb 0x54(%r15), %cl
xorb $0x3, %cl
testb %al, %cl
je 0xbf94
leaq 0x18(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rdx
movq %rcx, 0x18(%rdx)
movq 0x20(%rsi), %rdx
movq %rdx, 0x20(%rcx)
movq 0x10(%rsi), %rcx
movq (%rcx), %rdx
movq %rdx, 0x18(%rsi)
movl 0x8(%rcx), %ecx
movl %ecx, 0x20(%rsi)
movq %rax, 0x10(%rsi)
movq 0x60(%r15), %rax
movq %rax, (%rsi)
movq %rsi, 0x60(%r15)
movq %r15, %rdi
callq 0xc229
jmp 0xbf2c
movq %r14, %rdi
callq 0xbef5
jmp 0xbf2c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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));
  lua_assert(g->gcstate != GCSpause);
  lua_assert(gch(o)->tt != LUA_TTABLE);
  if (keepinvariantout(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 0xc0cb
movq %rdx, %rsi
jmp 0xc0dc
movb 0x9(%rsi), %al
andb $-0x48, %al
movb 0x54(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: reallymarkobject
static void reallymarkobject (global_State *g, GCObject *o) {
  lu_mem size;
  white2gray(o);
  switch (gch(o)->tt) {
    case LUA_TSHRSTR:
    case LUA_TLNGSTR: {
      size = sizestring(gco2ts(o));
      break;  /* nothing else to mark; make it black */
    }
    case LUA_TUSERDATA: {
      Table *mt = gco2u(o)->metatable;
      markobject(g, mt);
      markobject(g, gco2u(o)->env);
      size = sizeudata(gco2u(o));
      break;
    }
    case LUA_TUPVAL: {
      UpVal *uv = gco2uv(o);
      markvalue(g, uv->v);
      if (uv->v != &uv->u.value)  /* open? */
        return;  /* open upvalues remain gray */
      size = sizeof(UpVal);
      break;
    }
    case LUA_TLCL: {
      gco2lcl(o)->gclist = g->gray;
      g->gray = o;
      return;
    }
    case LUA_TCCL: {
      gco2ccl(o)->gclist = g->gray;
      g->gray = o;
      return;
    }
    case LUA_TTABLE: {
      linktable(gco2t(o), &g->gray);
      return;
    }
    case LUA_TTHREAD: {
      gco2th(o)->gclist = g->gray;
      g->gray = o;
      return;
    }
    case LUA_TPROTO: {
      gco2p(o)->gclist = g->gray;
      g->gray = o;
      return;
    }
    default: lua_assert(0); return;
  }
  gray2black(o);
  g->GCmemtrav += size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
andb $-0x4, 0x9(%rsi)
movq %rdi, %r14
movzbl 0x8(%rsi), %ecx
leal -0x4(%rcx), %eax
cmpl $0x10, %eax
ja 0xc120
leaq 0x12857(%rip), %rcx     # 0x1e958
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x19
popq %r15
pushq $0x10
popq %r12
addq (%rbx,%r12), %r15
orb $0x4, 0x9(%rbx)
addq %r15, 0x20(%r14)
jmp 0xc18c
cmpl $0x26, %ecx
jne 0xc18c
movq 0x80(%r14), %rax
movq %rax, 0x10(%rbx)
jmp 0xc185
movq 0x80(%r14), %rax
movq %rax, 0x68(%rbx)
jmp 0xc185
movq 0x10(%rbx), %rax
testb $0x40, 0x8(%rax)
je 0xc15e
movq (%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0xc15e
movq %r14, %rdi
callq 0xc0dc
movq 0x10(%rbx), %rax
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
jne 0xc18c
pushq $0x28
popq %r15
jmp 0xc116
movq 0x80(%r14), %rax
movq %rax, 0x30(%rbx)
jmp 0xc185
movq 0x80(%r14), %rax
movq %rax, 0x70(%rbx)
movq %rbx, 0x80(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0xc1af
testb $0x3, 0x9(%rsi)
je 0xc1af
movq %r14, %rdi
callq 0xc0dc
movq 0x18(%rbx), %rsi
pushq $0x28
popq %r15
pushq $0x20
popq %r12
testq %rsi, %rsi
je 0xc112
testb $0x3, 0x9(%rsi)
je 0xc112
movq %r14, %rdi
callq 0xc0dc
jmp 0xc112
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_barrierproto_
LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c) {
  global_State *g = G(L);
  lua_assert(isblack(obj2gco(p)));
  if (p->cache == NULL) {  /* first time? */
    luaC_objbarrier(L, p, c);
  }
  else {  /* use a backward barrier */
    black2gray(obj2gco(p));  /* make prototype gray (again) */
    p->gclist = g->grayagain;
    g->grayagain = obj2gco(p);
  }
}

// Assembly:
cmpq $0x0, 0x40(%rsi)
je 0xc218
movq 0x18(%rdi), %rax
andb $-0x5, 0x9(%rsi)
movq 0x88(%rax), %rcx
movq %rcx, 0x70(%rsi)
movq %rsi, 0x88(%rax)
retq
testb $0x3, 0x9(%rdx)
je 0xc217
testb $0x4, 0x9(%rsi)
je 0xc217
jmp 0xc0bc
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_checkupvalcolor
void luaC_checkupvalcolor (global_State *g, UpVal *uv) {
  GCObject *o = obj2gco(uv);
  lua_assert(!isblack(o));  /* open upvalues are never black */
  if (isgray(o)) {
    if (keepinvariant(g)) {
      resetoldbit(o);  /* see MOVE OLD rule */
      gray2black(o);  /* it is being visited now */
      markvalue(g, uv->v);
    }
    else {
      lua_assert(issweepphase(g));
      makewhite(g, o);
    }
  }
}

// Assembly:
movb 0x9(%rsi), %al
testb $0x7, %al
je 0xc231
retq
cmpb $0x2, 0x56(%rdi)
je 0xc23d
cmpb $0x1, 0x55(%rdi)
ja 0xc25c
andb $-0x48, %al
orb $0x4, %al
movb %al, 0x9(%rsi)
movq 0x10(%rsi), %rax
testb $0x40, 0x8(%rax)
je 0xc230
movq (%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0xc230
jmp 0xc0dc
andb $-0x48, %al
movb 0x54(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_checkfinalizer
void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
  global_State *g = G(L);
  if (testbit(gch(o)->marked, SEPARATED) || /* obj. is already separated... */
      isfinalized(o) ||                           /* ... or is finalized... */
      gfasttm(g, mt, TM_GC) == NULL)                /* or has no finalizer? */
    return;  /* nothing to be done */
  else {  /* move 'o' to 'finobj' list */
    GCObject **p;
    GCheader *ho = gch(o);
    if (g->sweepgc == &ho->next) {  /* avoid removing current sweep object */
      lua_assert(issweepphase(g));
      g->sweepgc = sweeptolive(L, g->sweepgc, NULL);
    }
    /* search for pointer pointing to 'o' */
    for (p = &g->allgc; *p != o; p = &gch(*p)->next) { /* empty */ }
    *p = ho->next;  /* remove 'o' from root list */
    ho->next = g->finobj;  /* link it in list 'finobj' */
    g->finobj = o;
    l_setbit(ho->marked, SEPARATED);  /* mark it as such */
    if (!keepinvariantout(g))  /* not keeping invariant? */
      makewhite(g, o);  /* "sweep" object */
    else
      resetoldbit(o);  /* see MOVE OLD rule */
  }
}

// Assembly:
testq %rdx, %rdx
je 0xc363
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movb 0x9(%rsi), %al
andb $0x18, %al
jne 0xc35e
testb $0x4, 0xa(%rdx)
jne 0xc35e
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0x130(%r15), %rax
pushq $0x2
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
callq 0x1694f
testq %rax, %rax
je 0xc35e
movq 0x70(%r15), %rsi
cmpq %rbx, %rsi
jne 0xc31e
movq %r14, %rdi
xorl %edx, %edx
callq 0xc364
movq %rax, 0x70(%r15)
leaq 0x60(%r15), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
cmpq %rbx, %rcx
jne 0xc322
movq (%rbx), %rcx
movq %rcx, (%rax)
movq 0x68(%r15), %rax
movq %rax, (%rbx)
movq %rbx, 0x68(%r15)
movb 0x9(%rbx), %al
orb $0x10, %al
cmpb $0x2, 0x55(%r15)
jae 0xc350
andb $-0x41, %al
movl %eax, %ecx
jmp 0xc35b
andb $-0x48, %al
movb 0x54(%r15), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: sweeptolive
static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) {
  GCObject ** old = p;
  int i = 0;
  do {
    i++;
    p = sweeplist(L, p, 1);
  } while (p == old);
  if (n) *n += i;
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
pushq $0x1
popq %r12
movq %rsi, %rax
incl %ebp
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xc580
cmpq %r14, %rax
je 0xc37e
testq %rbx, %rbx
je 0xc39a
addl %ebp, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_changemode
void luaC_changemode (lua_State *L, int mode) {
  global_State *g = G(L);
  if (mode == g->gckind) return;  /* nothing to change */
  if (mode == KGC_GEN) {  /* change to generational mode */
    /* make sure gray lists are consistent */
    luaC_runtilstate(L, bitmask(GCSpropagate));
    g->GCestimate = gettotalbytes(g);
    g->gckind = KGC_GEN;
  }
  else {  /* change to incremental mode */
    /* sweep all objects to turn them back to white
       (as white has not changed, nothing extra will be collected) */
    g->gckind = KGC_NORMAL;
    entersweep(L);
    luaC_runtilstate(L, ~sweepphases);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %r14
movzbl 0x56(%r14), %eax
cmpl %esi, %eax
je 0xc3d8
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0xc3e0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xc3ff
movq 0x18(%r14), %rax
addq 0x10(%r14), %rax
movq %rax, 0x28(%r14)
movb $0x2, 0x56(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0x56(%r14)
movq %rbx, %rdi
callq 0xc427
pushq $-0x1d
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc3ff
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: entersweep
static int entersweep (lua_State *L) {
  global_State *g = G(L);
  int n = 0;
  g->gcstate = GCSsweepstring;
  lua_assert(g->sweepgc == NULL && g->sweepfin == NULL);
  /* prepare to sweep strings, finalizable objects, and regular objects */
  g->sweepstrgc = 0;
  g->sweepfin = sweeptolive(L, &g->finobj, &n);
  g->sweepgc = sweeptolive(L, &g->allgc, &n);
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r15
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movb $0x2, 0x55(%r15)
andl $0x0, 0x58(%r15)
leaq 0x68(%r15), %rsi
movq %r14, %rdx
callq 0xc364
movq %rax, 0x78(%r15)
leaq 0x60(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc364
movq %rax, 0x70(%r15)
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_freeallobjects
void luaC_freeallobjects (lua_State *L) {
  global_State *g = G(L);
  int i;
  separatetobefnz(L, 1);  /* separate all objects with finalizers */
  lua_assert(g->finobj == NULL);
  callallpendingfinalizers(L, 0);
  g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
  g->gckind = KGC_NORMAL;
  sweepwholelist(L, &g->finobj);  /* finalizers can create objs. in 'finobj' */
  sweepwholelist(L, &g->allgc);
  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
    sweepwholelist(L, &g->strt.hash[i]);
  lua_assert(g->strt.nuse == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
pushq $0x1
popq %rsi
callq 0xc4fc
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc550
movb $0x3, 0x54(%r15)
movb $0x0, 0x56(%r15)
leaq 0x68(%r15), %rsi
pushq $-0x3
popq %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc580
leaq 0x60(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc580
xorl %r13d, %r13d
movslq 0x3c(%r15), %rax
cmpq %rax, %r13
jge 0xc4f2
movq 0x30(%r15), %rsi
addq %r12, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc580
incq %r13
addq $0x8, %r12
jmp 0xc4ce
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: separatetobefnz
static void separatetobefnz (lua_State *L, int all) {
  global_State *g = G(L);
  GCObject **p = &g->finobj;
  GCObject *curr;
  GCObject **lastnext = &g->tobefnz;
  /* find last 'next' field in 'tobefnz' list (to add elements in its end) */
  while (*lastnext != NULL)
    lastnext = &gch(*lastnext)->next;
  while ((curr = *p) != NULL) {  /* traverse all finalizable objects */
    lua_assert(!isfinalized(curr));
    lua_assert(testbit(gch(curr)->marked, SEPARATED));
    if (!(iswhite(curr) || all))  /* not being collected? */
      p = &gch(curr)->next;  /* don't bother with it */
    else {
      l_setbit(gch(curr)->marked, FINALIZEDBIT); /* won't be finalized again */
      *p = gch(curr)->next;  /* remove 'curr' from 'finobj' list */
      gch(curr)->next = *lastnext;  /* link at the end of 'tobefnz' list */
      *lastnext = curr;
      lastnext = &gch(curr)->next;
    }
  }
}

// Assembly:
movq 0x18(%rdi), %rax
leaq 0xa8(%rax), %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0xc507
addq $0x68, %rax
movq (%rax), %rdx
testq %rdx, %rdx
je 0xc54f
movzbl 0x9(%rdx), %edi
movl %edi, %r8d
andl $0x3, %r8d
orl %esi, %r8d
je 0xc54a
orb $0x8, %dil
movb %dil, 0x9(%rdx)
movq (%rdx), %rdi
movq %rdi, (%rax)
movq (%rcx), %rdi
movq %rdi, (%rdx)
movq %rdx, (%rcx)
movq %rdx, %rcx
jmp 0xc516
movq %rdx, %rax
jmp 0xc516
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: callallpendingfinalizers
static void callallpendingfinalizers (lua_State *L, int propagateerrors) {
  global_State *g = G(L);
  while (g->tobefnz) {
    resetoldbit(g->tobefnz);
    GCTM(L, propagateerrors);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0xa8(%r15), %rax
testq %rax, %rax
je 0xc57a
andb $-0x41, 0x9(%rax)
movq %r14, %rdi
movl %ebx, %esi
callq 0xcc0f
jmp 0xc55e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_forcestep
void luaC_forcestep (lua_State *L) {
  global_State *g = G(L);
  int i;
  if (isgenerational(g)) generationalcollection(L);
  else incstep(L);
  /* run a few finalizers (or all of them at the end of a collect cycle) */
  for (i = 0; g->tobefnz && (i < GCFINALIZENUM || g->gcstate == GCSpause); i++)
    GCTM(L, 1);  /* call one finalizer */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpb $0x2, 0x56(%r14)
jne 0xcb32
movq 0x28(%r14), %r15
testq %r15, %r15
je 0xcba0
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0xc3ff
movb $0x0, 0x55(%r14)
movq 0x18(%r14), %rsi
addq 0x10(%r14), %rsi
xorl %ecx, %ecx
pushq $0x64
popq %rdi
movq %r15, %rax
xorl %edx, %edx
divq %rdi
movslq 0xf4(%r14), %rdx
imulq %rax, %rdx
cmpq %rdx, %rsi
cmovaq %rcx, %r15
jmp 0xcbb5
movq 0x18(%r14), %rax
movl 0xf8(%r14), %ecx
cmpl $0x29, %ecx
pushq $0x28
popq %r12
cmovgel %ecx, %r12d
movl $0xc8, %ecx
cqto
idivq %rcx
movq %rax, %rcx
incq %rcx
movabsq $0x7ffffffffffffffc, %rsi # imm = 0x7FFFFFFFFFFFFFFC
movq %rsi, %rax
xorl %edx, %edx
divq %r12
movq %rcx, %r15
imulq %r12, %r15
cmpq %rax, %rcx
cmovgeq %rsi, %r15
movq %rbx, %rdi
callq 0xc71f
subq %rax, %r15
movb 0x55(%r14), %al
cmpq $-0x95f, %r15           # imm = 0xF6A1
jl 0xcb96
cmpb $0x5, %al
jne 0xcb78
jmp 0xcb9a
cmpb $0x5, %al
jne 0xcbf6
movq 0x28(%r14), %rsi
jmp 0xcbb9
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcd65
movq 0x18(%r14), %rsi
addq 0x10(%r14), %rsi
movq %rsi, %r15
movq %r15, 0x28(%r14)
movq %r14, %rdi
callq 0xce15
xorl %r15d, %r15d
pushq $0x1
popq %rbp
cmpq $0x0, 0xa8(%r14)
je 0xcbed
cmpl $0x4, %r15d
jb 0xcbde
cmpb $0x5, 0x55(%r14)
jne 0xcbed
movq %rbx, %rdi
movl %ebp, %esi
callq 0xcc0f
incl %r15d
jmp 0xcbc7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rax
cqto
idivq %r12
imulq $0xc8, %rax, %rsi
movq %r14, %rdi
callq 0x130b0
jmp 0xcbc1
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_fullgc
void luaC_fullgc (lua_State *L, int isemergency) {
  global_State *g = G(L);
  int origkind = g->gckind;
  lua_assert(origkind != KGC_EMERGENCY);
  if (isemergency)  /* do not run finalizers during emergency GC */
    g->gckind = KGC_EMERGENCY;
  else {
    g->gckind = KGC_NORMAL;
    callallpendingfinalizers(L, 1);
  }
  if (keepinvariant(g)) {  /* may there be some black objects? */
    /* must sweep all objects to turn them back to white
       (as white has not changed, nothing will be collected) */
    entersweep(L);
  }
  /* 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(GCSpause));  /* run entire collection */
  if (origkind == KGC_GEN) {  /* generational mode? */
    /* generational mode must be kept in propagate phase */
    luaC_runtilstate(L, bitmask(GCSpropagate));
  }
  g->gckind = origkind;
  setpause(g, gettotalbytes(g));
  if (!isemergency)   /* do not run finalizers during emergency GC */
    callallpendingfinalizers(L, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movb 0x56(%r14), %r12b
testl %esi, %esi
je 0xcd85
movb $0x1, 0x56(%r14)
jmp 0xcd9c
movb $0x0, 0x56(%r14)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xc550
cmpb $0x2, 0x56(%r14)
je 0xcda3
cmpb $0x1, 0x55(%r14)
ja 0xcdab
movq %rbx, %rdi
callq 0xc427
pushq $0x20
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0xc3ff
pushq $-0x21
popq %rsi
movq %rbx, %rdi
callq 0xc3ff
movq %rbx, %rdi
movl %r15d, %esi
callq 0xc3ff
cmpb $0x2, %r12b
jne 0xcde1
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xc3ff
movb %r12b, 0x56(%r14)
movq 0x18(%r14), %rsi
addq 0x10(%r14), %rsi
movq %r14, %rdi
callq 0xce15
testl %ebp, %ebp
je 0xce02
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc550
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: setpause
static void setpause (global_State *g, l_mem estimate) {
  l_mem debt, threshold;
  estimate = estimate / PAUSEADJ;  /* adjust 'estimate' */
  threshold = (g->gcpause < MAX_LMEM / estimate)  /* overflow? */
            ? estimate * g->gcpause  /* no overflow */
            : MAX_LMEM;  /* overflow; truncate to maximum */
  debt = -cast(l_mem, threshold - gettotalbytes(g));
  luaE_setdebt(g, debt);
}

// Assembly:
movq %rsi, %rax
pushq $0x64
popq %rcx
cqto
idivq %rcx
movq %rax, %rcx
movslq 0xf0(%rdi), %r8
movabsq $0x7ffffffffffffffc, %rsi # imm = 0x7FFFFFFFFFFFFFFC
movq %rsi, %rax
xorl %edx, %edx
idivq %rcx
imulq %r8, %rcx
cmpq %r8, %rax
cmovleq %rsi, %rcx
movq 0x18(%rdi), %rsi
addq 0x10(%rdi), %rsi
subq %rcx, %rsi
jmp 0x130b0
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: markbeingfnz
static void markbeingfnz (global_State *g) {
  GCObject *o;
  for (o = g->tobefnz; o != NULL; o = gch(o)->next) {
    makewhite(g, o);
    reallymarkobject(g, o);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movq (%r14), %r14
testq %r14, %r14
je 0xd3c3
movb 0x9(%r14), %al
andb $-0x48, %al
movb 0x54(%rbx), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc0dc
jmp 0xd39c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: traverseephemeron
static int traverseephemeron (global_State *g, Table *h) {
  int marked = 0;  /* true if an object is marked in this traversal */
  int hasclears = 0;  /* true if table has white keys */
  int prop = 0;  /* true if table has entry "white-key -> white-value" */
  Node *n, *limit = gnodelast(h);
  int i;
  /* traverse array part (numeric keys are 'strong') */
  for (i = 0; i < h->sizearray; i++) {
    if (valiswhite(&h->array[i])) {
      marked = 1;
      reallymarkobject(g, gcvalue(&h->array[i]));
    }
  }
  /* traverse hash part */
  for (n = gnode(h, 0); n < limit; n++) {
    checkdeadkey(n);
    if (ttisnil(gval(n)))  /* entry is empty? */
      removeentry(n);  /* remove it */
    else if (iscleared(g, gkey(n))) {  /* key is not marked (yet)? */
      hasclears = 1;  /* table must be cleared */
      if (valiswhite(gval(n)))  /* value not marked yet? */
        prop = 1;  /* must propagate again */
    }
    else if (valiswhite(gval(n))) {  /* value not marked yet? */
      marked = 1;
      reallymarkobject(g, gcvalue(gval(n)));  /* mark it now */
    }
  }
  if (prop)
    linktable(h, &g->ephemeron);  /* have to propagate again */
  else if (hasclears)  /* does table have white keys? */
    linktable(h, &g->allweak);  /* may have to clean white keys */
  else  /* no white keys */
    linktable(h, &g->grayagain);  /* no need to clean */
  return marked;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %r12
movb 0xb(%rsi), %cl
pushq $0x1
popq %rbp
movl %ebp, %eax
shll %cl, %eax
cltq
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
pushq $0x8
popq %r15
movl $0x0, 0xc(%rsp)
movslq 0x38(%rbx), %rax
cmpq %rax, %r13
jge 0xd437
movq 0x18(%rbx), %rax
testb $0x40, (%rax,%r15)
je 0xd42e
movq -0x8(%rax,%r15), %rsi
testb $0x3, 0x9(%rsi)
je 0xd42e
movq %r14, %rdi
callq 0xc0dc
movl %ebp, 0xc(%rsp)
incq %r13
addq $0x10, %r15
jmp 0xd403
imulq $0x28, 0x10(%rsp), %rax
addq %rax, %r12
movq 0x20(%rbx), %r15
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %r12, %r15
jae 0xd4b2
cmpl $0x0, 0x8(%r15)
je 0xd474
leaq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0xd51b
movl 0x8(%r15), %ecx
testl %eax, %eax
je 0xd47e
testb $0x40, %cl
jne 0xd49d
pushq $0x1
popq %r13
jmp 0xd4ac
movq %r15, %rdi
callq 0xd503
jmp 0xd4ac
testb $0x40, %cl
je 0xd4ac
movq (%r15), %rsi
testb $0x3, 0x9(%rsi)
je 0xd4ac
movq %r14, %rdi
callq 0xc0dc
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
jmp 0xd4ac
movq (%r15), %rax
testb $0x3, 0x9(%rax)
pushq $0x1
popq %r13
cmovnel %r13d, %ebp
addq $0x28, %r15
jmp 0xd449
testl %ebp, %ebp
je 0xd4c6
movq 0x98(%r14), %rax
addq $0x98, %r14
jmp 0xd4e9
testl %r13d, %r13d
je 0xd4db
movq 0xa0(%r14), %rax
addq $0xa0, %r14
jmp 0xd4e9
movq 0x88(%r14), %rax
addq $0x88, %r14
movq %rax, 0x30(%rbx)
movq %rbx, (%r14)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: iscleared
static int iscleared (global_State *g, const TValue *o) {
  if (!iscollectable(o)) return 0;
  else if (ttisstring(o)) {
    markobject(g, rawtsvalue(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 0xd549
andl $0xf, %eax
movq (%rsi), %rsi
cmpl $0x4, %eax
jne 0xd542
testq %rsi, %rsi
je 0xd549
testb $0x3, 0x9(%rsi)
je 0xd549
callq 0xc0dc
jmp 0xd549
movzbl 0x9(%rsi), %ebx
andl $0x3, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/linit.c
// Function: luaL_openlibs
LUALIB_API void luaL_openlibs (lua_State *L) {
  const luaL_Reg *lib;
  /* call open functions from 'loadedlibs' and set results to global table */
  for (lib = loadedlibs; lib->func; lib++) {
    luaL_requiref(L, lib->name, lib->func, 1);
    lua_pop(L, 1);  /* remove lib */
  }
  /* add open functions from 'preloadedlibs' into 'package.preload' table */
  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
  for (lib = preloadedlibs; lib->func; lib++) {
    lua_pushcfunction(L, lib->func);
    lua_setfield(L, -2, lib->name);
  }
  lua_pop(L, 1);  /* remove _PRELOAD table */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1e8cf(%rip), %r15     # 0x2bfd8
pushq $0x1
popq %rbp
pushq $-0x2
popq %r14
movq (%r15), %rdx
testq %rdx, %rdx
je 0xd737
movq -0x8(%r15), %rsi
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x9e6a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7437
addq $0x10, %r15
jmp 0xd710
leaq 0x112f7(%rip), %rdx     # 0x1ea35
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x9df5
pushq $-0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7437
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: io_popen
static int io_popen (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  LStream *p = newprefile(L);
  p->f = lua_popen(L, filename, mode);
  p->closef = &io_pclose;
  return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x9264
movq %rax, %r14
leaq 0x117d7(%rip), %rdx     # 0x1f278
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x920b
movq %rax, %r15
movq %rbx, %rdi
callq 0xdd7b
movq %rax, %r12
xorl %edi, %edi
callq 0x63b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x64a0
movq %rax, (%r12)
leaq 0x7f5(%rip), %rcx       # 0xe2ce
movq %rcx, 0x8(%r12)
testq %rax, %rax
je 0xdaf2
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8f0e
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: aux_close
static int aux_close (lua_State *L) {
  LStream *p = tolstream(L);
  lua_CFunction cf = p->closef;
  p->closef = NULL;  /* mark stream as closed */
  return (*cf)(L);  /* close it */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10e76(%rip), %rdx     # 0x1ea9d
pushq $0x1
popq %rsi
callq 0x9114
movq 0x8(%rax), %rcx
andq $0x0, 0x8(%rax)
movq %rbx, %rdi
popq %rbx
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: getiofile
static FILE *getiofile (lua_State *L, const char *findex) {
  LStream *p;
  lua_getfield(L, LUA_REGISTRYINDEX, findex);
  p = (LStream *)lua_touserdata(L, -1);
  if (isclosed(p))
    luaL_error(L, "standard %s file is closed", findex + strlen(IO_PREFIX));
  return p->f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x7e19
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x7a37
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
jne 0xdc83
addq $0x4, %rbx
leaq 0x10e4a(%rip), %rsi     # 0x1eac0
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8d68
movq (%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: opencheck
static void opencheck (lua_State *L, const char *fname, const char *mode) {
  LStream *p = newfile(L);
  p->f = fopen(fname, mode);
  if (p->f == NULL)
    luaL_error(L, "cannot open file " LUA_QS " (%s)", fname, strerror(errno));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0xdd64
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6330
movq %rax, (%r12)
testq %rax, %rax
je 0xdd36
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6080
movl (%rax), %edi
callq 0x6560
leaq 0x10d92(%rip), %rsi     # 0x1eadb
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8d68
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: aux_lines
static void aux_lines (lua_State *L, int toclose) {
  int i;
  int n = lua_gettop(L) - 1;  /* number of arguments to read */
  /* ensure that arguments will fit here and into 'io_readline' stack */
  luaL_argcheck(L, n <= LUA_MINSTACK - 3, LUA_MINSTACK - 3, "too many options");
  lua_pushvalue(L, 1);  /* file handle */
  lua_pushinteger(L, n);  /* number of arguments to read */
  lua_pushboolean(L, toclose);  /* close/not close file when finished */
  for (i = 1; i <= n; i++) lua_pushvalue(L, i + 1);  /* copy arguments */
  lua_pushcclosure(L, io_readline, 3 + n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7423
movl %eax, %r14d
leal -0x1(%r14), %r12d
cmpl $0x13, %eax
jl 0xde0a
leaq 0x10cf7(%rip), %rdx     # 0x1eaf6
pushq $0x11
popq %rsi
movq %rbx, %rdi
callq 0x8c84
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7604
movslq %r12d, %rsi
movq %rbx, %rdi
callq 0x7af1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d3d
cmpl %r14d, %r15d
jge 0xde43
incl %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7604
jmp 0xde2e
addl $0x2, %r14d
leaq 0x13(%rip), %rsi        # 0xde61
movq %rbx, %rdi
movl %r14d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7cba
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: io_readline
static int io_readline (lua_State *L) {
  LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1));
  int i;
  int n = (int)lua_tointeger(L, lua_upvalueindex(2));
  if (isclosed(p))  /* file is already closed? */
    return luaL_error(L, "file is already closed");
  lua_settop(L , 1);
  for (i = 1; i <= n; i++)  /* push arguments to 'g_read' */
    lua_pushvalue(L, lua_upvalueindex(3 + i));
  n = g_read(L, p->f, 2);  /* 'n' is number of results */
  lua_assert(n > 0);  /* should return at least a nil */
  if (!lua_isnil(L, -n))  /* read at least one value? */
    return n;  /* return them */
  else {  /* first result is nil: EOF or error */
    if (n > 1) {  /* is there error information? */
      /* 2nd result is error message */
      return luaL_error(L, "%s", lua_tostring(L, -n + 1));
    }
    if (lua_toboolean(L, lua_upvalueindex(3))) {  /* generator created file? */
      lua_settop(L, 0);
      lua_pushvalue(L, lua_upvalueindex(1));
      aux_close(L);  /* close it */
    }
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x7a37
movq %rax, %r14
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
xorl %edx, %edx
callq 0x78a4
cmpq $0x0, 0x8(%r14)
je 0xdef7
movq %rax, %r15
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7437
testl %r15d, %r15d
cmovgl %r15d, %r12d
movl $0xfff0b9d4, %r15d      # imm = 0xFFF0B9D4
leal (%r12,%r15), %eax
cmpl $0xfff0b9d4, %eax       # imm = 0xFFF0B9D4
je 0xdeca
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7604
decl %r15d
jmp 0xdeaf
movq (%r14), %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0xdf79
movl %eax, %r14d
movl %eax, %esi
negl %esi
movq %rbx, %rdi
callq 0x7624
testl %eax, %eax
je 0xdf10
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10c09(%rip), %rsi     # 0x1eb07
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d68
cmpl $0x2, %r14d
jl 0xdf41
subl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7967
leaq 0x10fc5(%rip), %rsi     # 0x1eef1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d68
movq %rbx, %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x7943
xorl %r14d, %r14d
testl %eax, %eax
je 0xdeeb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7437
movq %rbx, %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x7604
movq %rbx, %rdi
callq 0xdc1c
jmp 0xdeeb
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: read_line
static int read_line (lua_State *L, FILE *f, int chop) {
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  for (;;) {
    size_t l;
    char *p = luaL_prepbuffer(&b);
    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
      luaL_pushresult(&b);  /* close buffer */
      return (lua_rawlen(L, -1) > 0);  /* check whether read something */
    }
    l = strlen(p);
    if (l == 0 || p[l-1] != '\n')
      luaL_addsize(&b, l);
    else {
      luaL_addsize(&b, l - chop);  /* chop 'eol' if needed */
      luaL_pushresult(&b);  /* close buffer */
      return 1;  /* read at least an `eol' */
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rsi
callq 0x9657
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rdi
callq 0x94ad
movq %rax, %r12
movq %rax, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdx
callq 0x62a0
testq %rax, %rax
je 0xe28a
movq %r12, %rdi
callq 0x6170
testq %rax, %rax
je 0xe283
cmpb $0xa, -0x1(%r12,%rax)
je 0xe2aa
addq %rax, 0x10(%rsp)
jmp 0xe249
movq %rsp, %rdi
callq 0x95ae
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x79d7
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0xe2be
movl %ebp, %ecx
subq %rcx, %rax
movq %rsp, %rdi
addq %rax, 0x10(%rdi)
callq 0x95ae
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: g_write
static int g_write (lua_State *L, FILE *f, int arg) {
  int nargs = lua_gettop(L) - arg;
  int status = 1;
  for (; nargs--; arg++) {
    if (lua_type(L, arg) == LUA_TNUMBER) {
      /* optimization: could be done exactly as for strings */
      status = status &&
          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
    }
    else {
      size_t l;
      const char *s = luaL_checklstring(L, arg, &l);
      status = status && (fwrite(s, sizeof(char), l, f) == l);
    }
  }
  if (status) return 1;  /* file handle already on stack top */
  else return luaL_fileresult(L, status, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7423
movl %eax, %r15d
pushq $0x1
popq %r12
movq %rsp, %r13
cmpl %ebp, %r15d
je 0xe38f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7624
cmpl $0x3, %eax
jne 0xe357
testl %r12d, %r12d
je 0xe388
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x785f
movq %r14, %rdi
leaq 0x1081f(%rip), %rsi     # 0x1eb64
movb $0x1, %al
callq 0x6310
xorl %r12d, %r12d
testl %eax, %eax
setg %r12b
jmp 0xe38b
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x9264
testl %r12d, %r12d
je 0xe388
movq (%rsp), %rdx
movq %rax, %rdi
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x6540
xorl %r12d, %r12d
cmpq (%rsp), %rax
sete %r12b
jmp 0xe38b
xorl %r12d, %r12d
incl %ebp
jmp 0xe316
testl %r12d, %r12d
je 0xe399
pushq $0x1
popq %rax
jmp 0xe3a5
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8f0e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: f_seek
static int f_seek (lua_State *L) {
  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
  static const char *const modenames[] = {"set", "cur", "end", NULL};
  FILE *f = tofile(L);
  int op = luaL_checkoption(L, 2, "cur", modenames);
  lua_Number p3 = luaL_optnumber(L, 3, 0);
  l_seeknum offset = (l_seeknum)p3;
  luaL_argcheck(L, (lua_Number)offset == p3, 3,
                  "not an integer in proper range");
  op = l_fseek(f, offset, mode[op]);
  if (op)
    return luaL_fileresult(L, 0, NULL);  /* error */
  else {
    lua_pushnumber(L, (lua_Number)l_ftell(f));
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xdbe0
movq %rax, %r14
leaq 0x10763(%rip), %rdx     # 0x1eb84
leaq 0x1ddb8(%rip), %rcx     # 0x2c1e0
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x918e
movl %eax, %ebp
pushq $0x3
popq %rsi
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x93a6
cvttsd2si %xmm0, %r15
cvtsi2sd %r15, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe456
jnp 0xe468
leaq 0x1072f(%rip), %rdx     # 0x1eb8c
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x8c84
movslq %ebp, %rax
leaq 0x10776(%rip), %rcx     # 0x1ebe8
movl (%rcx,%rax,4), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x6440
testl %eax, %eax
je 0xe49a
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8f0e
movq %r14, %rdi
callq 0x6270
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x7adc
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: luaopen_math
LUAMOD_API int luaopen_math (lua_State *L) {
  luaL_newlib(L, mathlib);
  lua_pushnumber(L, PI);
  lua_setfield(L, -2, "pi");
  lua_pushnumber(L, HUGE_VAL);
  lua_setfield(L, -2, "huge");
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1b
popq %rdx
xorl %esi, %esi
callq 0x7f1a
leaq 0x1dc05(%rip), %rsi     # 0x2c220
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9c9a
movsd 0x105d3(%rip), %xmm0    # 0x1ec00
movq %rbx, %rdi
callq 0x7adc
leaq 0x10604(%rip), %rdx     # 0x1ec40
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x809d
movsd 0x105b7(%rip), %xmm0    # 0x1ec08
movq %rbx, %rdi
callq 0x7adc
leaq 0x105e3(%rip), %rdx     # 0x1ec43
movq %rbx, %rdi
movl %ebp, %esi
callq 0x809d
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_frexp
static int math_frexp (lua_State *L) {
  int e;
  lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
  lua_pushinteger(L, e);
  return 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x9364
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x62b0
movq %rbx, %rdi
callq 0x7adc
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x7af1
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_ldexp
static int math_ldexp (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  int ep = luaL_checkint(L, 2);
  lua_pushnumber(L, l_mathop(ldexp)(x, ep));
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x9364
movsd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x93db
movsd (%rsp), %xmm0
movl %eax, %edi
callq 0x6090
movq %rbx, %rdi
callq 0x7adc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_log
static int math_log (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number res;
  if (lua_isnoneornil(L, 2))
    res = l_mathop(log)(x);
  else {
    lua_Number base = luaL_checknumber(L, 2);
    if (base == (lua_Number)10.0) res = l_mathop(log10)(x);
    else res = l_mathop(log)(x)/l_mathop(log)(base);
  }
  lua_pushnumber(L, res);
  return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x9364
movsd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7624
testl %eax, %eax
jle 0xe92f
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x9364
ucomisd 0x102f9(%rip), %xmm0    # 0x1ec18
jne 0xe93b
jp 0xe93b
movsd (%rsp), %xmm0
callq 0x6300
jmp 0xe968
movsd (%rsp), %xmm0
callq 0x6210
jmp 0xe968
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x6210
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6210
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x7adc
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_max
static int math_max (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  lua_Number dmax = luaL_checknumber(L, 1);
  int i;
  for (i=2; i<=n; i++) {
    lua_Number d = luaL_checknumber(L, i);
    if (d > dmax)
      dmax = d;
  }
  lua_pushnumber(L, dmax);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7423
movl %eax, %ebp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x9364
pushq $0x2
popq %r14
cmpl %ebp, %r14d
jg 0xe9bb
movq %rbx, %rdi
movl %r14d, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x9364
maxsd 0x8(%rsp), %xmm0
incl %r14d
jmp 0xe99a
movq %rbx, %rdi
callq 0x7adc
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_min
static int math_min (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  lua_Number dmin = luaL_checknumber(L, 1);
  int i;
  for (i=2; i<=n; i++) {
    lua_Number d = luaL_checknumber(L, i);
    if (d < dmin)
      dmin = d;
  }
  lua_pushnumber(L, dmin);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7423
movl %eax, %ebp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x9364
pushq $0x2
popq %r14
cmpl %ebp, %r14d
jg 0xea11
movq %rbx, %rdi
movl %r14d, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x9364
minsd 0x8(%rsp), %xmm0
incl %r14d
jmp 0xe9f0
movq %rbx, %rdi
callq 0x7adc
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_modf
static int math_modf (lua_State *L) {
  lua_Number ip;
  lua_Number fp = l_mathop(modf)(luaL_checknumber(L, 1), &ip);
  lua_pushnumber(L, ip);
  lua_pushnumber(L, fp);
  return 2;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x9364
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x61c0
movsd %xmm0, 0x8(%rsp)
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x7adc
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x7adc
pushq $0x2
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq