LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltm.c
// Function: luaT_gettmbyobj
const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
  Table *mt;
  switch (ttype(o)) {
    case LUA_TTABLE:
      mt = hvalue(o)->metatable;
      break;
    case LUA_TUSERDATA:
      mt = uvalue(o)->metatable;
      break;
    default:
      mt = G(L)->mt[ttype(o)];
  }
  return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
}

// Assembly:
movslq 0x8(%rsi), %rax
cmpq $0x7, %rax
je 0x5f01f
cmpl $0x5, %eax
jne 0x5f028
movq (%rsi), %rax
addq $0x10, %rax
jmp 0x5f036
movq 0x20(%rdi), %rcx
leaq (%rcx,%rax,8), %rax
addq $0xe0, %rax
movq (%rax), %rsi
leaq 0x8e6d0(%rip), %rax     # 0xed710
testq %rsi, %rsi
je 0x5f087
movq 0x20(%rdi), %rdi
movl %edx, %edx
movb 0xb(%rsi), %cl
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
shll %cl, %r8d
movq 0x128(%rdi,%rdx,8), %rcx
notl %r8d
andl 0xc(%rcx), %r8d
leaq (%r8,%r8,4), %rdx
shlq $0x3, %rdx
addq 0x20(%rsi), %rdx
cmpl $0x4, 0x18(%rdx)
jne 0x5f07e
cmpq %rcx, 0x10(%rdx)
je 0x5f088
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
jne 0x5f072
retq
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldebug.c
// Function: luaG_typeerror
void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
  const char *name = NULL;
  const char *t = luaT_typenames[ttype(o)];
  const char *kind = (isinstack(L->ci, o)) ?
                         getobjname(L, L->ci, cast_int(o - L->base), &name) :
                         NULL;
  if (kind)
    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
                op, kind, name, t);
  else
    luaG_runerror(L, "attempt to %s a %s value", op, t);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
movslq 0x8(%rsi), %rax
leaq 0xefb3e(%rip), %rcx     # 0x14ebf0
movq (%rcx,%rax,8), %r14
movq 0x28(%rdi), %rsi
movq (%rsi), %rax
movq 0x10(%rsi), %rdi
xorl %ecx, %ecx
cmpq %rdi, %rax
jae 0x5f0eb
cmpq %rdx, %rax
je 0x5f0d3
addq $0x10, %rax
jmp 0x5f0c3
subq 0x18(%r15), %rdx
shrq $0x4, %rdx
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
callq 0x5c99e
movq %rax, %rcx
testq %rcx, %rcx
jne 0x5f107
leaq 0x8ed2b(%rip), %rsi     # 0xede22
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x57b1c
movq 0x8(%rsp), %r8
leaq 0x8ecec(%rip), %rsi     # 0xeddff
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %r9
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltable.c
// Function: luaH_setstr
TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {
  const TValue *p = luaH_getstr(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    TValue k;
    setsvalue(L, &k, key);
    return newkey(L, t, &k);
  }
}

// Assembly:
subq $0x18, %rsp
movb 0xb(%rsi), %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(%rsi), %rax
leaq 0x8e5c7(%rip), %rcx     # 0xed710
cmpl $0x4, 0x18(%rax)
jne 0x5f155
cmpq %rdx, 0x10(%rax)
je 0x5f161
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x5f149
movq %rcx, %rax
cmpq 0xf1e68(%rip), %rax     # 0x150fd0
jne 0x5f181
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movl $0x4, 0x8(%rax)
movq %rax, %rdx
callq 0x5f186
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltable.c
// Function: mainposition
static Node *mainposition (const Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TNUMBER:
      return hashnum(t, nvalue(key));
    case LUA_TSTRING:
      return hashstr(t, rawtsvalue(key));
    case LUA_TBOOLEAN:
      return hashboolean(t, bvalue(key));
    case LUA_TLIGHTUSERDATA:
      return hashpointer(t, pvalue(key));
    default:
      return hashpointer(t, gcvalue(key));
  }
}

// Assembly:
movl 0x8(%rsi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x5f47e
leaq 0x8dea3(%rip), %rcx     # 0xed308
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl (%rsi), %eax
jmp 0x5f4c5
movb 0xb(%rdi), %cl
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
shll %cl, %r8d
movl (%rsi), %eax
notl %r8d
orl $0x1, %r8d
xorl %edx, %edx
divl %r8d
leaq (%rdx,%rdx,4), %rax
jmp 0x5f4c9
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5f4d2
jp 0x5f4d2
movq 0x20(%rdi), %rax
retq
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
movq (%rsi), %rcx
notl %eax
andl 0xc(%rcx), %eax
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x20(%rdi), %rax
retq
movq %xmm0, %rdx
movq %rdx, %rax
movb 0xb(%rdi), %cl
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shll %cl, %esi
shrq $0x20, %rax
addl %edx, %eax
notl %esi
orl $0x1, %esi
xorl %edx, %edx
divl %esi
jmp 0x5f498
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltable.c
// Function: countint
static int arrayindex (const TValue *key) {
  if (ttisnumber(key)) {
    lua_Number n = nvalue(key);
    int k;
    lua_number2int(k, n);
    if (luai_numeq(cast_num(k), n))
      return k;
  }
  return -1;  /* `key' did not match some condition */
}

// Assembly:
cmpl $0x3, 0x8(%rdi)
jne 0x5f50f
movsd (%rdi), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5f50f
jnp 0x5f55f
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
decl %ecx
xorl %eax, %eax
cmpl $0x3ffffff, %ecx        # imm = 0x3FFFFFF
ja 0x5f55e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x100, %ecx            # imm = 0x100
jb 0x5f541
movl %ecx, %edx
addl $0x8, %eax
shrl $0x8, %edx
cmpl $0xffff, %ecx           # imm = 0xFFFF
movl %edx, %ecx
ja 0x5f52f
jmp 0x5f543
movl %ecx, %edx
movl %edx, %ecx
leaq 0x8e224(%rip), %rdx     # 0xed770
movzbl (%rcx,%rdx), %ecx
cltq
addq %rcx, %rax
incl 0x4(%rsi,%rax,4)
movl $0x1, %eax
retq
cvttsd2si %xmm0, %ecx
jmp 0x5f514
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltable.c
// Function: setarrayvector
static void setarrayvector (lua_State *L, Table *t, int size) {
  int i;
  luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
  for (i=t->sizearray; i<size; i++)
     setnilvalue(&t->array[i]);
  t->sizearray = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $-0x1, %edx
jl 0x5f84b
movl %edx, %ebx
movq %rsi, %r14
movq 0x18(%rsi), %rsi
movslq 0x38(%r14), %rdx
shlq $0x4, %rdx
movslq %ebx, %r15
movq %r15, %rcx
shlq $0x4, %rcx
callq 0x5d2f2
movq %rax, 0x18(%r14)
movslq 0x38(%r14), %rdx
cmpl %ebx, %edx
jge 0x5f841
subq %rdx, %r15
leaq 0x3(%r15), %rcx
andq $-0x4, %rcx
decq %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shlq $0x4, %rdx
addq %rdx, %rax
addq $0x38, %rax
xorl %edx, %edx
movdqa 0x8e1a5(%rip), %xmm1    # 0xed910
movdqa 0x8e1ad(%rip), %xmm2    # 0xed920
movdqa 0x8e1b5(%rip), %xmm3    # 0xed930
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x5f7cd
movl $0x0, -0x30(%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x5f7e3
movl $0x0, -0x20(%rax)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x5f81f
movl $0x0, -0x10(%rax)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x5f830
movl $0x0, (%rax)
addq $0x4, %rdx
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0x5f783
movl %ebx, 0x38(%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8e57c(%rip), %rsi     # 0xeddce
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lvm.c
// Function: Arith
static void Arith (lua_State *L, StkId ra, const TValue *rb,
                   const TValue *rc, TMS op) {
  TValue tempb, tempc;
  const TValue *b, *c;
  if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
      (c = luaV_tonumber(rc, &tempc)) != NULL) {
    lua_Number nb = nvalue(b), nc = nvalue(c);
    switch (op) {
      case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
      case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
      case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
      case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;
      case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;
      case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
      case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
      default: lua_assert(0); break;
    }
  }
  else if (!call_binTM(L, rb, rc, ra, op))
    luaG_aritherror(L, rb, rc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x38(%rsp), %rsi
movq %rdx, %rdi
callq 0x57ce3
testq %rax, %rax
je 0x5f9d6
movq %rax, %rbp
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x57ce3
testq %rax, %rax
je 0x5f9d6
movsd (%rbp), %xmm0
movsd (%rax), %xmm1
addl $-0x5, %r13d
leaq 0x8d954(%rip), %rax     # 0xed318
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
addsd %xmm1, %xmm0
jmp 0x5fa58
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %r13d, %r8d
callq 0x5fa80
testl %eax, %eax
jne 0x5fa63
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x57ce3
testq %rax, %rax
cmoveq %r12, %r14
leaq 0x8e49e(%rip), %rdx     # 0xedea7
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f08c
jmp 0x5fa63
movapd %xmm0, 0x10(%rsp)
divsd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0xbac0
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
jmp 0x5fa5c
mulsd %xmm1, %xmm0
jmp 0x5fa58
divsd %xmm1, %xmm0
jmp 0x5fa58
subsd %xmm1, %xmm0
jmp 0x5fa58
callq 0xbb00
movsd %xmm0, (%rbx)
movl $0x3, 0x8(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorpd 0x8dec6(%rip), %xmm0    # 0xed940
movlpd %xmm0, (%rbx)
jmp 0x5fa5c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lvm.c
// Function: call_binTM
static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
                       StkId res, TMS event) {
  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
  if (ttisnil(tm))
    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
  if (ttisnil(tm)) return 0;
  callTMres(L, res, tm, p1, p2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl %r8d, %edx
callq 0x5f010
cmpl $0x0, 0x8(%rax)
jne 0x5fab2
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5f010
cmpl $0x0, 0x8(%rax)
je 0x5fad3
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x5fb65
movl $0x1, %eax
jmp 0x5fad5
xorl %eax, %eax
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/lfunc.c
// Function: luaF_newLclosure
Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
  Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
  c->l.isC = 0;
  c->l.env = e;
  c->l.nupvalues = cast_byte(nelems);
  while (nelems--) c->l.upvals[nelems] = NULL;
  return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
leal 0x28(,%rbx,8), %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5d2f2
movq %rax, %r14
movq 0x20(%r12), %rax
movq 0x28(%rax), %rcx
movq %rcx, (%r14)
movq %r14, 0x28(%rax)
movb 0x20(%rax), %al
andb $0x3, %al
movb %al, 0x9(%r14)
movb $0x6, 0x8(%r14)
movb $0x0, 0xa(%r14)
movq %r15, 0x18(%r14)
movb %bl, 0xb(%r14)
testl %ebx, %ebx
je 0x5fb56
leal -0x1(%rbx), %eax
movslq %eax, %rcx
shlq $0x3, %rcx
shlq $0x3, %rax
subq %rax, %rcx
leaq (%rcx,%r14), %rdi
addq $0x28, %rdi
movl %ebx, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0xb2f0
movq %r14, %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/ldebug.c
// Function: luaG_ordererror
int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
  const char *t1 = luaT_typenames[ttype(p1)];
  const char *t2 = luaT_typenames[ttype(p2)];
  if (t1[2] == t2[2])
    luaG_runerror(L, "attempt to compare two %s values", t1);
  else
    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
  return 0;
}

// Assembly:
pushq %rax
movq %rdx, %rax
movslq 0x8(%rsi), %rcx
leaq 0xeefde(%rip), %rsi     # 0x14ebf0
movq (%rsi,%rcx,8), %rdx
movslq 0x8(%rax), %rax
movq (%rsi,%rax,8), %rcx
movb 0x2(%rdx), %al
cmpb 0x2(%rcx), %al
jne 0x5fc34
leaq 0x8e290(%rip), %rsi     # 0xedebd
xorl %eax, %eax
callq 0x57b1c
leaq 0x8e2a3(%rip), %rsi     # 0xedede
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lvm.c
// Function: call_orderTM
static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
                         TMS event) {
  const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
  const TValue *tm2;
  if (ttisnil(tm1)) return -1;  /* no metamethod? */
  tm2 = luaT_gettmbyobj(L, p2, event);
  if (!luaO_rawequalObj(tm1, tm2))  /* different metamethods? */
    return -1;
  callTMres(L, L->top, tm1, p1, p2);
  return !l_isfalse(L->top);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl %ecx, %edx
callq 0x5f010
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x8(%rax)
je 0x5fd3d
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5f010
movq %r13, %rdi
movq %rax, %rsi
callq 0x57db4
testl %eax, %eax
je 0x5fd3d
movq 0x10(%r14), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x5fb65
movq 0x10(%r14), %rax
movl 0x8(%rax), %ebx
testl %ebx, %ebx
je 0x5fd3d
cmpl $0x1, %ebx
jne 0x5fd38
xorl %ebx, %ebx
cmpl $0x0, (%rax)
setne %bl
jmp 0x5fd3d
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %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/ldo.c
// Function: f_parser
static void f_parser (lua_State *L, void *ud) {
  int i;
  Proto *tf;
  Closure *cl;
  struct SParser *p = cast(struct SParser *, ud);
  int c = luaZ_lookahead(p->z);
  luaC_checkGC(L);
  tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
                                                             &p->buff, p->name);
  cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
  cl->l.p = tf;
  for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */
    cl->l.upvals[i] = luaF_newupval(L);
  setclvalue(L, L->top, cl);
  incr_top(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x5fe4b
movl %eax, %ebp
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x5fd7c
movq %rbx, %rdi
callq 0x57814
cmpl $0x1b, %ebp
leaq 0xf3(%rip), %rax        # 0x5fe79
leaq 0x1b9(%rip), %r8        # 0x5ff46
cmoveq %rax, %r8
leaq 0x8(%r14), %rdx
movq (%r14), %rsi
movq 0x20(%r14), %rcx
movq %rbx, %rdi
callq *%r8
movq %rax, %r14
movzbl 0x70(%rax), %esi
movq 0x78(%rbx), %rdx
movq %rbx, %rdi
callq 0x5fade
movq %rax, %r15
movq %r14, 0x20(%rax)
cmpb $0x0, 0x70(%r14)
je 0x5fe14
xorl %r12d, %r12d
movl $0x28, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5d2f2
movq 0x20(%rbx), %rcx
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x28(%rcx)
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0xa, 0x8(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x28(%r15,%r12,8)
incq %r12
movzbl 0x70(%r14), %eax
cmpq %rax, %r12
jb 0x5fdc6
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movl $0x6, 0x8(%rax)
movq 0x38(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x10, %rax
jg 0x5fe3d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x576ac
addq $0x10, 0x10(%rbx)
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/lzio.c
// Function: luaZ_lookahead
int luaZ_lookahead (ZIO *z) {
  if (z->n == 0) {
    if (luaZ_fill(z) == EOZ)
      return EOZ;
    else {
      z->n++;  /* luaZ_fill removed first byte; put back it */
      z->p--;
    }
  }
  return char2int(*z->p);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x5fe69
movq %rbx, %rdi
callq 0x6008d
cmpl $-0x1, %eax
je 0x5fe72
incq (%rbx)
decq 0x8(%rbx)
movq 0x8(%rbx), %rax
movzbl (%rax), %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5fe70
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lundump.c
// Function: luaU_undump
Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
{
 LoadState S;
 if (*name=='@' || *name=='=')
  S.name=name+1;
 else if (*name==LUA_SIGNATURE[0])
  S.name="binary string";
 else
  S.name=name;
 S.L=L;
 S.Z=Z;
 S.b=buff;
 LoadHeader(&S);
 return LoadFunction(&S,luaS_newliteral(L,"=?"));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movzbl (%rcx), %eax
cmpl $0x1b, %eax
je 0x5fe9a
cmpl $0x40, %eax
je 0x5fe95
cmpl $0x3d, %eax
jne 0x5fea1
incq %rcx
jmp 0x5fea1
leaq 0x8e085(%rip), %rcx     # 0xedf26
leaq 0x18(%rsp), %rdi
movq %rcx, 0x18(%rdi)
movq %rbx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movl $0x61754c1b, 0xc(%rsp)  # imm = 0x61754C1B
movabsq $0x8040804010051, %rax  # imm = 0x8040804010051
movq %rax, 0x10(%rsp)
leaq 0x3c(%rsp), %r14
movl $0xc, %edx
movq %r14, %rsi
callq 0x6074d
movq 0xc(%rsp), %rax
xorq (%r14), %rax
movl 0x14(%rsp), %ecx
xorl 0x8(%r14), %ecx
orq %rax, %rcx
jne 0x5ff1c
leaq 0x8e03a(%rip), %rsi     # 0xedf34
movl $0x2, %edx
movq %rbx, %rdi
callq 0x583e8
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x600dc
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x30(%rsp), %rdx
leaq 0x8e029(%rip), %rsi     # 0xedf51
leaq 0x8e008(%rip), %rcx     # 0xedf37
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5d33c
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5d170
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: luaY_parser
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
  struct LexState lexstate;
  struct FuncState funcstate;
  lexstate.buff = buff;
  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
  open_func(&lexstate, &funcstate);
  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
  luaX_next(&lexstate);  /* read first token */
  chunk(&lexstate);
  check(&lexstate, TK_EOS);
  close_func(&lexstate);
  lua_assert(funcstate.prev == NULL);
  lua_assert(funcstate.f->nups == 0);
  lua_assert(lexstate.fs == NULL);
  return funcstate.f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, 0x50(%rsp)
movq %rcx, %rdi
callq 0xb260
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x583e8
movb $0x2e, 0x60(%rsp)
movq %r15, 0x40(%rsp)
movl $0x11f, 0x28(%rsp)      # imm = 0x11F
movq %r14, 0x48(%rsp)
movq $0x0, 0x38(%rsp)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0xc(%rsp)
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
movl $0x20, %ecx
movq %r15, %rdi
callq 0x5d2f2
movq 0x50(%rsp), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
movq 0x48(%rsp), %rdi
subq $0x1, (%rdi)
jae 0x5ffe5
callq 0x6008d
jmp 0x5fff4
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
leaq 0x8(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x68(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x60906
movq (%r14), %rax
movb $0x2, 0x72(%rax)
movl 0x4(%rbx), %eax
movl 0x20(%rbx), %ecx
movl %eax, 0x8(%rbx)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0x6003a
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x617cb
movl %eax, 0x10(%rbx)
jmp 0x6004c
leaq 0x28(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, -0x10(%rax)
movl $0x11f, (%rax)          # imm = 0x11F
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x60a38
cmpl $0x11f, 0x10(%rbx)      # imm = 0x11F
jne 0x6007e
leaq 0x8(%rsp), %rdi
callq 0x615e9
movq 0x68(%rsp), %rax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
movl $0x11f, %esi            # imm = 0x11F
callq 0x6538e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lundump.c
// Function: LoadInt
static int LoadInt(LoadState* S)
{
 int x;
 LoadVar(S,x);
 IF (x<0, "bad integer");
 return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x4, %edx
movq %r14, %rsi
callq 0x6074d
movl (%r14), %eax
testl %eax, %eax
js 0x60887
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x8d6bc(%rip), %rsi     # 0xedf51
leaq 0x8d6e8(%rip), %rcx     # 0xedf84
xorl %eax, %eax
callq 0x5d33c
movq (%rbx), %rdi
movl $0x3, %esi
callq 0x5d170
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: open_func
static void open_func (LexState *ls, FuncState *fs) {
  lua_State *L = ls->L;
  Proto *f = luaF_newproto(L);
  fs->f = f;
  fs->prev = ls->fs;  /* linked list of funcstates */
  fs->ls = ls;
  fs->L = L;
  ls->fs = fs;
  fs->pc = 0;
  fs->lasttarget = -1;
  fs->jpc = NO_JUMP;
  fs->freereg = 0;
  fs->nk = 0;
  fs->np = 0;
  fs->nlocvars = 0;
  fs->nactvar = 0;
  fs->bl = NULL;
  f->source = ls->source;
  f->maxstacksize = 2;  /* registers 0/1 are always valid */
  fs->h = luaH_new(L, 0, 0);
  /* anchor table of constants and prototype (to avoid being collected) */
  sethvalue2s(L, L->top, fs->h);
  incr_top(L);
  setptvalue2s(L, L->top, f);
  incr_top(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x38(%rdi), %rbx
xorl %r13d, %r13d
movl $0x78, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5d2f2
movq %rax, %r14
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rcx
movq %rcx, (%r14)
movq %r14, 0x28(%rax)
movb 0x20(%rax), %al
andb $0x3, %al
movb %al, 0x9(%r14)
movb $0x9, 0x8(%r14)
movq %r13, 0x60(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movl $0x0, 0x70(%r14)
movq %r14, (%r15)
movq 0x30(%r12), %rax
movq %rax, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %rbx, 0x20(%r15)
movq %r15, 0x30(%r12)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x30(%r15)
movl $0xffffffff, 0x38(%r15) # imm = 0xFFFFFFFF
movq %r13, 0x28(%r15)
movq %r13, 0x3c(%r15)
movq %r13, 0x43(%r15)
movq 0x50(%r12), %rax
movq %rax, 0x40(%r14)
movb $0x2, 0x73(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58df1
movq %rax, 0x8(%r15)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x5, 0x8(%rcx)
movq 0x38(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x10, %rax
jg 0x609f7
movq %rbx, %rdi
movl $0x1, %esi
callq 0x576ac
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, 0x10(%rax)
movl $0x9, 0x18(%rax)
movq 0x38(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x10, %rax
jg 0x60a29
movq %rbx, %rdi
movl $0x1, %esi
callq 0x576ac
addq $0x10, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/llex.c
// Function: luaX_lexerror
void luaX_lexerror (LexState *ls, const char *msg, int token) {
  char buff[MAXSRC];
  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
  if (token)
    luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
  luaD_throw(ls->L, LUA_ERRSYNTAX);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
addq $0x18, %rsi
movq %rsp, %r12
movl $0x50, %edx
movq %r12, %rdi
callq 0x5c8b7
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x8bba4(%rip), %rsi     # 0xeddf5
movq %r12, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x5d33c
testl %r14d, %r14d
je 0x622a8
movq %rax, %r15
movq 0x38(%rbx), %r12
leal -0x11c(%r14), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0x62289
xorl %esi, %esi
callq 0x622b6
movq 0x48(%rbx), %rax
movq (%rax), %rcx
jmp 0x62294
movl %r14d, %esi
callq 0x6257e
movq %rax, %rcx
leaq 0x8bd89(%rip), %rsi     # 0xee024
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x5d33c
movq 0x38(%rbx), %rdi
movl $0x3, %esi
callq 0x5d170
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/llex.c
// Function: save
static void save (LexState *ls, int c) {
  Mbuffer *b = ls->buff;
  if (b->n + 1 > b->buffsize) {
    size_t newsize;
    if (b->buffsize >= MAX_SIZET/2)
      luaX_lexerror(ls, "lexical element too long", 0);
    newsize = b->buffsize * 2;
    luaZ_resizebuffer(ls->L, b, newsize);
  }
  b->buffer[b->n++] = cast(char, c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x48(%rdi), %r15
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rax
incq %rcx
cmpq %rax, %rcx
jbe 0x62304
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, %rax
jae 0x6231c
movq 0x10(%r15), %rdx
leaq (%rdx,%rdx), %r14
movq 0x38(%rdi), %rdi
cmpq $-0x2, %r14
je 0x6232a
movq (%r15), %rsi
movq %r14, %rcx
callq 0x5d2f2
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq (%r15), %rax
movq 0x8(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r15)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8bd43(%rip), %rsi     # 0xee066
xorl %edx, %edx
callq 0x62217
leaq 0x8ba9d(%rip), %rsi     # 0xeddce
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/llex.c
// Function: check_next
static int check_next (LexState *ls, const char *set) {
  if (!strchr(set, ls->current))
    return 0;
  save_and_next(ls);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq %rsi, %rdi
movl %ebp, %esi
callq 0xb210
testq %rax, %rax
je 0x6236a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x622b6
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x6236e
callq 0x6008d
jmp 0x6237d
xorl %eax, %eax
jmp 0x62384
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/llex.c
// Function: read_numeral
static void read_numeral (LexState *ls, SemInfo *seminfo) {
  lua_assert(isdigit(ls->current));
  do {
    save_and_next(ls);
  } while (isdigit(ls->current) || ls->current == '.');
  if (check_next(ls, "Ee"))  /* `E'? */
    check_next(ls, "+-");  /* optional exponent sign */
  while (isalnum(ls->current) || ls->current == '_')
    save_and_next(ls);
  save(ls, '\0');
  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
    trydecpoint(ls, seminfo); /* try to update decimal point separator */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rbx), %esi
movq %rbx, %rdi
callq 0x622b6
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x623b5
callq 0x6008d
movl %eax, %ebp
jmp 0x623c4
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movl %ebp, (%rbx)
callq 0xb6e0
cmpl $0x2e, %ebp
je 0x62398
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0x62398
leaq 0x8bc94(%rip), %rsi     # 0xee07f
movq %rbx, %rdi
callq 0x62338
testl %eax, %eax
je 0x62406
leaq 0x8bc84(%rip), %rsi     # 0xee082
movq %rbx, %rdi
callq 0x62338
movslq (%rbx), %rsi
cmpq $0x5f, %rsi
je 0x6241b
movq (%r15), %rax
movzwl (%rax,%rsi,2), %eax
andl $0x8, %eax
je 0x62458
movq %rbx, %rdi
callq 0x622b6
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x62436
callq 0x6008d
movl %eax, %esi
jmp 0x62445
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %esi
movl %esi, (%rbx)
cmpl $0x5f, %esi
je 0x6241b
movq (%r15), %rax
movslq %esi, %rcx
movzwl (%rax,%rcx,2), %eax
jmp 0x62416
movq %rbx, %rdi
xorl %esi, %esi
callq 0x622b6
movq 0x48(%rbx), %rdx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x62485
movb 0x58(%rbx), %cl
movq (%rdx), %rdx
cmpb $0x2e, -0x1(%rdx,%rax)
jne 0x62480
movb %cl, -0x1(%rdx,%rax)
decq %rax
jne 0x62475
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x625dd
testl %eax, %eax
jne 0x624e3
callq 0xbca0
testq %rax, %rax
je 0x624a9
movq (%rax), %rax
movb (%rax), %al
jmp 0x624ab
movb $0x2e, %al
movb 0x58(%rbx), %cl
movb %al, 0x58(%rbx)
movq 0x48(%rbx), %rsi
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x624d0
movq (%rsi), %rsi
cmpb %cl, -0x1(%rsi,%rdx)
jne 0x624cb
movb %al, -0x1(%rsi,%rdx)
decq %rdx
jne 0x624c1
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x625dd
testl %eax, %eax
je 0x624ee
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%rbx), %rdx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x62511
movb 0x58(%rbx), %cl
movq (%rdx), %rdx
cmpb %cl, -0x1(%rdx,%rax)
jne 0x6250c
movb $0x2e, -0x1(%rdx,%rax)
decq %rax
jne 0x62501
leaq 0x8bb6d(%rip), %rsi     # 0xee085
movq %rbx, %rdi
movl $0x11c, %edx            # imm = 0x11C
callq 0x62217
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/llex.c
// Function: luaX_newstring
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
  lua_State *L = ls->L;
  TString *ts = luaS_newlstr(L, str, l);
  TValue *o = luaH_setstr(L, ls->fs->h, ts);  /* entry for `str' */
  if (ttisnil(o)) {
    setbvalue(o, 1);  /* make sure `str' will not be collected */
    luaC_checkGC(L);
  }
  return ts;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x583e8
movq %rax, %r14
movq 0x30(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5f123
cmpl $0x0, 0x8(%rax)
jne 0x62575
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x62575
movq %rbx, %rdi
callq 0x57814
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/llex.c
// Function: luaX_token2str
const char *luaX_token2str (LexState *ls, int token) {
  if (token < FIRST_RESERVED) {
    lua_assert(token == cast(unsigned char, token));
    return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
                              luaO_pushfstring(ls->L, "%c", token);
  }
  else
    return luaX_tokens[token-FIRST_RESERVED];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl $0x100, %esi            # imm = 0x100
jg 0x625ad
movq %rdi, %r14
callq 0xb6e0
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x2, (%rax,%rcx,2)
movq 0x38(%r14), %rdi
jne 0x625c6
leaq 0x981b0(%rip), %rsi     # 0xfa75b
jmp 0x625cd
addl $0xfffffeff, %ebx       # imm = 0xFFFFFEFF
leaq 0xec3f6(%rip), %rax     # 0x14e9b0
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8ba64(%rip), %rsi     # 0xee031
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d33c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lobject.c
// Function: luaO_str2d
int luaO_str2d (const char *s, lua_Number *result) {
  char *endptr;
  *result = lua_str2number(s, &endptr);
  if (endptr == s) return 0;  /* conversion failed */
  if (*endptr == 'x' || *endptr == 'X')  /* maybe an hexadecimal constant? */
    *result = cast_num(strtoul(s, &endptr, 16));
  if (*endptr == '\0') return 1;  /* most common case */
  while (isspace(cast(unsigned char, *endptr))) endptr++;
  if (*endptr != '\0') return 0;  /* invalid trailing characters? */
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0xb490
movsd %xmm0, (%rbx)
movq (%r15), %rax
cmpq %r14, %rax
je 0x6267d
movzbl (%rax), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x62647
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x10, %edx
callq 0xb1c0
movq %rax, %xmm0
punpckldq 0x7ee51(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x7ee59(%rip), %xmm0    # 0xe1490
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x62681
callq 0xb6e0
movq (%rax), %rcx
movq 0x8(%rsp), %rax
decq %rax
movzbl 0x1(%rax), %edx
incq %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x62661
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testb %dl, %dl
sete %al
jmp 0x62686
xorl %eax, %eax
jmp 0x62686
movl $0x1, %eax
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: testnext
static int testnext (LexState *ls, int c) {
  if (ls->t.token == c) {
    luaX_next(ls);
    return 1;
  }
  else return 0;
}

// Assembly:
xorl %eax, %eax
cmpl %esi, 0x10(%rdi)
jne 0x626d7
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0x626bd
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x617cb
movl %eax, 0x10(%rbx)
jmp 0x626d1
leaq 0x10(%rbx), %rax
addq $0x20, %rbx
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl $0x11f, (%rbx)          # imm = 0x11F
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: block
static void block (LexState *ls) {
  /* block -> chunk */
  FuncState *fs = ls->fs;
  BlockCnt bl;
  enterblock(fs, &bl, 0);
  chunk(ls);
  lua_assert(bl.breaklist == NO_JUMP);
  leaveblock(fs);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x30(%rdi), %rbx
movq %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)
callq 0x60a38
movq %rbx, %rdi
callq 0x65300
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: check_match
static void check_match (LexState *ls, int what, int who, int where) {
  if (!testnext(ls, what)) {
    if (where == ls->linenumber)
      error_expected(ls, what);
    else {
      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
             LUA_QS " expected (to close " LUA_QS " at line %d)",
              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x62690
testl %eax, %eax
je 0x6273c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl %ebp, 0x4(%rbx)
jne 0x6274c
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6538e
movq 0x38(%rbx), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6257e
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x6257e
leaq 0x8bad6(%rip), %rsi     # 0xee246
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x5d33c
movl 0x10(%rbx), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62217
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: breakstat
static void breakstat (LexState *ls) {
  FuncState *fs = ls->fs;
  BlockCnt *bl = fs->bl;
  int upval = 0;
  while (bl && !bl->isbreakable) {
    upval |= bl->upval;
    bl = bl->previous;
  }
  if (!bl)
    luaX_syntaxerror(ls, "no loop to break");
  if (upval)
    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rbx
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x627ba
xorl %eax, %eax
cmpb $0x0, 0xe(%r14)
jne 0x627c9
movzbl 0xd(%r14), %ecx
orl %ecx, %eax
movq (%r14), %r14
testq %r14, %r14
jne 0x627a4
movl 0x10(%rdi), %edx
leaq 0x8bb1b(%rip), %rsi     # 0xee2df
callq 0x62217
testl %eax, %eax
je 0x627e7
movzbl 0xc(%r14), %esi
shll $0x6, %esi
orl $0x23, %esi
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0x63675
addq $0x8, %r14
movq %rbx, %rdi
callq 0x628ac
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
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: test_then_block
static int test_then_block (LexState *ls) {
  /* test_then_block -> [IF | ELSEIF] cond THEN block */
  int condexit;
  luaX_next(ls);  /* skip IF or ELSEIF */
  condexit = cond(ls);
  checknext(ls, TK_THEN);
  block(ls);  /* `then' part */
  return condexit;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0x6282c
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x617cb
movl %eax, 0x10(%rbx)
jmp 0x62840
leaq 0x20(%rbx), %rax
leaq 0x10(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %rbx, %rdi
callq 0x628f3
movl %eax, %ebp
movq %rbx, %rdi
movl $0x112, %esi            # imm = 0x112
callq 0x62931
movq %rbx, %rdi
callq 0x626d8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: codearith
static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
  if (constfolding(op, e1, e2))
    return;
  else {
    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
    int o1 = luaK_exp2RK(fs, e1);
    if (o1 > o2) {
      freeexp(fs, e1);
      freeexp(fs, e2);
    }
    else {
      freeexp(fs, e2);
      freeexp(fs, e1);
    }
    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
    e1->k = VRELOCABLE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x5, (%rdx)
jne 0x63290
cmpl $-0x1, 0x10(%rbx)
jne 0x63290
cmpl $-0x1, 0x14(%rbx)
jne 0x63290
cmpl $0x5, (%r12)
jne 0x63290
cmpl $-0x1, 0x10(%r12)
jne 0x63290
cmpl $-0x1, 0x14(%r12)
je 0x6334f
xorl %ebp, %ebp
cmpl $0x12, %r15d
je 0x632ab
cmpl $0x14, %r15d
je 0x632ab
movq %r14, %rdi
movq %r12, %rsi
callq 0x63cee
movl %eax, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63cee
cmpl %ebp, %eax
jle 0x632e3
cmpl $0xc, (%rbx)
jne 0x632d5
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x632d5
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0x632d5
decl 0x3c(%r14)
cmpl $0xc, (%r12)
jne 0x6331d
movl 0x8(%r12), %ecx
jmp 0x6330a
cmpl $0xc, (%r12)
jne 0x63302
movl 0x8(%r12), %ecx
btl $0x8, %ecx
jb 0x63302
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0x63302
decl 0x3c(%r14)
cmpl $0xc, (%rbx)
jne 0x6331d
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x6331d
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0x6331d
decl 0x3c(%r14)
shll $0x17, %eax
shll $0xe, %ebp
orl %eax, %ebp
orl %r15d, %ebp
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x63675
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorpd %xmm0, %xmm0
leal -0xc(%r15), %eax
cmpl $0x8, %eax
ja 0x633ba
movsd 0x8(%rbx), %xmm2
movsd 0x8(%r12), %xmm1
leaq 0x8a165(%rip), %rcx     # 0xed4d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
jmp 0x633b6
movapd %xmm2, %xmm0
callq 0xbb00
jmp 0x633ba
subsd %xmm1, %xmm2
jmp 0x633b6
xorpd 0x8a5a9(%rip), %xmm2    # 0xed940
jmp 0x633b6
xorl %ebp, %ebp
jmp 0x632ab
mulsd %xmm1, %xmm2
jmp 0x633b6
ucomisd %xmm0, %xmm1
jne 0x633b2
jnp 0x63290
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
ucomisd %xmm0, %xmm0
jp 0x63290
movsd %xmm0, 0x8(%rbx)
jmp 0x63342
ucomisd %xmm0, %xmm1
jne 0x633da
jnp 0x63290
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0xbac0
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x633ba
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: luaK_dischargevars
void luaK_dischargevars (FuncState *fs, expdesc *e) {
  switch (e->k) {
    case VLOCAL: {
      e->k = VNONRELOC;
      break;
    }
    case VUPVAL: {
      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    case VGLOBAL: {
      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
      e->k = VRELOCABLE;
      break;
    }
    case VINDEXED: {
      freereg(fs, e->u.s.aux);
      freereg(fs, e->u.s.info);
      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
      e->k = VRELOCABLE;
      break;
    }
    case VVARARG:
    case VCALL: {
      luaK_setoneret(fs, e);
      break;
    }
    default: break;  /* there is one value available (somewhere) */
  }
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x8, %eax
ja 0x634a0
movq %rsi, %rbx
leaq 0x8a0d6(%rip), %rcx     # 0xed4f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rsi
popq %rbx
jmp 0x63628
movl 0x8(%rbx), %esi
shll $0xe, %esi
orl $0x5, %esi
jmp 0x6348b
movl $0xc, (%rbx)
jmp 0x634a0
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x4, %esi
jmp 0x6348b
movl 0xc(%rbx), %eax
btl $0x8, %eax
jb 0x63466
movzbl 0x4a(%rdi), %ecx
cmpl %ecx, %eax
jl 0x63466
decl 0x3c(%rdi)
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x6347a
movzbl 0x4a(%rdi), %ecx
cmpl %ecx, %eax
jl 0x6347a
decl 0x3c(%rdi)
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %esi
shll $0x17, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x6, %esi
movq 0x18(%rdi), %rax
movl 0x8(%rax), %edx
callq 0x63675
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: luaK_code
static int luaK_code (FuncState *fs, Instruction i, int line) {
  Proto *f = fs->f;
  dischargejpc(fs);  /* `pc' will change */
  /* put new instruction in code array */
  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
                  MAX_INT, "code size overflow");
  f->code[fs->pc] = i;
  /* save corresponding line information */
  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
                  MAX_INT, "code size overflow");
  f->lineinfo[fs->pc] = line;
  return fs->pc++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r15
movl 0x38(%rdi), %esi
movl 0x30(%rdi), %edx
movl $0xff, %ecx
movl %edx, %r8d
callq 0x637a3
movl $0xffffffff, 0x38(%rbx) # imm = 0xFFFFFFFF
movl 0x30(%rbx), %eax
cmpl 0x50(%r15), %eax
jl 0x636d1
leaq 0x50(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x18(%r15), %rsi
leaq 0x8a9fa(%rip), %r9      # 0xee0b7
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0x6372c
movq %rax, 0x18(%r15)
movq 0x18(%r15), %rax
movslq 0x30(%rbx), %rcx
movl %r14d, (%rax,%rcx,4)
movl 0x30(%rbx), %eax
cmpl 0x54(%r15), %eax
jl 0x6370d
leaq 0x54(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x28(%r15), %rsi
leaq 0x8a9be(%rip), %r9      # 0xee0b7
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0x6372c
movq %rax, 0x28(%r15)
movq 0x28(%r15), %rax
movslq 0x30(%rbx), %rcx
movl %ebp, (%rax,%rcx,4)
movl 0x30(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x30(%rbx)
addq $0x8, %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/lmem.c
// Function: luaM_growaux_
void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
                     int limit, const char *errormsg) {
  void *newblock;
  int newsize;
  if (*size >= limit/2) {  /* cannot double it? */
    if (*size >= limit)  /* cannot grow even a little? */
      luaG_runerror(L, errormsg);
    newsize = limit;  /* still have at least one free place */
  }
  else {
    newsize = (*size)*2;
    if (newsize < MINSIZEARRAY)
      newsize = MINSIZEARRAY;  /* minimum size */
  }
  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
  *size = newsize;  /* update only when everything else is OK */
  return newblock;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rdx), %eax
movl %r8d, %edx
shrl %edx
cmpl %edx, %eax
jge 0x6374f
addl %eax, %eax
cmpl $0x5, %eax
movl $0x4, %r14d
cmovgel %eax, %r14d
jmp 0x63757
movl %r8d, %r14d
cmpl %r8d, %eax
jge 0x63799
leal 0x1(%r14), %eax
movslq %eax, %r8
movq $-0x3, %rax
xorl %edx, %edx
divq %rcx
cmpq %r8, %rax
jb 0x63790
movslq (%rbx), %rdx
imulq %rcx, %rdx
movslq %r14d, %rax
imulq %rcx, %rax
movq %rax, %rcx
callq 0x5d2f2
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8a637(%rip), %rsi     # 0xeddce
jmp 0x6379c
movq %r9, %rsi
xorl %eax, %eax
callq 0x57b1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lcode.c
// Function: discharge2reg
static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: {
      luaK_nil(fs, reg, 1);
      break;
    }
    case VFALSE:  case VTRUE: {
      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
      break;
    }
    case VK: {
      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
      break;
    }
    case VKNUM: {
      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VRELOCABLE: {
      Instruction *pc = &getcode(fs, e);
      SETARG_A(*pc, reg);
      break;
    }
    case VNONRELOC: {
      if (reg != e->u.s.info)
        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
      break;
    }
    default: {
      lua_assert(e->k == VVOID || e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.s.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x63409
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0x639ba
leaq 0x89c1b(%rip), %rdx     # 0xed51c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %ebp, %ecx
shll $0x6, %ecx
cmpl $0x2, %eax
movl $0x800000, %eax         # imm = 0x800000
movl $0x2, %esi
cmovel %eax, %esi
orl %ecx, %esi
orl $0x2, %esi
jmp 0x639a2
movq (%r14), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rbx), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movzbl %bpl, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
jmp 0x639b1
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0x639b1
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
jmp 0x639a2
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x63a2e
jmp 0x639b1
movl 0x8(%rbx), %esi
movl %ebp, %eax
shll $0x6, %eax
shll $0xe, %esi
jmp 0x6399e
movsd 0x8(%rbx), %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x63ac5
movl %ebp, %esi
shll $0x6, %esi
shll $0xe, %eax
orl %eax, %esi
incl %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x63675
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq