LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x60(%rdi), %rsi
testq %rsi, %rsi
je 0xc718
movq %rdi, %r14
movq 0x18(%rdi), %r15
cmpq %rbx, 0x10(%rsi)
jb 0xc718
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 0xc707
leaq 0x18(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rdx
movq %rcx, 0x18(%rdx)
movq 0x18(%rsi), %rcx
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 0xc9cc
jmp 0xc70f
movq %r14, %rdi
callq 0xc65e
movq 0x60(%r14), %rsi
testq %rsi, %rsi
jne 0xc6a4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc84b
movq %rdx, %rsi
jmp 0xc85c
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_O1/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 0xc8a4
leaq 0x14107(%rip), %rcx     # 0x20988
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x19, %r15d
movl $0x10, %r12d
addq (%rbx,%r12), %r15
orb $0x4, 0x9(%rbx)
addq %r15, 0x20(%r14)
jmp 0xc90f
cmpl $0x26, %ecx
jne 0xc90f
movq 0x80(%r14), %rax
movq %rax, 0x10(%rbx)
jmp 0xc908
movq 0x80(%r14), %rax
movq %rax, 0x68(%rbx)
jmp 0xc908
movq 0x10(%rbx), %rax
testb $0x40, 0x8(%rax)
je 0xc8de
movq (%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0xc8de
movq %r14, %rdi
callq 0xc85c
leaq 0x18(%rbx), %rax
cmpq %rax, 0x10(%rbx)
jne 0xc90f
movl $0x28, %r15d
jmp 0xc89a
movq 0x80(%r14), %rax
movq %rax, 0x30(%rbx)
jmp 0xc908
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 0xc932
testb $0x3, 0x9(%rsi)
je 0xc932
movq %r14, %rdi
callq 0xc85c
movq 0x18(%rbx), %rsi
movl $0x28, %r15d
movl $0x20, %r12d
testq %rsi, %rsi
je 0xc896
testb $0x3, 0x9(%rsi)
je 0xc896
movq %r14, %rdi
callq 0xc85c
jmp 0xc896
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_barrierback_
void luaC_barrierback_ (lua_State *L, GCObject *o) {
  global_State *g = G(L);
  lua_assert(isblack(o) && !isdead(g, o) && gch(o)->tt == LUA_TTABLE);
  black2gray(o);  /* make object gray (again) */
  gco2t(o)->gclist = g->grayagain;
  g->grayagain = o;
}

// Assembly:
movq 0x18(%rdi), %rax
andb $-0x5, 0x9(%rsi)
movq 0x88(%rax), %rcx
movq %rcx, 0x30(%rsi)
movq %rsi, 0x88(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc99f
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 0xc99e
movb 0x9(%rsi), %al
testb $0x4, %al
je 0xc99e
movq 0x18(%rdi), %rdi
cmpb $0x1, 0x55(%rdi)
ja 0xc9be
movq %rdx, %rsi
jmp 0xc85c
andb $-0x48, %al
movb 0x54(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc9d4
retq
cmpb $0x2, 0x56(%rdi)
je 0xc9e0
cmpb $0x1, 0x55(%rdi)
ja 0xc9ff
andb $-0x48, %al
orb $0x4, %al
movb %al, 0x9(%rsi)
movq 0x10(%rsi), %rax
testb $0x40, 0x8(%rax)
je 0xc9d3
movq (%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0xc9d3
jmp 0xc85c
andb $-0x48, %al
movb 0x54(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: luaC_newobj
GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, GCObject **list,
                       int offset) {
  global_State *g = G(L);
  char *raw = cast(char *, luaM_newobject(L, novariant(tt), sz));
  GCObject *o = obj2gco(raw + offset);
  if (list == NULL)
    list = &g->allgc;  /* standard list for collectable objects */
  gch(o)->marked = luaC_white(g);
  gch(o)->tt = tt;
  gch(o)->next = *list;
  *list = o;
  return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %rcx
movl %esi, %ebp
movq 0x18(%rdi), %r15
movl %esi, %edx
andl $0xf, %edx
xorl %esi, %esi
callq 0xfa40
leaq 0x60(%r15), %rdx
testq %r14, %r14
cmovneq %r14, %rdx
movslq %ebx, %rsi
leaq (%rax,%rsi), %rcx
movb 0x54(%r15), %dil
andb $0x3, %dil
movb %dil, 0x9(%rax,%rsi)
movb %bpl, 0x8(%rax,%rsi)
movq (%rdx), %rdi
movq %rdi, (%rax,%rsi)
movq %rcx, (%rdx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcb2a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x9(%rsi), %al
andb $0x18, %al
jne 0xcb1f
testb $0x4, 0xa(%rdx)
jne 0xcb1f
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0x130(%r15), %rax
movq %rdx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18145
testq %rax, %rax
je 0xcb1f
movq 0x70(%r15), %r12
cmpq %rbx, %r12
jne 0xcadc
movq %r12, %rax
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xcd50
cmpq %r12, %rax
je 0xcac3
movq %rax, 0x70(%r15)
leaq 0x60(%r15), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
cmpq %rbx, %rcx
jne 0xcae0
movq (%rbx), %rcx
movq %rcx, (%rax)
movq 0x68(%r15), %rax
movq %rax, (%rbx)
movq %rbx, 0x68(%r15)
movb 0x9(%rbx), %al
orb $0x10, %al
movb %al, 0x9(%rbx)
cmpb $0x2, 0x55(%r15)
jae 0xcb11
andb $-0x41, %al
movl %eax, %ecx
jmp 0xcb1c
andb $-0x48, %al
movb 0x54(%r15), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcb62
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0xcb6a
movq %rbx, %rdi
movl $0x1, %esi
callq 0xcb8b
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 0xcbbb
movq %rbx, %rdi
movl $0xffffffe3, %esi       # imm = 0xFFFFFFE3
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcb8b
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movb $0x2, 0x55(%r14)
movl $0x0, 0x58(%r14)
leaq 0x68(%r14), %r15
xorl %ebp, %ebp
movq %r15, %rax
incl %ebp
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xcd50
cmpq %r15, %rax
je 0xcbdf
movq %rax, 0x78(%r14)
leaq 0x60(%r14), %r15
movq %r15, %rax
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xcd50
incl %ebp
cmpq %r15, %rax
je 0xcc01
movq %rax, 0x70(%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movl $0x1, %esi
callq 0xccbb
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcd16
movb $0x3, 0x54(%r14)
movb $0x0, 0x56(%r14)
leaq 0x68(%r14), %rsi
movq %rbx, %rdi
movq $-0x3, %rdx
callq 0xcd50
leaq 0x60(%r14), %rsi
movq %rbx, %rdi
movq $-0x3, %rdx
callq 0xcd50
cmpl $0x0, 0x3c(%r14)
jle 0xccaf
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x30(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq $-0x3, %rdx
callq 0xcd50
incq %r12
movslq 0x3c(%r14), %rax
addq $0x8, %r15
cmpq %rax, %r12
jl 0xcc89
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xccc6
movq 0x68(%rax), %rdx
testq %rdx, %rdx
je 0xcd15
addq $0x68, %rax
movzbl 0x9(%rdx), %edi
movl %edi, %r8d
andl $0x3, %r8d
orl %esi, %r8d
je 0xcd0a
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 0xcd0d
movq %rdx, %rax
movq (%rax), %rdx
testq %rdx, %rdx
jne 0xccde
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x18(%rdi), %r15
movq 0xa8(%r15), %rax
testq %rax, %rax
je 0xcd4a
movl %esi, %ebx
movq %rdi, %r14
andb $-0x41, 0x9(%rax)
movq %r14, %rdi
movl %ebx, %esi
callq 0xd534
movq 0xa8(%r15), %rax
testq %rax, %rax
jne 0xcd30
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x7ffffffffffffffc, %r12 # imm = 0x7FFFFFFFFFFFFFFC
movq 0x18(%rdi), %r14
cmpb $0x2, 0x56(%r14)
jne 0xd3b3
movq 0x28(%r14), %r15
movq %rbx, %rdi
testq %r15, %r15
je 0xd489
movl $0x20, %esi
callq 0xcb8b
movb $0x0, 0x55(%r14)
movq 0x18(%r14), %rcx
addq 0x10(%r14), %rcx
movq %r15, %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
shrq $0x2, %rdx
movslq 0xf4(%r14), %rsi
imulq %rdx, %rsi
xorl %eax, %eax
cmpq %rsi, %rcx
cmovbeq %r15, %rax
jmp 0xd498
movq 0x18(%r14), %rcx
movl 0xf8(%r14), %eax
cmpl $0x29, %eax
movl $0x28, %r13d
cmovgel %eax, %r13d
movabsq $-0x5c28f5c28f5c28f5, %rbp # imm = 0xA3D70A3D70A3D70B
movq %rcx, %rax
imulq %rbp
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
leaq (%rdx,%rax), %rcx
incq %rcx
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
xorl %edx, %edx
divq %r13
movq %rcx, %r15
imulq %r13, %r15
cmpq %rax, %rcx
cmovgeq %r12, %r15
movq %rbx, %rdi
callq 0xcf06
subq %rax, %r15
cmpq $-0x95f, %r15           # imm = 0xF6A1
jl 0xd428
cmpb $0x5, 0x55(%r14)
jne 0xd40d
cmpb $0x5, 0x55(%r14)
jne 0xd478
movq 0x18(%r14), %rsi
movq 0x28(%r14), %rcx
movq %rcx, %rax
imulq %rbp
movq %rdx, %rdi
addq %rcx, %rdi
movq %rdi, %rax
shrq $0x3f, %rax
sarq $0x6, %rdi
addq %rax, %rdi
movslq 0xf0(%r14), %rcx
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
xorl %edx, %edx
idivq %rdi
imulq %rcx, %rdi
cmpq %rcx, %rax
cmovgq %rdi, %r12
addq 0x10(%r14), %rsi
jmp 0xd4e9
movq %r15, %rax
cqto
idivq %r13
imulq $0xc8, %rax, %rsi
jmp 0xd4ec
xorl %esi, %esi
callq 0xd68e
movq 0x18(%r14), %rax
addq 0x10(%r14), %rax
movq %rax, 0x28(%r14)
movq 0x18(%r14), %rsi
addq 0x10(%r14), %rsi
movabsq $-0x5c28f5c28f5c28f5, %rcx # imm = 0xA3D70A3D70A3D70B
movq %rsi, %rax
imulq %rcx
movq %rdx, %rcx
addq %rsi, %rcx
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x6, %rcx
addq %rax, %rcx
movslq 0xf0(%r14), %rdi
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
xorl %edx, %edx
idivq %rcx
imulq %rdi, %rcx
cmpq %rdi, %rax
cmovgq %rcx, %r12
subq %r12, %rsi
movq %r14, %rdi
callq 0x14318
cmpq $0x0, 0xa8(%r14)
je 0xd525
xorl %ebp, %ebp
cmpl $0x4, %ebp
jb 0xd50c
cmpb $0x5, 0x55(%r14)
jne 0xd525
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd534
incl %ebp
cmpq $0x0, 0xa8(%r14)
jne 0xd500
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movb 0x56(%r14), %r15b
testl %esi, %esi
je 0xd6ad
movb $0x1, 0x56(%r14)
jmp 0xd6bf
movb $0x0, 0x56(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xcd16
cmpb $0x2, 0x56(%r14)
je 0xd6cd
cmpb $0x1, 0x55(%r14)
ja 0xd6d5
movq %rbx, %rdi
callq 0xcbbb
movq %rbx, %rdi
movl $0x20, %esi
callq 0xcb8b
movq %rbx, %rdi
movl $0xffffffdf, %esi       # imm = 0xFFFFFFDF
callq 0xcb8b
movq %rbx, %rdi
movl $0x20, %esi
callq 0xcb8b
cmpb $0x2, %r15b
jne 0xd70f
movq %rbx, %rdi
movl $0x1, %esi
callq 0xcb8b
movb %r15b, 0x56(%r14)
movq 0x18(%r14), %rsi
addq 0x10(%r14), %rsi
movabsq $-0x5c28f5c28f5c28f5, %rcx # imm = 0xA3D70A3D70A3D70B
movq %rsi, %rax
imulq %rcx
movq %rdx, %rcx
addq %rsi, %rcx
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x6, %rcx
addq %rax, %rcx
movslq 0xf0(%r14), %r8
movabsq $0x7ffffffffffffffc, %rdi # imm = 0x7FFFFFFFFFFFFFFC
movq %rdi, %rax
xorl %edx, %edx
idivq %rcx
imulq %r8, %rcx
cmpq %r8, %rax
cmovleq %rdi, %rcx
subq %rcx, %rsi
movq %r14, %rdi
callq 0x14318
testl %ebp, %ebp
je 0xd77d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcd16
// File: /workspace/github_c_makefile_star2_O1/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 0xa8(%rdi), %r14
testq %r14, %r14
je 0xde7a
movq %rdi, %rbx
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 0xc85c
movq (%r14), %r14
testq %r14, %r14
jne 0xde55
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rsi, %rbx
movb 0xb(%rsi), %cl
movl $0x1, %eax
shll %cl, %eax
movq %rdi, %r14
cltq
leaq (%rax,%rax,4), %r15
shlq $0x3, %r15
addq 0x20(%rsi), %r15
cmpl $0x0, 0x38(%rsi)
jle 0xdef1
xorl %r12d, %r12d
movl $0x8, %r13d
xorl %eax, %eax
movq 0x18(%rbx), %rcx
testb $0x40, (%rcx,%r13)
je 0xdedf
movq -0x8(%rcx,%r13), %rsi
testb $0x3, 0x9(%rsi)
je 0xdedf
movq %r14, %rdi
callq 0xc85c
movl $0x1, %eax
incq %r12
movslq 0x38(%rbx), %rcx
addq $0x10, %r13
cmpq %rcx, %r12
jl 0xdebc
jmp 0xdef3
xorl %eax, %eax
movq 0x20(%rbx), %r12
movb $0x1, %dl
cmpq %r15, %r12
jae 0xdf98
movl %eax, 0x4(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpl $0x0, 0x8(%r12)
je 0xdf41
leaq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0xdfe6
movl 0x8(%r12), %ecx
testl %eax, %eax
je 0xdf5f
movl $0x1, %ebp
testb $0x40, %cl
je 0xdf7e
movq (%r12), %rax
testb $0x3, 0x9(%rax)
cmovnel %ebp, %r13d
jmp 0xdf7e
testb $0x40, 0x18(%r12)
je 0xdf7e
movq 0x10(%r12), %rax
testb $0x3, 0x9(%rax)
je 0xdf7e
movl $0xb, 0x18(%r12)
jmp 0xdf7e
testb $0x40, %cl
je 0xdf7e
movq (%r12), %rsi
testb $0x3, 0x9(%rsi)
je 0xdf7e
movq %r14, %rdi
callq 0xc85c
movl $0x1, 0x4(%rsp)
addq $0x28, %r12
cmpq %r15, %r12
jb 0xdf0b
testl %r13d, %r13d
sete %cl
testl %ebp, %ebp
sete %dl
movl 0x4(%rsp), %eax
jmp 0xdf9a
movb $0x1, %cl
testb %cl, %cl
je 0xdfb2
testb %dl, %dl
je 0xdfc2
movq 0x88(%r14), %rcx
addq $0x88, %r14
jmp 0xdfd0
movq 0x98(%r14), %rcx
addq $0x98, %r14
jmp 0xdfd0
movq 0xa0(%r14), %rcx
addq $0xa0, %r14
movq %rcx, 0x30(%rbx)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe014
andl $0xf, %eax
movq (%rsi), %rsi
cmpl $0x4, %eax
jne 0xe00d
testq %rsi, %rsi
je 0xe014
testb $0x3, 0x9(%rsi)
je 0xe014
callq 0xc85c
jmp 0xe014
movzbl 0x9(%rsi), %ebx
andl $0x3, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1ddd1(%rip), %r14     # 0x2bfd0
leaq 0xc982(%rip), %rdx      # 0x1ab88
movq (%r14), %rsi
movq 0x18(%r14), %r15
movq %rbx, %rdi
movl $0x1, %ecx
callq 0xa1de
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7697
addq $0x10, %r14
movq %r15, %rdx
testq %r15, %r15
jne 0xe206
leaq 0x1282b(%rip), %rdx     # 0x20a65
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa162
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
popq %rbx
popq %r14
popq %r15
jmp 0x7697
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
xorl %edx, %edx
callq 0x9559
movq %rax, %r14
leaq 0x12c81(%rip), %rdx     # 0x212ab
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x9500
movq %rax, %r15
movl $0x10, %esi
movq %rbx, %rdi
callq 0x8a40
movq %rax, %r12
movq $0x0, 0x8(%rax)
leaq 0x12472(%rip), %rsi     # 0x20acd
movq %rbx, %rdi
callq 0x9363
xorl %edi, %edi
callq 0x63c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x64b0
movq %rax, (%r12)
leaq 0x852(%rip), %rcx       # 0xeed2
movq %rcx, 0x8(%r12)
testq %rax, %rax
je 0xe69b
movl $0x1, %eax
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 0x91d4
// File: /workspace/github_c_makefile_star2_O1/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 0x80bf
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7caf
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
jne 0xe83d
addq $0x4, %rbx
leaq 0x122c0(%rip), %rsi     # 0x20af0
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9024
movq (%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %esi
callq 0x8a40
movq %rax, %r12
xorl %r13d, %r13d
movq %r13, 0x8(%rax)
leaq 0x121e3(%rip), %rsi     # 0x20acd
movq %r14, %rdi
callq 0x9363
movq %r13, (%r12)
leaq 0x4f(%rip), %rax        # 0xe94c
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6340
movq %rax, (%r12)
testq %rax, %rax
je 0xe920
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x6080
movl (%rax), %edi
callq 0x6570
leaq 0x121d8(%rip), %rsi     # 0x20b0b
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9024
// File: /workspace/github_c_makefile_star2_O1/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 0x7683
movl %eax, %r14d
leal -0x1(%r14), %r15d
cmpl $0x13, %eax
jl 0xe9ae
leaq 0x12185(%rip), %rdx     # 0x20b26
movq %rbx, %rdi
movl $0x11, %esi
callq 0x8f3e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7869
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x7d87
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7fe1
cmpl $0x2, %r14d
jl 0xea00
movl %r14d, %r12d
negl %r12d
movl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7869
leal (%r12,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0xe9e2
addl $0x2, %r14d
leaq 0x13(%rip), %rsi        # 0xea1e
movq %rbx, %rdi
movl %r14d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7f5d
// File: /workspace/github_c_makefile_star2_O1/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 0x7caf
movq %rax, %r14
movq %rbx, %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
xorl %edx, %edx
callq 0x7b1d
cmpq $0x0, 0x8(%r14)
je 0xeab4
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7697
testl %r15d, %r15d
jle 0xea87
movl $0xfff0b9d4, %r12d      # imm = 0xFFF0B9D4
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7869
leal (%r15,%r12), %eax
decl %eax
movl %r12d, %ecx
decl %ecx
movl %ecx, %r12d
cmpl $0xfff0b9d4, %eax       # imm = 0xFFF0B9D4
jne 0xea67
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0xeb53
movl %eax, %ebp
movl %eax, %esi
negl %esi
movq %rbx, %rdi
callq 0x7889
testl %eax, %eax
je 0xeacd
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1207c(%rip), %rsi     # 0x20b37
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9024
cmpl $0x2, %ebp
jl 0xeaff
movl $0x1, %esi
subl %ebp, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7bdc
leaq 0x12437(%rip), %rsi     # 0x20f21
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9024
movq %rbx, %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x7bb6
xorl %ebp, %ebp
testl %eax, %eax
je 0xeaa9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7697
movq %rbx, %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x7869
leaq 0x11f9d(%rip), %rdx     # 0x20acd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x93f5
movq 0x8(%rax), %rcx
movq $0x0, 0x8(%rax)
movq %rbx, %rdi
callq *%rcx
jmp 0xeaa9
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x999b
movl %ebp, %r13d
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rdi
callq 0x97c0
movq %rax, %r12
movq %rax, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %rbx, %rdx
callq 0x62b0
testq %rax, %rax
je 0xee9a
movq %r12, %rdi
callq 0x6170
testq %rax, %rax
je 0xee91
cmpb $0xa, -0x1(%r12,%rax)
jne 0xee91
subq %r13, %rax
addq %rax, 0x18(%rsp)
movq %r15, %rdi
callq 0x98d0
movl $0x1, %ebp
jmp 0xeeb8
addq %rax, 0x18(%rsp)
movb $0x1, %al
jmp 0xeeba
movq %r15, %rdi
callq 0x98d0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7c4f
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
xorl %eax, %eax
testb %al, %al
jne 0xee40
movl %ebp, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7683
movl %eax, %r15d
movl $0x1, %eax
cmpl %ebp, %r15d
je 0xefbb
movl $0x1, %r12d
movq %rsp, %r13
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7889
cmpl $0x3, %eax
jne 0xef68
testl %r12d, %r12d
je 0xef9b
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7ad5
movq %r14, %rdi
leaq 0x11c3e(%rip), %rsi     # 0x20b94
movb $0x1, %al
callq 0x6320
xorl %r12d, %r12d
testl %eax, %eax
setg %r12b
jmp 0xef9e
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x9559
testl %r12d, %r12d
je 0xef9b
movq (%rsp), %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rcx
callq 0x6550
xorl %r12d, %r12d
cmpq (%rsp), %rax
sete %r12b
jmp 0xef9e
xorl %r12d, %r12d
incl %ebp
cmpl %ebp, %r15d
jne 0xef2c
movl $0x1, %eax
testl %r12d, %r12d
jne 0xefbb
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x91d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe7b8
movq %rax, %r14
leaq 0x11b79(%rip), %rdx     # 0x20bb4
leaq 0x1d19e(%rip), %rcx     # 0x2c1e0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x946f
movl %eax, %ebp
xorpd %xmm0, %xmm0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x969f
cvttsd2si %xmm0, %r15
cvtsi2sd %r15, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf074
jnp 0xf088
leaq 0x11b41(%rip), %rdx     # 0x20bbc
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8f3e
movslq %ebp, %rax
leaq 0x11b86(%rip), %rcx     # 0x20c18
movl (%rcx,%rax,4), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x6450
testl %eax, %eax
je 0xf0ba
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x91d4
movq %r14, %rdi
callq 0x6280
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x7d72
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
xorl %esi, %esi
movl $0x1b, %edx
callq 0x81c0
leaq 0x1cfad(%rip), %rsi     # 0x2c220
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa00f
movsd 0x119ab(%rip), %xmm0    # 0x20c30
movq %rbx, %rdi
callq 0x7d72
leaq 0x119dc(%rip), %rdx     # 0x20c70
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x833f
movsd 0x1198f(%rip), %xmm0    # 0x20c38
movq %rbx, %rdi
callq 0x7d72
leaq 0x119bb(%rip), %rdx     # 0x20c73
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x833f
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x9650
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x62c0
movq %rbx, %rdi
callq 0x7d72
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x7d87
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x9650
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x96d4
movsd 0x8(%rsp), %xmm0
movl %eax, %edi
callq 0x6090
movq %rbx, %rdi
callq 0x7d72
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x9650
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7889
testl %eax, %eax
jle 0xf581
movq %rbx, %rdi
movl $0x2, %esi
callq 0x9650
ucomisd 0x116d7(%rip), %xmm0    # 0x20c48
jne 0xf58d
jp 0xf58d
movsd (%rsp), %xmm0
callq 0x6310
jmp 0xf5ba
movsd (%rsp), %xmm0
callq 0x6220
jmp 0xf5ba
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x6220
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6220
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x7d72
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7683
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9650
movapd %xmm0, %xmm1
cmpl $0x2, %r14d
jge 0xf5fe
movapd %xmm1, %xmm0
jmp 0xf635
negl %r14d
movl $0x2, %r15d
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x9650
maxsd 0x8(%rsp), %xmm0
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movapd %xmm0, %xmm1
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0xf607
movq %rbx, %rdi
callq 0x7d72
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7683
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9650
movapd %xmm0, %xmm1
cmpl $0x2, %r14d
jge 0xf67d
movapd %xmm1, %xmm0
jmp 0xf6b4
negl %r14d
movl $0x2, %r15d
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x9650
minsd 0x8(%rsp), %xmm0
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movapd %xmm0, %xmm1
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0xf686
movq %rbx, %rdi
callq 0x7d72
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x9650
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x61c0
movsd %xmm0, 0x8(%rsp)
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x7d72
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x7d72
movl $0x2, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_pow
static int math_pow (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number y = luaL_checknumber(L, 2);
  lua_pushnumber(L, l_mathop(pow)(x, y));
  return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x9650
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x9650
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x6140
movq %rbx, %rdi
callq 0x7d72
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq