LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: luaK_nil
void luaK_nil (FuncState *fs, int from, int n) {
  Instruction *previous;
  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
    if (fs->pc == 0) {  /* function start? */
      if (from >= fs->nactvar)
        return;  /* positions are already clean */
    }
    else {
      previous = &fs->f->code[fs->pc-1];
      if (GET_OPCODE(*previous) == OP_LOADNIL) {
        int pfrom = GETARG_A(*previous);
        int pto = GETARG_B(*previous);
        if (pfrom <= from && from <= pto+1) {  /* can connect both? */
          if (from+n-1 > pto)
            SETARG_B(*previous, from+n-1);
          return;
        }
      }
    }
  }
  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
}

// Assembly:
movslq 0x30(%rdi), %rax
cmpl 0x34(%rdi), %eax
jle 0x63aa1
testl %eax, %eax
je 0x63a99
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movl -0x4(%rcx,%rax,4), %r8d
movl %r8d, %r9d
andl $0x3f, %r9d
cmpl $0x3, %r9d
jne 0x63aa1
movl %r8d, %r9d
shrl $0x6, %r9d
movzbl %r9b, %r10d
movl %r8d, %r9d
shrl $0x17, %r9d
cmpl %esi, %r10d
setg %r10b
leal 0x1(%r9), %r11d
cmpl %esi, %r11d
setl %r11b
orb %r10b, %r11b
jne 0x63aa1
addl %esi, %edx
decl %edx
cmpl %r9d, %edx
jle 0x63ac4
andl $0x7fffc3, %r8d         # imm = 0x7FFFC3
shll $0x17, %edx
orl %r8d, %edx
movl %edx, -0x4(%rcx,%rax,4)
jmp 0x63ac4
movzbl 0x4a(%rdi), %eax
cmpl %esi, %eax
jle 0x63ac4
addl %esi, %edx
shll $0x6, %esi
shll $0x17, %edx
addl $0xff800000, %edx       # imm = 0xFF800000
orl %esi, %edx
orl $0x3, %edx
movq 0x18(%rdi), %rax
movl 0x8(%rax), %eax
movl %edx, %esi
movl %eax, %edx
jmp 0x63675
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: luaK_exp2RK
int luaK_exp2RK (FuncState *fs, expdesc *e) {
  luaK_exp2val(fs, e);
  switch (e->k) {
    case VKNUM:
    case VTRUE:
    case VFALSE:
    case VNIL: {
      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
                                        boolK(fs, (e->k == VTRUE));
        e->k = VK;
        return RKASK(e->u.s.info);
      }
      else break;
    }
    case VK: {
      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
        return RKASK(e->u.s.info);
      else break;
    }
    default: break;
  }
  /* not a constant in the right range: put it in a register */
  return luaK_exp2anyreg(fs, e);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x63db6
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0x63d14
cmpl $0x4, %eax
je 0x63d4c
cmpl $0x5, %eax
jne 0x63d56
cmpl $0xff, 0x40(%r14)
jg 0x63d56
cmpl $0x5, %eax
je 0x63d68
cmpl $0x1, %eax
jne 0x63d7f
leaq 0x18(%rsp), %rdx
movl $0x0, 0x8(%rdx)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
movq %r14, %rdi
jmp 0x63d9b
movl 0x8(%rbx), %eax
cmpl $0xff, %eax
jle 0x63da9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x631f7
movsd 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
jmp 0x63d95
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x63ac5
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
orl $0x100, %eax            # imm = 0x100
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: invertjump
static void invertjump (FuncState *fs, expdesc *e) {
  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
                                           GET_OPCODE(*pc) != OP_TEST);
  SETARG_A(*pc, !(GETARG_A(*pc)));
}

// Assembly:
movslq 0x8(%rsi), %rcx
movq (%rdi), %rdx
leaq (,%rcx,4), %rax
addq 0x18(%rdx), %rax
testq %rcx, %rcx
jle 0x63df6
movl -0x4(%rax), %ecx
movabsq $0x3df07fffff, %rdx     # imm = 0x3DF07FFFFF
btq %rcx, %rdx
jb 0x63df6
addq $-0x4, %rax
movl (%rax), %ecx
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: listfield
static void listfield (LexState *ls, struct ConsControl *cc) {
  expr(ls, &cc->v);
  luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
  cc->na++;
  cc->tostore++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x629ed
cmpl $0x7ffffffe, 0x24(%rbx) # imm = 0x7FFFFFFE
jge 0x646d8
movq 0x24(%rbx), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movq %xmm0, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x30(%r14), %rdi
leaq 0x89a68(%rip), %rdx     # 0xee14b
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0x64877
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: luaK_setlist
void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
  lua_assert(tostore != 0);
  if (c <= MAXARG_C)
    luaK_codeABC(fs, OP_SETLIST, base, b, c);
  else {
    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
  }
  fs->freereg = base + 1;  /* free registers with list values */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rdx), %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rsi
sarq $0x24, %rsi
shrq $0x3f, %rax
leal (%rsi,%rax), %ebp
incl %ebp
movl %ecx, %edi
shll $0x17, %edi
movl %ebx, %esi
shll $0x6, %esi
xorl %eax, %eax
cmpl $-0x1, %ecx
cmovnel %edi, %eax
cmpl $0x63ce, %edx           # imm = 0x63CE
jg 0x64847
shll $0xe, %ebp
orl %esi, %eax
orl %ebp, %eax
orl $0x22, %eax
movl %eax, %ebp
jmp 0x6485b
orl %eax, %esi
orl $0x22, %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x63675
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x63675
incl %ebx
movl %ebx, 0x3c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: errorlimit
static void errorlimit (FuncState *fs, int limit, const char *what) {
  const char *msg = (fs->f->linedefined == 0) ?
    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
                            fs->f->linedefined, limit, what);
  luaX_lexerror(fs->ls, msg, 0);
}

// Assembly:
pushq %rbx
movq %rdx, %r8
movl %esi, %ecx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rdi), %rdi
movl 0x60(%rax), %edx
testl %edx, %edx
jne 0x648a3
leaq 0x898cd(%rip), %rsi     # 0xee162
movl %ecx, %edx
movq %r8, %rcx
xorl %eax, %eax
callq 0x5d33c
jmp 0x648b1
leaq 0x898da(%rip), %rsi     # 0xee184
xorl %eax, %eax
callq 0x5d33c
movq 0x18(%rbx), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x62217
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: adjustlocalvars
static void adjustlocalvars (LexState *ls, int nvars) {
  FuncState *fs = ls->fs;
  fs->nactvar = cast_byte(fs->nactvar + nvars);
  for (; nvars; nvars--) {
    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
  }
}

// Assembly:
movq 0x30(%rdi), %rdi
movb 0x4a(%rdi), %r8b
addb %sil, %r8b
movb %r8b, 0x4a(%rdi)
testl %esi, %esi
je 0x64c2e
movl 0x30(%rdi), %eax
movq (%rdi), %rcx
movq 0x30(%rcx), %rcx
movslq %esi, %rdx
movzbl %r8b, %esi
leaq (%rdi,%rsi,2), %rsi
addq $0xc4, %rsi
negq %rdx
movzwl (%rsi,%rdx,2), %edi
shll $0x4, %edi
movl %eax, 0x8(%rcx,%rdi)
incq %rdx
jne 0x64c1e
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: field
static void field (LexState *ls, expdesc *v) {
  /* field -> ['.' | ':'] NAME */
  FuncState *fs = ls->fs;
  expdesc key;
  luaK_exp2anyreg(fs, v);
  luaX_next(ls);  /* skip the dot or colon */
  checkname(ls, &key);
  luaK_indexed(fs, v, &key);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x30(%rdi), %r14
movq %r14, %rdi
callq 0x631f7
movl 0x4(%r15), %eax
movl 0x20(%r15), %ecx
movl %eax, 0x8(%r15)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0x64c71
leaq 0x18(%r15), %rsi
movq %r15, %rdi
callq 0x617cb
movl %eax, 0x10(%r15)
jmp 0x64c85
leaq 0x20(%r15), %rax
leaq 0x10(%r15), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %r15, %rdi
callq 0x6492c
movq 0x30(%r15), %rdi
movq %rsp, %r15
movq %rax, (%r15)
movl $0x4, %ebp
movl %ebp, 0x8(%r15)
movq %r15, %rsi
movq %r15, %rdx
callq 0x63ac5
movq $-0x1, 0x10(%r15)
movl %ebp, (%r15)
movl %eax, 0x8(%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x63cee
movl %eax, 0xc(%rbx)
movl $0x9, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: singlevar
static void singlevar (LexState *ls, expdesc *var) {
  TString *varname = str_checkname(ls);
  FuncState *fs = ls->fs;
  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6492c
movq %rax, %r15
movq 0x30(%r14), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x64f0a
cmpl $0x8, %eax
jne 0x64f00
movq %rsp, %rdx
movq %r15, (%rdx)
movl $0x4, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x63ac5
movl %eax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: explist1
static int explist1 (LexState *ls, expdesc *v) {
  /* explist1 -> expr { `,' expr } */
  int n = 1;  /* at least one expression */
  expr(ls, v);
  while (testnext(ls, ',')) {
    luaK_exp2nextreg(ls->fs, v);
    expr(ls, v);
    n++;
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x629ed
movq %r14, %rdi
movl $0x2c, %esi
callq 0x62690
movl $0x1, %ebp
testl %eax, %eax
je 0x6513c
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x635d4
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x629ed
incl %ebp
movq %r14, %rdi
movl $0x2c, %esi
callq 0x62690
jmp 0x6510e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: leaveblock
static void leaveblock (FuncState *fs) {
  BlockCnt *bl = fs->bl;
  fs->bl = bl->previous;
  removevars(fs->ls, bl->nactvar);
  if (bl->upval)
    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
  /* a block either controls scope or breaks (never both) */
  lua_assert(!bl->isbreakable || !bl->upval);
  lua_assert(bl->nactvar == fs->nactvar);
  fs->freereg = fs->nactvar;  /* free registers */
  luaK_patchtohere(fs, bl->breaklist);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %r14
movq (%r14), %rcx
movq %rcx, 0x28(%rdi)
movzbl 0xc(%r14), %esi
movq 0x30(%rax), %rcx
movzbl 0x4a(%rcx), %edx
cmpb %sil, %dl
jbe 0x65352
movl 0x30(%rcx), %edi
movq (%rcx), %r8
movq 0x30(%r8), %r8
movl %esi, %r9d
movzwl 0xc2(%rcx,%rdx,2), %r10d
decq %rdx
shll $0x4, %r10d
movl %edi, 0xc(%r8,%r10)
cmpq %r9, %rdx
ja 0x65335
movb %dl, 0x4a(%rcx)
cmpb $0x0, 0xd(%r14)
je 0x6536a
shll $0x6, %esi
orl $0x23, %esi
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0x63675
movzbl 0x4a(%rbx), %eax
movl %eax, 0x3c(%rbx)
movl 0x8(%r14), %edx
movl 0x30(%rbx), %eax
movl %eax, 0x34(%rbx)
leaq 0x38(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x62868
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: forbody
static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
  /* forbody -> DO block */
  BlockCnt bl;
  FuncState *fs = ls->fs;
  int prep, endfor;
  adjustlocalvars(ls, 3);  /* control variables */
  checknext(ls, TK_DO);
  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
  enterblock(fs, &bl, 0);  /* scope for declared variables */
  adjustlocalvars(ls, nvars);
  luaK_reserveregs(fs, nvars);
  block(ls);
  leaveblock(fs);  /* end of scope for declared variables */
  luaK_patchtohere(fs, prep);
  endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
                     luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
  luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
  luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, 0x4(%rsp)
movl %esi, %r15d
movq %rdi, %r14
movq 0x30(%rdi), %rbx
movb 0x4a(%rbx), %dl
addb $0x3, %dl
movb %dl, 0x4a(%rbx)
movl 0x30(%rbx), %eax
movq (%rbx), %rcx
movq 0x30(%rcx), %rcx
movzbl %dl, %edx
leaq (%rbx,%rdx,2), %rdx
addq $0xbe, %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %edi
shll $0x4, %edi
movl %eax, 0x8(%rcx,%rdi)
incq %rsi
cmpq $0x3, %rsi
jne 0x65405
movq %r14, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x62931
testl %ebp, %ebp
je 0x65447
movl %r15d, %esi
shll $0x6, %esi
orl $0x7fff8020, %esi       # imm = 0x7FFF8020
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0x63675
jmp 0x6544f
movq %rbx, %rdi
callq 0x628ac
movl %eax, %r13d
leaq 0x8(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movb %cl, 0xe(%rax)
movb 0x4a(%rbx), %dl
movb %dl, 0xc(%rax)
movb %cl, 0xd(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x28(%rbx)
movq %r14, %rdi
movl %r12d, %esi
callq 0x64bec
movq %rbx, %rdi
movl %r12d, %esi
callq 0x63cbf
addl %r12d, 0x3c(%rbx)
movq %r14, %rdi
callq 0x626d8
movq %rbx, %rdi
callq 0x65300
movl 0x30(%rbx), %eax
movl %eax, 0x34(%rbx)
leaq 0x38(%rbx), %rsi
movq %rbx, %rdi
movl %r13d, %edx
callq 0x62868
shll $0x6, %r15d
shll $0xe, %r12d
orl %r15d, %r12d
orl $0x21, %r12d
orl $0x7fff801f, %r15d      # imm = 0x7FFF801F
testl %ebp, %ebp
cmovel %r12d, %r15d
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x63675
movq (%rbx), %rcx
movq 0x28(%rcx), %rcx
movslq 0x30(%rbx), %rdx
movl 0x4(%rsp), %esi
movl %esi, -0x4(%rcx,%rdx,4)
testl %ebp, %ebp
jne 0x65503
movq %rbx, %rdi
callq 0x628ac
incl %r13d
movq %rbx, %rdi
movl %eax, %esi
movl %r13d, %edx
callq 0x652d8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: luaK_storevar
void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
      exp2reg(fs, ex, var->u.s.info);
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
      break;
    }
    case VGLOBAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
      break;
    }
    case VINDEXED: {
      int e = luaK_exp2RK(fs, ex);
      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
      break;
    }
    default: {
      lua_assert(0);  /* invalid var kind to store */
      break;
    }
  }
  freeexp(fs, ex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x3, %eax
ja 0x65669
movq %rsi, %r15
leaq 0x87f87(%rip), %rcx     # 0xed54c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0xc, (%r14)
jne 0x655e9
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x655e9
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x655e9
decl 0x3c(%rbx)
movl 0x8(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x634a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x631f7
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x7, %esi
jmp 0x6565a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63cee
movl %eax, %esi
movl 0x8(%r15), %eax
movl 0xc(%r15), %ecx
shll $0x6, %eax
shll $0x17, %ecx
shll $0xe, %esi
orl %eax, %esi
orl %ecx, %esi
orl $0x9, %esi
jmp 0x6565a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x631f7
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
orl $0x8, %esi
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0x63675
cmpl $0xc, (%r14)
jne 0x65684
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x65684
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x65684
decl 0x3c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldump.c
// Function: DumpString
static void DumpString(const TString* s, DumpState* D)
{
 if (s==NULL) /* also see current code in Lua 5.4 */
 {
  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,D);
 }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x65c09
movq %rdi, %r14
movq 0x10(%rdi), %rax
incq %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x65bef
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
cmpl $0x0, 0x1c(%rbx)
jne 0x65c2c
movq (%rsp), %rdx
addq $0x18, %r14
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %r14, %rsi
jmp 0x65c26
movq $0x0, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x65c2c
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lgc.c
// Function: markroot
static void markroot (lua_State *L) {
  global_State *g = G(L);
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  markobject(g, g->mainthread);
  /* make global table be traversed before main stack */
  markvalue(g, gt(g->mainthread));
  markvalue(g, registry(L));
  markmt(g);
  g->gcstate = GCSpropagate;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x48(%rbx)
movq 0xb0(%rbx), %rsi
testb $0x3, 0x9(%rsi)
je 0x66049
movq %rbx, %rdi
callq 0x66a62
movq 0xb0(%rbx), %rax
cmpl $0x4, 0x80(%rax)
jl 0x6606b
movq 0x78(%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0x6606b
movq %rbx, %rdi
callq 0x66a62
movq 0x20(%r14), %rax
cmpl $0x4, 0xa8(%rax)
jl 0x6608d
movq 0xa0(%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0x6608d
movq %rbx, %rdi
callq 0x66a62
movq %rbx, %rdi
callq 0x66b1d
movb $0x1, 0x21(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lgc.c
// Function: GCTM
static void GCTM (lua_State *L) {
  global_State *g = G(L);
  GCObject *o = g->tmudata->gch.next;  /* get first element */
  Udata *udata = rawgco2u(o);
  const TValue *tm;
  /* remove udata from `tmudata' */
  if (o == g->tmudata)  /* last element? */
    g->tmudata = NULL;
  else
    g->tmudata->gch.next = udata->uv.next;
  udata->uv.next = g->mainthread->next;  /* return it to `root' list */
  g->mainthread->next = o;
  makewhite(g, o);
  tm = fasttm(L, udata->uv.metatable, TM_GC);
  if (tm != NULL) {
    lu_byte oldah = L->allowhook;
    lu_mem oldt = g->GCthreshold;
    L->allowhook = 0;  /* stop debug hooks during GC tag method */
    g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
    setobj2s(L, L->top, tm);
    setuvalue(L, L->top+1, udata);
    L->top += 2;
    luaD_call(L, L->top - 2, 0);
    L->allowhook = oldah;  /* restore hooks */
    g->GCthreshold = oldt;  /* restore threshold */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x50(%r14), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x669a6
movq (%r15), %rcx
movq %rcx, (%rax)
jmp 0x669ae
movq $0x0, 0x50(%r14)
movq 0xb0(%r14), %rax
movq (%rax), %rax
movq %rax, (%r15)
movq 0xb0(%r14), %rax
movq %r15, (%rax)
movb 0x9(%r15), %al
andb $-0x8, %al
movb 0x20(%r14), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r15)
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x669fe
testb $0x4, 0xa(%rdi)
jne 0x669fe
movq 0x20(%rbx), %rax
movq 0x138(%rax), %rdx
movl $0x2, %esi
callq 0x66b52
jmp 0x66a00
xorl %eax, %eax
testq %rax, %rax
je 0x66a59
movb 0x65(%rbx), %bpl
movq 0x70(%r14), %r12
movb $0x0, 0x65(%rbx)
movq 0x78(%r14), %rcx
addq %rcx, %rcx
movq %rcx, 0x70(%r14)
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq %r15, 0x10(%rax)
movl $0x7, 0x18(%rax)
movq 0x10(%rbx), %rsi
leaq 0x20(%rsi), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x594c2
movb %bpl, 0x65(%rbx)
movq %r12, 0x70(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lgc.c
// Function: reallymarkobject
static void reallymarkobject (global_State *g, GCObject *o) {
  lua_assert(iswhite(o) && !isdead(g, o));
  white2gray(o);
  switch (o->gch.tt) {
    case LUA_TSTRING: {
      return;
    }
    case LUA_TUSERDATA: {
      Table *mt = gco2u(o)->metatable;
      gray2black(o);  /* udata are never gray */
      if (mt) markobject(g, mt);
      markobject(g, gco2u(o)->env);
      return;
    }
    case LUA_TUPVAL: {
      UpVal *uv = gco2uv(o);
      markvalue(g, uv->v);
      if (uv->v == &uv->u.value)  /* closed? */
        gray2black(o);  /* open upvalues are never black */
      return;
    }
    case LUA_TFUNCTION: {
      gco2cl(o)->c.gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TTABLE: {
      gco2h(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TTHREAD: {
      gco2th(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TPROTO: {
      gco2p(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    default: lua_assert(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x9(%rbx), %al
andb $-0x4, %al
movb %al, 0x9(%rbx)
movzbl 0x8(%rbx), %ecx
cmpl $0x7, %ecx
jne 0x66aa5
movq 0x10(%rbx), %rsi
orb $0x4, %al
movb %al, 0x9(%rbx)
testq %rsi, %rsi
je 0x66a99
testb $0x3, 0x9(%rsi)
je 0x66a99
movq %r14, %rdi
callq 0x66a62
movq 0x18(%rbx), %rbx
testb $0x3, 0x9(%rbx)
jne 0x66a6c
jmp 0x66aea
addl $-0x5, %ecx
cmpl $0x5, %ecx
ja 0x66aea
leaq 0x86aec(%rip), %rax     # 0xed5a0
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x38(%r14), %rax
movq %rax, 0x30(%rbx)
jmp 0x66ae6
movq 0x38(%r14), %rax
movq %rax, 0x68(%rbx)
jmp 0x66ae6
movq 0x38(%r14), %rax
movq %rax, 0xa0(%rbx)
jmp 0x66ae6
movq 0x38(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rbx, 0x38(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%rbx), %rax
cmpl $0x4, 0x8(%rax)
jl 0x66b0d
movq (%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0x66b0d
movq %r14, %rdi
callq 0x66a62
leaq 0x18(%rbx), %rax
cmpq %rax, 0x10(%rbx)
jne 0x66aea
orb $0x4, 0x9(%rbx)
jmp 0x66aea
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltable.c
// Function: luaT_gettm
const TValue *luaH_getstr (Table *t, TString *key) {
  Node *n = hashstr(t, key);
  do {  /* check whether `key' is somewhere in the chain */
    if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
      return gval(n);  /* that's it */
    else n = gnext(n);
  } while (n);
  return luaO_nilobject;
}

// Assembly:
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rdx), %eax
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x20(%rdi), %rax
leaq 0x86b9c(%rip), %rcx     # 0xed710
cmpl $0x4, 0x18(%rax)
jne 0x66b80
cmpq %rdx, 0x10(%rax)
je 0x66b8c
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x66b74
movq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x66b93
retq
movl $0x1, %eax
movl %esi, %ecx
shll %cl, %eax
orb %al, 0xa(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lgc.c
// Function: iscleared
static int iscleared (const TValue *o, int iskey) {
  if (!iscollectable(o)) return 0;
  if (ttisstring(o)) {
    stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
    return 0;
  }
  return iswhite(gcvalue(o)) ||
    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
}

// Assembly:
movl 0x8(%rdi), %edx
xorl %eax, %eax
cmpl $0x4, %edx
jl 0x66bc6
movq (%rdi), %rdi
movzbl 0x9(%rdi), %ecx
jne 0x66bbc
andb $-0x4, %cl
movb %cl, 0x9(%rdi)
retq
movl $0x1, %eax
testb $0x3, %cl
je 0x66bc7
retq
xorl $0x7, %edx
orl %edx, %esi
movl $0x0, %eax
jne 0x66bc6
shrl $0x3, %ecx
andl $0x1, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstring.c
// Function: luaS_resize
void luaS_resize (lua_State *L, int newsize) {
  GCObject **newhash;
  stringtable *tb;
  int i;
  if (G(L)->gcstate == GCSsweepstring)
    return;  /* cannot resize during GC traverse */
  newhash = luaM_newvector(L, newsize, GCObject *);
  tb = &G(L)->strt;
  for (i=0; i<newsize; i++) newhash[i] = NULL;
  /* rehash */
  for (i=0; i<tb->size; i++) {
    GCObject *p = tb->hash[i];
    while (p) {  /* for each node in the list */
      GCObject *next = p->gch.next;  /* save next */
      unsigned int h = gco2ts(p)->hash;
      int h1 = lmod(h, newsize);  /* new position */
      lua_assert(cast_int(h%newsize) == lmod(h, newsize));
      p->gch.next = newhash[h1];  /* chain it */
      newhash[h1] = p;
      p = next;
    }
  }
  luaM_freearray(L, tb->hash, tb->size, TString *);
  tb->size = newsize;
  tb->hash = newhash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x20(%rdi), %rax
cmpb $0x2, 0x21(%rax)
je 0x66d3d
movl %esi, %ebx
movq %rdi, %r14
cmpl $-0x1, %esi
jl 0x66d47
movslq %ebx, %r12
leaq (,%r12,8), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5d2f2
movq %rax, %r15
movq 0x20(%r14), %r13
testl %ebx, %ebx
jle 0x66cd2
movl %ebx, %edx
shlq $0x3, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0xb2f0
movl 0xc(%r13), %ecx
testl %ecx, %ecx
jle 0x66d15
decq %r12
xorl %eax, %eax
movq (%r13), %rcx
movq (%rcx,%rax,8), %rcx
testq %rcx, %rcx
je 0x66d09
movq (%rcx), %rdx
movslq 0xc(%rcx), %rsi
andq %r12, %rsi
movq (%r15,%rsi,8), %rdi
movq %rdi, (%rcx)
movq %rcx, (%r15,%rsi,8)
movq %rdx, %rcx
testq %rdx, %rdx
jne 0x66cec
incq %rax
movslq 0xc(%r13), %rcx
cmpq %rcx, %rax
jl 0x66cdf
movq (%r13), %rsi
movslq %ecx, %r12
shlq $0x3, %r12
movq 0x20(%r14), %r14
movq 0x18(%r14), %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq *0x10(%r14)
subq %r12, 0x78(%r14)
movl %ebx, 0xc(%r13)
movq %r15, (%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x87080(%rip), %rsi     # 0xeddce
movq %r14, %rdi
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lstate.c
// Function: stack_init
static void stack_init (lua_State *L1, lua_State *L) {
  /* initialize CallInfo array */
  L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
  L1->ci = L1->base_ci;
  L1->size_ci = BASIC_CI_SIZE;
  L1->end_ci = L1->base_ci + L1->size_ci - 1;
  /* initialize stack array */
  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
  L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
  L1->top = L1->stack;
  L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
  /* initialize first ci */
  L1->ci->func = L1->top;
  setnilvalue(L1->top++);  /* `function' entry for this `ci' */
  L1->base = L1->ci->base = L1->top;
  L1->ci->top = L1->top + LUA_MINSTACK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x140, %ecx            # imm = 0x140
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5d2f2
movq %rax, 0x50(%rbx)
movq %rax, 0x28(%rbx)
movl $0x8, 0x5c(%rbx)
addq $0x118, %rax            # imm = 0x118
movq %rax, 0x48(%rbx)
movl $0x2d0, %ecx            # imm = 0x2D0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5d2f2
movq %rax, 0x40(%rbx)
movl $0x2d, 0x58(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x270(%rax), %rcx
movq %rcx, 0x38(%rbx)
movq 0x28(%rbx), %rcx
movq %rax, 0x8(%rcx)
leaq 0x10(%rax), %rdx
movq %rdx, 0x10(%rbx)
movl $0x0, 0x8(%rax)
movq %rdx, (%rcx)
movq %rdx, 0x18(%rbx)
addq $0x150, %rax            # imm = 0x150
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lvm.c
// Function: get_compTM
static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
                                  TMS event) {
  const TValue *tm1 = fasttm(L, mt1, event);
  const TValue *tm2;
  if (tm1 == NULL) return NULL;  /* no metamethod */
  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
  tm2 = fasttm(L, mt2, event);
  if (tm2 == NULL) return NULL;  /* no metamethod */
  if (luaO_rawequalObj(tm1, tm2))  /* same metamethods? */
    return tm1;
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rsi, %rsi
je 0x66e78
testb $0x10, 0xa(%r12)
jne 0x66e78
movq 0x20(%r15), %rax
movq 0x148(%rax), %rdx
movq %r12, %rdi
movl $0x4, %esi
callq 0x66b52
movq %rax, %rbx
jmp 0x66e7a
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x66ec6
cmpq %r14, %r12
je 0x66ec8
testq %r14, %r14
je 0x66ead
testb $0x10, 0xa(%r14)
jne 0x66ead
movq 0x20(%r15), %rax
movq 0x148(%rax), %rdx
movq %r14, %rdi
movl $0x4, %esi
callq 0x66b52
movq %rax, %rsi
jmp 0x66eaf
xorl %esi, %esi
testq %rsi, %rsi
je 0x66ec6
movq %rbx, %rdi
callq 0x57db4
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rcx, %rbx
jmp 0x66ec8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_ipairs
static int luaB_ipairs (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
  lua_pushvalue(L, 1);  /* state, */
  lua_pushinteger(L, 0);  /* and initial value */
  return 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
cmpb $0x0, 0xb(%rcx)
leaq 0x28(%rcx), %rcx
leaq 0x867cb(%rip), %rdx     # 0xed710
cmoveq %rdx, %rcx
movq (%rcx), %rsi
movq %rsi, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
leaq 0x10(%rax), %rsi
movq %rsi, 0x10(%rbx)
cmpq %rsi, %rcx
cmovbq %rcx, %rdx
movq (%rdx), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%rdx), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq $0x0, 0x10(%rax)
movl $0x3, 0x18(%rax)
addq $0x10, 0x10(%rbx)
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_pairs
static int luaB_pairs (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
  lua_pushvalue(L, 1);  /* state, */
  lua_pushnil(L);  /* and initial value */
  return 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5b30c
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
leaq 0x28(%rcx), %rdx
cmpb $0x0, 0xb(%rcx)
leaq 0x866c3(%rip), %rcx     # 0xed710
cmoveq %rcx, %rdx
movq (%rdx), %rsi
movq %rsi, (%rax)
movl 0x8(%rdx), %edx
movl %edx, 0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
leaq 0x10(%rax), %rsi
cmpq %rsi, %rdx
cmovbq %rdx, %rcx
movq %rsi, 0x10(%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movl $0x0, 0x18(%rax)
addq $0x20, %rax
movq %rax, 0x10(%rbx)
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_newproxy
static int luaB_newproxy (lua_State *L) {
  lua_settop(L, 1);
  lua_newuserdata(L, 0);  /* create proxy */
  if (lua_toboolean(L, 1) == 0)
    return 1;  /* no metatable */
  else if (lua_isboolean(L, 1)) {
    lua_newtable(L);  /* create a new metatable `m' ... */
    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
    lua_pushboolean(L, 1);
    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
  }
  else {
    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
    if (lua_getmetatable(L, 1)) {
      lua_rawget(L, lua_upvalueindex(1));
      validproxy = lua_toboolean(L, -1);
      lua_pop(L, 1);  /* remove value */
    }
    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
    lua_getmetatable(L, 1);  /* metatable is valid; get it */
  }
  lua_setmetatable(L, 2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rcx
leaq 0x10(%rcx), %rax
cmpq %rax, %rdx
jae 0x67140
movq %rdx, %rsi
movl $0x0, 0x8(%rdx)
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x67129
movq %rdx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x59e95
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jb 0x6715f
leaq 0x865b1(%rip), %rax     # 0xed710
movl 0x8(%rax), %ecx
testl %ecx, %ecx
je 0x67257
cmpl $0x1, %ecx
jne 0x671c8
cmpl $0x0, (%rax)
je 0x67257
cmpl $0x1, %ecx
jne 0x671c8
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq 0x10(%rbx), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl %ecx, 0x18(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x59193
jmp 0x6724a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58e77
testl %eax, %eax
je 0x67268
movq 0x10(%rbx), %r14
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0xb(%rax)
jne 0x671fb
leaq 0x86517(%rip), %rax     # 0xed710
jmp 0x671ff
addq $0x28, %rax
movq (%rax), %rdi
leaq -0x10(%r14), %rsi
callq 0x58c18
movq (%rax), %rcx
movq %rcx, -0x10(%r14)
movl 0x8(%rax), %eax
movl %eax, -0x8(%r14)
movq 0x10(%rbx), %rcx
movl -0x8(%rcx), %edx
leaq -0x10(%rcx), %rax
cmpl $0x1, %edx
je 0x67233
testl %edx, %edx
je 0x67264
movq %rax, 0x10(%rbx)
jmp 0x6723d
cmpl $0x0, -0x10(%rcx)
movq %rax, 0x10(%rbx)
je 0x67268
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58e77
movq %rbx, %rdi
movl $0x2, %esi
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, 0x10(%rbx)
leaq 0x8746d(%rip), %rdx     # 0xee6dc
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_assert
static int luaB_assert (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_toboolean(L, 1))
    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
  return lua_gettop(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5b35e
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, %rdx
cmpq %rax, %rcx
jb 0x672a1
leaq 0x8646f(%rip), %rdx     # 0xed710
movl 0x8(%rdx), %esi
cmpl $0x1, %esi
je 0x672b6
testl %esi, %esi
je 0x672bb
subq %rcx, %rax
shrq $0x4, %rax
popq %rbx
retq
cmpl $0x0, (%rdx)
jne 0x672ad
leaq 0x87246(%rip), %rdx     # 0xee508
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x5b14f
leaq 0x87871(%rip), %rsi     # 0xeeb49
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_collectgarbage
static int luaB_collectgarbage (lua_State *L) {
  static const char *const opts[] = {"stop", "restart", "collect",
    "count", "step", "setpause", "setstepmul", NULL};
  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
  int o = luaL_checkoption(L, 1, "collect", opts);
  int ex = luaL_optint(L, 2, 0);
  int res = lua_gc(L, optsnum[o], ex);
  switch (optsnum[o]) {
    case LUA_GCCOUNT: {
      int b = lua_gc(L, LUA_GCCOUNTB, 0);
      lua_pushnumber(L, res + ((lua_Number)b/1024));
      return 1;
    }
    case LUA_GCSTEP: {
      lua_pushboolean(L, res);
      return 1;
    }
    default: {
      lua_pushnumber(L, res);
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8722f(%rip), %rdx     # 0xee522
leaq 0xe82e6(%rip), %rcx     # 0x14f5e0
movl $0x1, %r14d
movl $0x1, %esi
callq 0x5b0d4
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b45e
movslq %ebp, %rcx
leaq 0x8656b(%rip), %rdx     # 0xed890
movl (%rdx,%rcx,4), %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x59855
cmpl $0x5, %ebp
je 0x6736c
cmpl $0x3, %ebp
jne 0x6737f
movq 0x10(%rbx), %rcx
movq 0x20(%rbx), %rdx
movl $0x3ff, %esi            # imm = 0x3FF
andl 0x78(%rdx), %esi
cvtsi2sd %eax, %xmm0
cvtsi2sd %esi, %xmm1
mulsd 0x86622(%rip), %xmm1    # 0xed980
addsd %xmm0, %xmm1
addq $0x10, %rbx
movsd %xmm1, (%rcx)
jmp 0x6738f
movq 0x10(%rbx), %rcx
addq $0x10, %rbx
xorl %edx, %edx
testl %eax, %eax
setne %dl
movl %edx, (%rcx)
jmp 0x67395
cvtsi2sd %eax, %xmm0
movq 0x10(%rbx), %rcx
addq $0x10, %rbx
movsd %xmm0, (%rcx)
movl $0x3, %r14d
movl %r14d, 0x8(%rcx)
addq $0x10, (%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_dofile
static int luaB_dofile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  int n = lua_gettop(L);
  if (luaL_loadfile(L, fname) != 0) lua_error(L);
  lua_call(L, 0, LUA_MULTRET);
  return lua_gettop(L) - n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5b14f
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5bcaf
testl %eax, %eax
jne 0x67413
movq 0x10(%rbx), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x594c2
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x673fb
movq %rax, 0x10(%rcx)
subq %r15, %r14
subq 0x18(%rbx), %rax
shrq $0x4, %r14
shrq $0x4, %rax
subl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x599a2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lapi.c
// Function: luaB_gcinfo
LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
  lua_lock(L);
  setnvalue(L->top, cast_num(n));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x78(%rcx), %rcx
shrq $0xa, %rcx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_getfenv
static int luaB_getfenv (lua_State *L) {
  getfunc(L, 1);
  if (lua_iscfunction(L, -1))  /* is a C function? */
    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
  else
    lua_getfenv(L, -1);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x68083
movq 0x10(%rbx), %rax
cmpl $0x6, -0x8(%rax)
jne 0x67526
movq -0x10(%rax), %rcx
cmpb $0x0, 0xa(%rcx)
je 0x67526
movq 0x78(%rbx), %rcx
movq %rcx, (%rax)
movl 0x80(%rbx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
jmp 0x67533
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58ecc
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_load
static int luaB_load (lua_State *L) {
  int status;
  const char *cname = luaL_optstring(L, 2, "=(load)");
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
  status = lua_load(L, generic_reader, NULL, cname);
  return load_aux(L, status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x86fbd(%rip), %rdx     # 0xee5aa
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x5b14f
movq %rax, %r14
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x5b30c
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
addq $0x30, %rax
cmpq %rax, %rcx
jae 0x67638
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x67624
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
leaq 0xb22(%rip), %rsi       # 0x68165
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x59744
testl %eax, %eax
je 0x67679
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57a06
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_loadstring
static int luaB_loadstring (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  const char *chunkname = luaL_optstring(L, 2, s);
  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %ebp
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b1b3
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x5b14f
movq (%r14), %rcx
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movq %rcx, 0x8(%rdx)
leaq -0xb73b(%rip), %rsi     # 0x5bf92
movq %rbx, %rdi
movq %rax, %rcx
callq 0x59744
testl %eax, %eax
je 0x67701
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57a06
movl $0x2, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_pcall
static int luaB_pcall (lua_State *L) {
  int status;
  luaL_checkany(L, 1);
  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
  lua_pushboolean(L, (status == 0));
  lua_insert(L, 1);
  return lua_gettop(L);  /* return status + all results */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5b35e
movq 0x10(%rbx), %rsi
subq 0x18(%rbx), %rsi
shrq $0x4, %rsi
decl %esi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x59536
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq 0x10(%rbx), %rax
movl %ecx, (%rax)
movl $0x1, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57a06
movq 0x10(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x4, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_print
static int luaB_print (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    lua_pushvalue(L, -1);  /* function to be called */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tostring(L, -1);  /* get result */
    if (s == NULL)
      return luaL_error(L, LUA_QL("tostring") " must return a string to "
                           LUA_QL("print"));
    if (i>1) fputs("\t", stdout);
    fputs(s, stdout);
    lua_pop(L, 1);  /* pop result */
  }
  fputs("\n", stdout);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r13
subq 0x18(%rdi), %r13
shrq $0x4, %r13
leaq 0x86f23(%rip), %rdx     # 0xee6b1
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x58b98
testl %r13d, %r13d
jle 0x6785c
negl %r13d
movl $0x1, %r14d
movq 0xe97a7(%rip), %rbp     # 0x150f58
leaq 0x87115(%rip), %r15     # 0xee8cd
movq 0x10(%rbx), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x57945
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x10, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x594c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x58042
testq %rax, %rax
je 0x67883
movq %rax, %r12
cmpl $0x2, %r14d
jb 0x6782f
movq (%rbp), %rsi
movq %r15, %rdi
callq 0xb730
movq (%rbp), %rsi
movq %r12, %rdi
callq 0xb730
addq $-0x10, 0x10(%rbx)
testq %r12, %r12
je 0x67872
leal (%r14,%r13), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x677b8
movq 0xe96f5(%rip), %rax     # 0x150f58
movq (%rax), %rsi
leaq 0x9003c(%rip), %rdi     # 0xf78a9
callq 0xb730
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x86d67(%rip), %rsi     # 0xee5f1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: luaB_setfenv
static int luaB_setfenv (lua_State *L) {
  luaL_checktype(L, 2, LUA_TTABLE);
  getfunc(L, 0);
  lua_pushvalue(L, 2);
  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
    /* change environment of current thread */
    lua_pushthread(L);
    lua_insert(L, -2);
    lua_setfenv(L, -2);
    return 0;
  }
  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
    luaL_error(L,
          LUA_QL("setfenv") " cannot change environment of given object");
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
movl $0x5, %edx
callq 0x5b30c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x68083
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x67aa5
leaq 0x85c6b(%rip), %rcx     # 0xed710
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57cb2
testl %eax, %eax
je 0x67b11
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57fbe
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x67b11
jp 0x67b11
movq 0x10(%rbx), %rax
movq %rbx, (%rax)
movl $0x8, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x57a06
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x593ec
xorl %eax, %eax
jmp 0x67b3d
movq 0x10(%rbx), %rax
cmpl $0x6, -0x18(%rax)
jne 0x67b25
movq -0x20(%rax), %rax
cmpb $0x0, 0xa(%rax)
jne 0x67b3f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x593ec
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x67b3f
popq %rbx
retq
leaq 0x86ae9(%rip), %rsi     # 0xee62f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5af61