LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_type
static int io_type(lua_State*L){
void*ud;
luaL_checkany(L,1);
ud=lua_touserdata(L,1);
lua_getfield(L,(-10000),"FILE*");
if(ud==NULL||!lua_getmetatable(L,1)||!lua_rawequal(L,-2,-1))
lua_pushnil(L);
else if(*((FILE**)ud)==NULL)
lua_pushliteral(L,"closed file");
else
lua_pushliteral(L,"file");
return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0xa907
movq 0x18(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
leaq 0x33cd(%rip), %rax      # 0x15498
cmovbq %rcx, %rax
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x120f9
cmpl $0x7, %ecx
jne 0x1214b
movq (%rax), %r14
addq $0x28, %r14
leaq 0x3ec7(%rip), %rdx      # 0x15fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x114a3
jmp 0x12115
movq (%rax), %r14
leaq 0x3eae(%rip), %rdx      # 0x15fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x114a3
testq %r14, %r14
je 0x1215f
movq %rbx, %rdi
callq 0x1054c
testl %eax, %eax
je 0x1215f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1171d
testl %eax, %eax
je 0x1215f
cmpq $0x0, (%r14)
je 0x12174
leaq 0x3e97(%rip), %rsi      # 0x15fdb
movl $0x4, %edx
jmp 0x12180
leaq 0x3e5f(%rip), %rdx      # 0x15fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x114a3
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
jmp 0x12188
leaq 0x3e59(%rip), %rsi      # 0x15fd4
movl $0xb, %edx
movq %rbx, %rdi
callq 0x94a5
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getiofile
static FILE*getiofile(lua_State*L,int findex){
FILE*f;
lua_rawgeti(L,(-10001),findex);
f=*(FILE**)lua_touserdata(L,-1);
if(f==NULL)
luaL_error(L,"standard %s file is closed",fnames[findex-1]);
return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %r14d, %edx
callq 0x106bf
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
cmpl $0x7, -0x8(%rax)
movq -0x10(%rax), %rax
movl $0x28, %edx
cmovneq %rcx, %rdx
movq (%rax,%rdx), %rax
testq %rax, %rax
je 0x121f3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
decl %r14d
leaq 0x33f3(%rip), %rax      # 0x155f0
movslq (%rax,%r14,4), %rdx
addq %rax, %rdx
leaq 0x3e4d(%rip), %rsi      # 0x16058
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: g_iofile
static int g_iofile(lua_State*L,int f,const char*mode){
if(!lua_isnoneornil(L,1)){
const char*filename=lua_tostring(L,1);
if(filename){
FILE**pf=newfile(L);
*pf=fopen(filename,mode);
if(*pf==NULL)
fileerror(L,1,filename);
}
else{
tofile(L);
lua_pushvalue(L,1);
}
lua_rawseti(L,(-10001),f);
}
lua_rawgeti(L,(-10001),f);
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rax
leaq 0x326a(%rip), %r13      # 0x15498
cmpq %r13, %rax
je 0x122c4
cmpq 0x10(%r14), %rax
jae 0x122c4
cmpl $0x0, 0x8(%rax)
jle 0x122c4
movq %rdx, %r15
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3d8d
testq %rax, %rax
je 0x1228b
movq %rax, %r12
movq %r14, %rdi
callq 0x122dc
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, (%r13)
testq %rax, %rax
jne 0x122b5
movq %r14, %rdi
movq %r12, %rsi
callq 0x12323
movq %r14, %rdi
callq 0x115ed
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
cmpq %rax, %rcx
cmovbq %rcx, %r13
movq (%r13), %rcx
movq %rcx, (%rax)
movl 0x8(%r13), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebx, %edx
callq 0x3930
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x106bf
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: newfile
static FILE**newfile(lua_State*L){
FILE**pf=(FILE**)lua_newuserdata(L,sizeof(FILE*));
*pf=NULL;
luaL_getmetatable(L,"FILE*");
lua_setmetatable(L,-2);
return pf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0x106f4
movq %rax, %r14
movq $0x0, (%rax)
leaq 0x3cb3(%rip), %rdx      # 0x15fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x114a3
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x99cf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_byte
static int str_byte(lua_State*L){
size_t l;
const char*s=luaL_checklstring(L,1,&l);
ptrdiff_t posi=posrelat(luaL_optinteger(L,2,1),l);
ptrdiff_t pose=posrelat(luaL_optinteger(L,3,posi),l);
int n,i;
if(posi<=0)posi=1;
if((size_t)pose>l)pose=l;
if(posi>pose)return 0;
n=(int)(pose-posi+1);
if(posi+n<=pose)
luaL_error(L,"string slice too long");
luaL_checkstack(L,n,"string slice too long");
for(i=0;i<n;i++)
lua_pushinteger(L,uchar(s[posi+i-1]));
return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0xb00c
movq %rax, %r15
movl $0x1, %ebp
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0xb093
movq (%r12), %rcx
incq %rcx
movq %rax, %r13
sarq $0x3f, %r13
andq %rcx, %r13
addq %rax, %r13
xorl %r14d, %r14d
testq %r13, %r13
movl $0x0, %edx
cmovgq %r13, %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0xb093
movq (%r12), %rdx
leaq 0x1(%rdx), %rsi
movq %rax, %rcx
sarq $0x3f, %rcx
andq %rsi, %rcx
addq %rax, %rcx
testq %rcx, %rcx
cmovleq %r14, %rcx
cmpq $0x2, %r13
cmovlq %rbp, %r13
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
cmpq %r13, %rcx
jb 0x12524
movl %ecx, %r12d
subl %r13d, %r12d
leal 0x1(%r12), %r14d
movslq %r14d, %rax
addq %r13, %rax
cmpq %rcx, %rax
jle 0x12536
leaq 0x3be8(%rip), %rdx      # 0x160be
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10e19
cmpl $0x7ffffffe, %r12d      # imm = 0x7FFFFFFE
ja 0x12524
leaq (%r15,%r13), %rax
decq %rax
movl %r14d, %ecx
movq 0x10(%rbx), %rdx
xorl %esi, %esi
movzbl (%rax,%rsi), %edi
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq 0x10(%rbx), %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rbx)
incq %rsi
cmpq %rsi, %rcx
jne 0x124fa
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b81(%rip), %rsi      # 0x160be
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_char
static int str_char(lua_State*L){
int n=lua_gettop(L);
int i;
luaL_Buffer b;
luaL_buffinit(L,&b);
for(i=1;i<=n;i++){
int c=luaL_checkint(L,i);
luaL_argcheck(L,uchar(c)==c,i,"invalid value");
luaL_addchar(&b,uchar(c));
}
luaL_pushresult(&b);
return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq 0x10(%rdi), %r13
subq 0x18(%rdi), %r13
shrq $0x4, %r13
leaq 0x18(%rsp), %rax
movq %rdi, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
testl %r13d, %r13d
jle 0x125e7
movq %rdi, %rbx
leaq 0x2018(%rsp), %rbp
negl %r13d
movl $0x1, %r14d
movq %rsp, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0xb0cc
movq %rax, %r12
testl $0xffffff00, %r12d      # imm = 0xFFFFFF00
jne 0x12615
cmpq %rbp, (%rsp)
jb 0x125c5
movq %r15, %rdi
callq 0x10d41
testl %eax, %eax
je 0x125c5
movq %r15, %rdi
callq 0x10d77
movq (%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movb %r12b, (%rax)
leal (%r14,%r13), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x12594
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x10d41
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0xaedf
movl $0x1, %eax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ab8(%rip), %rdx      # 0x160d4
movq %rbx, %rdi
movl %r14d, %esi
callq 0xaa6a
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: gmatch
static int gmatch(lua_State*L){
luaL_checkstring(L,1);
luaL_checkstring(L,2);
lua_settop(L,2);
lua_pushinteger(L,0);
lua_pushcclosure(L,gmatch_aux,3);
return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0xb00c
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0xb00c
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
leaq 0x20(%rax), %rdx
cmpq %rdx, %rcx
jae 0x12d26
leaq 0x10(%rcx), %rdi
cmpq %rdi, %rdx
cmovaq %rdx, %rdi
movq %rcx, %rsi
notq %rsi
addq %rdi, %rsi
movq %rsi, %xmm0
shrq $0x4, %rsi
addq $0x4, %rsi
andq $-0x4, %rsi
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
addq $0x38, %rcx
xorl %edi, %edi
movdqa 0x23c5(%rip), %xmm1     # 0x15010
movdqa 0x23cd(%rip), %xmm2     # 0x15020
movdqa 0x23d5(%rip), %xmm3     # 0x15030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdi, %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, %r8d
notl %r8d
testb $0x1, %r8b
je 0x12caf
movl $0x0, -0x30(%rcx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %r8d
testb $0x1, %r8b
je 0x12cc6
movl $0x0, -0x20(%rcx)
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, %r8d
testb $0x1, %r8b
je 0x12d03
movl $0x0, -0x10(%rcx)
pextrw $0x4, %xmm5, %r8d
testb $0x1, %r8b
je 0x12d15
movl $0x0, (%rcx)
addq $0x4, %rdi
addq $0x40, %rcx
cmpq %rdi, %rsi
jne 0x12c63
movq %rdx, 0x10(%rbx)
movq $0x0, 0x20(%rax)
movl $0x3, 0x28(%rax)
addq $0x10, 0x10(%rbx)
leaq 0x12d6(%rip), %rsi      # 0x1401b
movq %rbx, %rdi
movl $0x3, %edx
callq 0x904e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_lower
static int str_lower(lua_State*L){
size_t l;
size_t i;
luaL_Buffer b;
const char*s=luaL_checklstring(L,1,&l);
luaL_buffinit(L,&b);
for(i=0;i<l;i++)
luaL_addchar(&b,tolower(uchar(s[i])));
luaL_pushresult(&b);
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0xb00c
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq %r14, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
cmpq $0x0, (%r15)
je 0x13288
leaq 0x2028(%rsp), %r15
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
cmpq %r15, 0x10(%rsp)
jb 0x1325e
movq %r14, %rdi
callq 0x10d41
testl %eax, %eax
je 0x1325e
movq %r14, %rdi
callq 0x10d77
callq 0x32e0
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
movb (%rax,%rcx,4), %al
movq 0x10(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movb %al, (%rcx)
incq %r12
cmpq 0x8(%rsp), %r12
jb 0x13243
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x10d41
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0xaedf
movl $0x1, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_rep
static int str_rep(lua_State*L){
size_t l;
luaL_Buffer b;
const char*s=luaL_checklstring(L,1,&l);
int n=luaL_checkint(L,2);
luaL_buffinit(L,&b);
while(n-->0)
luaL_addlstring(&b,s,l);
luaL_pushresult(&b);
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r15
movq %rsp, %rdx
movl $0x1, %esi
callq 0xb00c
movq %rax, %rbx
movq %r15, %rdi
movl $0x2, %esi
callq 0xb0cc
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %r15, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
testl %r14d, %r14d
jle 0x13324
incl %r14d
leaq 0x8(%rsp), %r15
movq (%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10c63
decl %r14d
cmpl $0x1, %r14d
ja 0x1330c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10d41
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0xaedf
movl $0x1, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_sub
static int str_sub(lua_State*L){
size_t l;
const char*s=luaL_checklstring(L,1,&l);
ptrdiff_t start=posrelat(luaL_checkinteger(L,2),l);
ptrdiff_t end=posrelat(luaL_optinteger(L,3,-1),l);
if(start<1)start=1;
if(end>(ptrdiff_t)l)end=(ptrdiff_t)l;
if(start<=end)
lua_pushlstring(L,s+start-1,end-start+1);
else lua_pushliteral(L,"");
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0xb00c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0xb0cc
movq (%r15), %rcx
incq %rcx
movq %rax, %r12
sarq $0x3f, %r12
andq %rcx, %r12
addq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0xb093
movq (%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rax, %rsi
sarq $0x3f, %rsi
andq %rdx, %rsi
addq %rax, %rsi
xorl %edx, %edx
testq %rsi, %rsi
cmovgq %rsi, %rdx
cmpq $0x2, %r12
movl $0x1, %eax
cmovgeq %r12, %rax
cmpq %rcx, %rdx
cmovgeq %rcx, %rdx
subq %rax, %rdx
jge 0x133e5
leaq 0x2545(%rip), %rsi      # 0x15923
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x133f2
leaq (%r14,%rax), %rsi
decq %rsi
incq %rdx
movq %rbx, %rdi
callq 0x94a5
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_upper
static int str_upper(lua_State*L){
size_t l;
size_t i;
luaL_Buffer b;
const char*s=luaL_checklstring(L,1,&l);
luaL_buffinit(L,&b);
for(i=0;i<l;i++)
luaL_addchar(&b,toupper(uchar(s[i])));
luaL_pushresult(&b);
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0xb00c
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq %r14, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
cmpq $0x0, (%r15)
je 0x1349d
leaq 0x2028(%rsp), %r15
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
cmpq %r15, 0x10(%rsp)
jb 0x13473
movq %r14, %rdi
callq 0x10d41
testl %eax, %eax
je 0x13473
movq %r14, %rdi
callq 0x10d77
callq 0x3030
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
movb (%rax,%rcx,4), %al
movq 0x10(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movb %al, (%rcx)
incq %r12
cmpq 0x8(%rsp), %r12
jb 0x13458
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x10d41
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0xaedf
movl $0x1, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: push_captures
static int push_captures(MatchState*ms,const char*s,const char*e){
int i;
int nlevels=(ms->level==0&&s)?1:ms->level;
luaL_checkstack(ms->L,nlevels,"too many captures");
for(i=0;i<nlevels;i++)
push_onecapture(ms,i,s,e);
return nlevels;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x18(%rdi), %eax
testl %eax, %eax
movl $0x1, %ebp
cmovnel %eax, %ebp
testq %rsi, %rsi
cmovel %eax, %ebp
movq 0x10(%rdi), %rdi
leaq 0x2554(%rip), %rdx      # 0x16110
movl %ebp, %esi
callq 0x10e19
testl %ebp, %ebp
jle 0x13be3
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x13f4e
incl %r12d
cmpl %r12d, %ebp
jne 0x13bca
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: start_capture
static const char*start_capture(MatchState*ms,const char*s,
const char*p,int what){
const char*res;
int level=ms->level;
if(level>=32)luaL_error(ms->L,"too many captures");
ms->capture[level].init=s;
ms->capture[level].len=what;
ms->level=level+1;
if((res=match(ms,s,p))==NULL)
ms->level--;
return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
cmpq $0x20, %rax
jge 0x13c27
movq %rax, %rdi
shlq $0x4, %rdi
movq %rsi, 0x20(%rbx,%rdi)
movslq %ecx, %rcx
movq %rcx, 0x28(%rbx,%rdi)
incl %eax
movl %eax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x1379f
testq %rax, %rax
jne 0x13c25
decl 0x18(%rbx)
popq %rbx
retq
movq 0x10(%rbx), %rdi
leaq 0x24de(%rip), %rsi      # 0x16110
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: classend
static const char*classend(MatchState*ms,const char*p){
switch(*p++){
case'%':{
if(*p=='\0')
luaL_error(ms->L,"malformed pattern (ends with "LUA_QL("%%")")");
return p+1;
}
case'[':{
if(*p=='^')p++;
do{
if(*p=='\0')
luaL_error(ms->L,"malformed pattern (missing "LUA_QL("]")")");
if(*(p++)=='%'&&*p!='\0')
p++;
}while(*p!=']');
return p+1;
}
default:{
return p;
}
}
}

// Assembly:
pushq %rax
leaq 0x1(%rsi), %rax
movzbl (%rsi), %ecx
cmpl $0x5b, %ecx
je 0x13c59
cmpl $0x25, %ecx
jne 0x13c95
cmpb $0x0, (%rax)
je 0x13ca9
addq $0x2, %rsi
movq %rsi, %rax
jmp 0x13c95
leaq 0x2(%rsi), %rcx
xorl %edx, %edx
cmpb $0x5e, 0x1(%rsi)
sete %dl
cmoveq %rcx, %rax
movb 0x1(%rdx,%rsi), %cl
testb %cl, %cl
je 0x13c97
leaq 0x1(%rax), %rdx
cmpb $0x25, %cl
jne 0x13c88
cmpb $0x0, 0x1(%rax)
je 0x13c88
addq $0x2, %rax
movq %rax, %rdx
movq %rdx, %rax
movb (%rdx), %cl
cmpb $0x5d, %cl
jne 0x13c6e
incq %rax
popq %rcx
retq
movq 0x10(%rdi), %rdi
leaq 0x24ce(%rip), %rsi      # 0x16170
xorl %eax, %eax
callq 0xa940
movq 0x10(%rdi), %rdi
leaq 0x2499(%rip), %rsi      # 0x1614d
jmp 0x13ca2
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: matchbracketclass
static int matchbracketclass(int c,const char*p,const char*ec){
int sig=1;
if(*(p+1)=='^'){
sig=0;
p++;
}
while(++p<ec){
if(*p=='%'){
p++;
if(match_class(c,uchar(*p)))
return sig;
}
else if((*(p+1)=='-')&&(p+2<ec)){
p+=2;
if(uchar(*(p-2))<=c&&c<=uchar(*p))
return sig;
}
else if(uchar(*p)==c)return sig;
}
return!sig;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1(%rsi), %r12
cmpb $0x5e, 0x1(%rsi)
sete %r14b
setne %r15b
cmovneq %rsi, %r12
leaq 0x1(%r12), %rax
cmpq %rdx, %rax
jae 0x13d3a
movq %rdx, %rbx
movl %edi, %ebp
movzbl 0x1(%r12), %ecx
movzbl 0x2(%r12), %esi
cmpl $0x25, %ecx
jne 0x13d06
movl %ebp, %edi
callq 0x13df6
testl %eax, %eax
jne 0x13d37
addq $0x2, %r12
movq %r12, %rax
jmp 0x13d2a
cmpl $0x2d, %esi
jne 0x13d26
addq $0x3, %r12
cmpq %rbx, %r12
jae 0x13d26
cmpl %ebp, %ecx
jg 0x13d01
movzbl (%r12), %ecx
movq %r12, %rax
cmpl %ebp, %ecx
jb 0x13d2a
jmp 0x13d37
cmpl %ebp, %ecx
je 0x13d37
movq %rax, %r12
incq %rax
cmpq %rbx, %rax
jb 0x13ce1
jmp 0x13d3a
movl %r15d, %r14d
movzbl %r14b, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: singlematch
static int singlematch(int c,const char*p,const char*ep){
switch(*p){
case'.':return 1;
case'%':return match_class(c,uchar(*(p+1)));
case'[':return matchbracketclass(c,p,ep-1);
default:return(uchar(*p)==c);
}
}

// Assembly:
movzbl (%rsi), %ecx
cmpl $0x5b, %ecx
je 0x13d68
cmpl $0x2e, %ecx
je 0x13d62
cmpl $0x25, %ecx
jne 0x13d70
movzbl 0x1(%rsi), %esi
jmp 0x13df6
movl $0x1, %eax
retq
decq %rdx
jmp 0x13cb6
xorl %eax, %eax
cmpl %edi, %ecx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: max_expand
static const char*max_expand(MatchState*ms,const char*s,
const char*p,const char*ep){
ptrdiff_t i=0;
while((s+i)<ms->src_end&&singlematch(uchar(*(s+i)),p,ep))
i++;
while(i>=0){
const char*res=match(ms,(s+i),ep+1);
if(res)return res;
i--;
}
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rbp
subq %rsi, %rbp
jbe 0x13dbc
movq %rdx, %r12
xorl %r13d, %r13d
movzbl (%r14,%r13), %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x13d47
testl %eax, %eax
je 0x13dbf
incq %r13
cmpq %r13, %rbp
jne 0x13d9b
movq %rbp, %r13
jmp 0x13dbf
xorl %r13d, %r13d
incq %rbx
xorl %r12d, %r12d
testq %r13, %r13
js 0x13de4
leaq (%r14,%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1379f
decq %r13
testq %rax, %rax
je 0x13dc5
movq %rax, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: match_class
static int match_class(int c,int cl){
int res;
switch(tolower(cl)){
case'a':res=isalpha(c);break;
case'c':res=iscntrl(c);break;
case'd':res=isdigit(c);break;
case'l':res=islower(c);break;
case'p':res=ispunct(c);break;
case's':res=isspace(c);break;
case'u':res=isupper(c);break;
case'w':res=isalnum(c);break;
case'x':res=isxdigit(c);break;
case'z':res=(c==0);break;
default:return(cl==c);
}
return(islower(cl)?res:!res);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl %esi, %edi
callq 0x31c0
cmpl $0x6b, %eax
jle 0x13e41
addl $-0x6c, %eax
cmpl $0xe, %eax
ja 0x13f45
leaq 0x163b(%rip), %rcx      # 0x15458
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x200, %r14d           # imm = 0x200
jmp 0x13f2a
cmpl $0x61, %eax
je 0x13eff
cmpl $0x63, %eax
je 0x13f17
cmpl $0x64, %eax
jne 0x13f45
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x800, %r14d           # imm = 0x800
jmp 0x13f2a
xorl %r14d, %r14d
testl %ebp, %ebp
sete %r14b
callq 0x32f0
jmp 0x13f2a
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x100, %r14d           # imm = 0x100
jmp 0x13f2a
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x1000, %r14d          # imm = 0x1000
jmp 0x13f2a
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x2000, %r14d          # imm = 0x2000
jmp 0x13f2a
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x4, %r14d
jmp 0x13f2a
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x8, %r14d
jmp 0x13f2a
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x400, %r14d           # imm = 0x400
jmp 0x13f2a
callq 0x32f0
movq (%rax), %rcx
movl %ebp, %edx
movzwl (%rcx,%rdx,2), %r14d
andl $0x2, %r14d
movq (%rax), %rcx
movl %ebx, %edx
xorl %eax, %eax
testl %r14d, %r14d
sete %al
testb $0x2, 0x1(%rcx,%rdx,2)
cmovnel %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
cmpl %ebp, %ebx
sete %al
jmp 0x13f40
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: push_onecapture
static void push_onecapture(MatchState*ms,int i,const char*s,
const char*e){
if(i>=ms->level){
if(i==0)
lua_pushlstring(ms->L,s,e-s);
else
luaL_error(ms->L,"invalid capture index");
}
else{
ptrdiff_t l=ms->capture[i].len;
if(l==(-1))luaL_error(ms->L,"unfinished capture");
if(l==(-2))
lua_pushinteger(ms->L,ms->capture[i].init-ms->src_init+1);
else
lua_pushlstring(ms->L,ms->capture[i].init,l);
}
}

// Assembly:
pushq %rax
movq %rdi, %rax
cmpl %esi, 0x18(%rdi)
jle 0x13f7e
movslq %esi, %rcx
shlq $0x4, %rcx
addq %rax, %rcx
addq $0x20, %rcx
movq 0x8(%rcx), %rdx
movq 0x10(%rax), %rdi
cmpq $-0x2, %rdx
je 0x13f95
cmpq $-0x1, %rdx
je 0x13fc2
movq (%rcx), %rsi
jmp 0x13f8f
movq 0x10(%rax), %rdi
testl %esi, %esi
jne 0x13fb9
subq %rdx, %rcx
movq %rdx, %rsi
movq %rcx, %rdx
popq %rax
jmp 0x94a5
movq (%rcx), %rcx
subq (%rax), %rcx
incq %rcx
movq 0x10(%rdi), %rax
cvtsi2sd %rcx, %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rdi)
popq %rax
retq
leaq 0x21d0(%rip), %rsi      # 0x16190
jmp 0x13fc9
leaq 0x21dd(%rip), %rsi      # 0x161a6
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_checknumber
static lua_Number luaL_checknumber(lua_State*L,int narg){
lua_Number d=lua_tonumber(L,narg);
if(d==0&&!lua_isnumber(L,narg))
tag_error(L,narg,3);
return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1048f
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14002
jp 0x14002
movq %r14, %rdi
movl %ebx, %esi
movsd %xmm0, (%rsp)
callq 0xb13a
movsd (%rsp), %xmm0
testl %eax, %eax
je 0x1400a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1718(%rip), %rdx      # 0x15729
movq %r14, %rdi
movl %ebx, %esi
callq 0xb038
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: gmatch_aux
static int gmatch_aux(lua_State*L){
MatchState ms;
size_t ls;
const char*s=lua_tolstring(L,lua_upvalueindex(1),&ls);
const char*p=lua_tostring(L,lua_upvalueindex(2));
const char*src;
ms.L=L;
ms.src_init=s;
ms.src_end=s+ls;
for(src=s+(size_t)lua_tointeger(L,lua_upvalueindex(3));
src<=ms.src_end;
src++){
const char*e;
ms.level=0;
if((e=match(&ms,src,p))!=NULL){
lua_Integer newstart=e-s;
if(e==src)newstart++;
lua_pushinteger(L,newstart);
lua_replace(L,lua_upvalueindex(3));
return push_captures(&ms,src,e);
}
}
return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq %rsp, %r14
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
movq %r14, %rdx
callq 0x3d8d
movq %rax, %r12
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0xffffd8ec, %esi       # imm = 0xFFFFD8EC
xorl %edx, %edx
callq 0x3d8d
movq %rax, %r13
movq %rbx, 0x18(%rsp)
movq %r12, 0x8(%rsp)
movq (%r14), %r14
leaq (%r12,%r14), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movl $0xffffd8eb, %esi       # imm = 0xFFFFD8EB
callq 0xb10b
cmpq %r14, %rax
jg 0x140fb
movq %rax, %r15
addq %r12, %r15
leaq 0x8(%rsp), %r14
movl $0x0, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1379f
testq %rax, %rax
jne 0x140b2
incq %r15
cmpq 0x10(%rsp), %r15
jbe 0x14089
xorl %ebp, %ebp
jmp 0x140fb
movq %rax, %rbp
subq %r12, %rax
xorl %ecx, %ecx
cmpq %rbp, %r15
sete %cl
addq %rax, %rcx
movq 0x10(%rbx), %rax
cvtsi2sd %rcx, %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xffffd8eb, %esi       # imm = 0xFFFFD8EB
callq 0x11320
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x13b8d
movl %eax, %ebp
movl %ebp, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_findtable
static const char*luaL_findtable(lua_State*L,int idx,
const char*fname,int szhint){
const char*e;
lua_pushvalue(L,idx);
do{
e=strchr(fname,'.');
if(e==NULL)e=fname+strlen(fname);
lua_pushlstring(L,fname,e-fname);
lua_rawget(L,-2);
if(lua_isnil(L,-1)){
lua_pop(L,1);
lua_createtable(L,0,(*e=='.'?1:szhint));
lua_pushlstring(L,fname,e-fname);
lua_pushvalue(L,-2);
lua_settable(L,-4);
}
else if(!lua_istable(L,-1)){
lua_pop(L,2);
return fname;
}
lua_remove(L,-2);
fname=e+1;
}while(*e=='.');
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %r14
movq %rdi, %rbx
callq 0x9d4e
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
leaq 0x1353(%rip), %r13      # 0x15498
movq %r14, %rdi
movl $0x2e, %esi
callq 0x30f0
movq %rax, %r15
testq %rax, %rax
jne 0x14168
movq %r14, %rdi
callq 0x30e0
movq %rax, %r15
addq %r14, %r15
movq %r15, %r12
subq %r14, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x94a5
movq 0x10(%rbx), %rbp
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x7876
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x8(%rbp)
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r13, %rcx
je 0x14232
movl -0x8(%rax), %edx
cmpl $0x5, %edx
je 0x14212
testl %edx, %edx
jne 0x14232
movq %rcx, 0x10(%rbx)
cmpb $0x2e, (%r15)
movl $0x1, %esi
je 0x141ca
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x38a5
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x94a5
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rcx
movq %rcx, (%rax)
movl -0x18(%rax), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rcx
leaq 0x10(%rcx), %rax
movq %rax, 0x10(%rbx)
leaq -0x30(%rcx), %rsi
leaq -0x10(%rcx), %rdx
movq %rbx, %rdi
callq 0x729b
addq $-0x20, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x105a9
leaq 0x1(%r15), %r14
cmpb $0x2e, (%r15)
je 0x14145
xorl %r14d, %r14d
jmp 0x1423a
addq $-0x20, %rax
movq %rax, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tohex
static int tohex(lua_State*L){
UB b=barg(L,1);
int n=lua_isnone(L,2)?8:(int)barg(L,2);
const char*hexdigits="0123456789abcdef";
char buf[8];
int i;
if(n<0){n=-n;hexdigits="0123456789ABCDEF";}
if(n>8)n=8;
for(i=(int)n;--i>=0;){buf[i]=hexdigits[b&15];b>>=4;}
lua_pushlstring(L,buf,(size_t)n);
return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1462d
movl %eax, %ebp
movq 0x18(%rbx), %rax
leaq 0x10(%rax), %rcx
cmpq 0x10(%rbx), %rcx
setae %dl
leaq 0xf0a(%rip), %rsi       # 0x15498
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0x145c5
cmpl $-0x1, 0x18(%rax)
je 0x145c5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1462d
leaq 0x1d33(%rip), %rdx      # 0x162e5
leaq 0x1d1b(%rip), %rcx      # 0x162d4
testl %eax, %eax
cmovsq %rdx, %rcx
jne 0x145d1
xorl %eax, %eax
jmp 0x14604
movl $0x8, %eax
leaq 0x1d03(%rip), %rcx      # 0x162d4
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
cmpl $0x8, %edx
movl $0x8, %esi
cmovll %edx, %esi
leal 0x1(%rsi), %edx
decl %esi
addq %rsp, %rsi
movl %ebp, %edi
andl $0xf, %edi
movb (%rcx,%rdi), %dil
movb %dil, (%rsi)
shrl $0x4, %ebp
decl %edx
decq %rsi
cmpl $0x1, %edx
jg 0x145eb
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x8, %ecx
movl $0x8, %edx
cmovbl %ecx, %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x94a5
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: barg
static UB barg(lua_State*L,int idx){
union{lua_Number n;U64 b;}bn;
bn.n=lua_tonumber(L,idx)+6755399441055744.0;
if(bn.n==0.0&&!lua_isnumber(L,idx))luaL_typerror(L,idx,"number");
return(UB)bn.b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1048f
addsd 0xfbd(%rip), %xmm0      # 0x15600
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14667
jp 0x14667
movq %r14, %rdi
movl %ebx, %esi
movsd %xmm0, (%rsp)
callq 0xb13a
movsd (%rsp), %xmm0
testl %eax, %eax
je 0x14674
movq %xmm0, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10ae(%rip), %rdx      # 0x15729
movq %r14, %rdi
movl %ebx, %esi
callq 0xb038
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: errfile
static int errfile(lua_State*L,const char*what,int fnameindex){
const char*serr=strerror(errno);
const char*filename=lua_tostring(L,fnameindex)+1;
lua_pushfstring(L,"cannot %s %s: %s",what,filename,serr);
lua_remove(L,fnameindex);
return(5+1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x3050
movl (%rax), %edi
callq 0x32c0
movq %rax, %r12
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3d8d
leaq 0x1(%rax), %rcx
leaq 0x1c50(%rip), %rsi      # 0x1630b
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %r8
xorl %eax, %eax
callq 0xaf5c
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x105a9
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getF
static const char*getF(lua_State*L,void*ud,size_t*size){
LoadF*lf=(LoadF*)ud;
(void)L;
if(lf->extraline){
lf->extraline=0;
*size=1;
return"\n";
}
if(feof(lf->f))return NULL;
*size=fread(lf->buff,1,sizeof(lf->buff),lf->f);
return(*size>0)?lf->buff:NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpl $0x0, (%rsi)
je 0x14705
movl $0x0, (%rbx)
movq $0x1, (%r14)
leaq 0x121f(%rip), %rbx      # 0x15922
jmp 0x1473a
movq 0x8(%rbx), %rdi
callq 0x3190
testl %eax, %eax
je 0x14716
xorl %ebx, %ebx
jmp 0x1473a
movq 0x8(%rbx), %rcx
addq $0x10, %rbx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %rbx, %rdi
callq 0x30a0
movq %rax, (%r14)
testq %rax, %rax
cmoveq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/demo/output.c
// Function: main
int main(int argc, char **argv) {
    (void)argc; (void)argv;
    int ret = tb_init();
    if (ret) {
        fprintf(stderr, "tb_init() failed with error code %d\n", ret);
        return 1;
    }

    draw_all();

    struct tb_event ev;
    while (tb_poll_event(&ev)) {
        switch (ev.type) {
        case TB_EVENT_KEY:
            switch (ev.key) {
            case TB_KEY_ESC:
                goto done;
                break;
            }
            break;
        case TB_EVENT_RESIZE:
            draw_all();
            break;
        }
    }
done:
    tb_shutdown();
    return 0;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
callq 0x3e0d
testl %eax, %eax
jne 0x33d9
callq 0x33fa
leaq 0x8(%rsp), %rdi
callq 0x4828
testl %eax, %eax
je 0x33cc
leaq 0x8(%rsp), %rbx
movzbl 0x8(%rsp), %eax
cmpl $0x2, %eax
je 0x33bb
cmpl $0x1, %eax
jne 0x33c0
cmpw $0x1b, 0xa(%rsp)
jne 0x33c0
jmp 0x33cc
callq 0x33fa
movq %rbx, %rdi
callq 0x4828
testl %eax, %eax
jne 0x33a2
callq 0x3e29
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq 0x5c10(%rip), %rcx      # 0x8ff0
movq (%rcx), %rdi
leaq 0x2c1a(%rip), %rsi      # 0x6004
movl %eax, %edx
xorl %eax, %eax
callq 0x3160
movl $0x1, %eax
jmp 0x33d3
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/demo/output.c
// Function: draw_all
static void draw_all() {
    tb_clear();

    tb_select_output_mode(TB_OUTPUT_NORMAL);
    static const uint16_t col1[] = {0, TB_BOLD};
    static const uint16_t col2[] = {TB_REVERSE};
    print_combinations_table(1, 1, col1, 2);
    print_combinations_table(2 + strlen(chars), 1, col2, 1);
    tb_present();

    tb_select_output_mode(TB_OUTPUT_GRAYSCALE);
    int c, x, y;
    for (x = 0, y = 23; x < 24; ++x) {
        tb_change_cell(x, y, '@', x, 0);
        tb_change_cell(x+25, y, ' ', 0, x);
    }
    tb_present();

    tb_select_output_mode(TB_OUTPUT_216);
    y++;
    for (c = 0, x = 0; c < 216; ++c, ++x) {
        if (!(x%24)) {
            x = 0;
            ++y;
        }
        tb_change_cell(x, y, '@', c, 0);
        tb_change_cell(x+25, y, ' ', 0, c);
    }
    tb_present();

    tb_select_output_mode(TB_OUTPUT_256);
    y++;
    for (c = 0, x = 0; c < 256; ++c, ++x) {
        if (!(x%24)) {
            x = 0;
            ++y;
        }
        tb_change_cell(x, y, '+', c | ((y & 1) ? TB_UNDERLINE : 0), 0);
        tb_change_cell(x+25, y, ' ', 0, c);
    }
    tb_present();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x4aa1
movl $0x1, %edi
callq 0x4b75
leaq 0x2c13(%rip), %rsi      # 0x602a
movl $0x1, %edi
movl $0x2, %edx
callq 0x3595
leaq 0x2c01(%rip), %rsi      # 0x602e
movl $0x26, %edi
movl $0x1, %edx
callq 0x3595
callq 0x3feb
movl $0x4, %edi
callq 0x4b75
xorl %ebx, %ebx
movzwl %bx, %ebp
movl %ebx, %edi
movl $0x17, %esi
movl $0x40, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x46ff
leal 0x19(%rbx), %edi
movl $0x17, %esi
movl $0x20, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x46ff
incl %ebx
cmpl $0x18, %ebx
jne 0x344d
callq 0x3feb
movl $0x3, %edi
callq 0x4b75
xorl %eax, %eax
movl $0x18, %ebx
xorl %r15d, %r15d
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
addl $0x2aaaaaa8, %ecx       # imm = 0x2AAAAAA8
rorl $0x3, %ecx
movl $0x0, %r14d
cmpl $0xaaaaaab, %ecx        # imm = 0xAAAAAAB
jb 0x34bd
movl %eax, %r14d
adcl $0x0, %ebx
movzwl %r15w, %ebp
movl %r14d, %edi
movl %ebx, %esi
movl $0x40, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x46ff
leal 0x19(%r14), %edi
movl %ebx, %esi
movl $0x20, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x46ff
incl %r15d
incl %r14d
movl %r14d, %eax
cmpl $0xd8, %r15d
jne 0x349d
callq 0x3feb
movl $0x2, %edi
callq 0x4b75
incl %ebx
xorl %eax, %eax
movl $0xffff, %ebp           # imm = 0xFFFF
xorl %r15d, %r15d
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
addl $0x2aaaaaa8, %ecx       # imm = 0x2AAAAAA8
rorl $0x3, %ecx
movl $0x0, %r14d
cmpl $0xaaaaaab, %ecx        # imm = 0xAAAAAAB
jb 0x353a
movl %eax, %r14d
adcl $0x0, %ebx
movl %ebx, %ecx
andl $0x1, %ecx
shll $0x9, %ecx
addl %r15d, %ecx
andl %ebp, %ecx
movl %r14d, %edi
movl %ebx, %esi
movl $0x2b, %edx
xorl %r8d, %r8d
callq 0x46ff
leal 0x19(%r14), %edi
movl %r15d, %r8d
andl %ebp, %r8d
movl %ebx, %esi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x46ff
incl %r15d
incl %r14d
movl %r14d, %eax
cmpl $0x100, %r15d           # imm = 0x100
jne 0x351a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3feb
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/termbox.c
// Function: send_clear
static void send_clear(void) {
    send_attr(foreground, background);
    bytebuffer_puts(&output_buffer, funcs[T_CLEAR_SCREEN]);
    if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y))
        write_cursor(cursor_x, cursor_y);
    bytebuffer_flush(&output_buffer, inout);

    /* we need to invalidate cursor position too and these two vars are
     * used only for simple cursor positioning optimization, cursor
     * actually may be in the correct place, but we simply discard
     * optimization once and it gives us simple solution for the case when
     * cursor moved */
    lastx = LAST_COORD_INIT;
    lasty = LAST_COORD_INIT;
}

// Assembly:
pushq %rbx
movzwl 0x5c5b(%rip), %edi      # 0x9924
movzwl 0x5c56(%rip), %esi      # 0x9926
callq 0x4266
movq 0x5c1c(%rip), %rax      # 0x98f8
movq 0x20(%rax), %rbx
movq %rbx, %rdi
callq 0x30c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ceb
movl 0x5458(%rip), %edi      # 0x9150
cmpl $-0x1, %edi
sete %al
movl 0x5450(%rip), %esi      # 0x9154
cmpl $-0x1, %esi
sete %cl
orb %al, %cl
jne 0x3d13
callq 0x4599
movl 0x5b77(%rip), %edi      # 0x9890
movq 0x5bc8(%rip), %rsi      # 0x98e8
movslq 0x5bc9(%rip), %rdx      # 0x98f0
callq 0x30a0
movl $0x0, 0x5bba(%rip)      # 0x98f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x5407(%rip)      # 0x9148
movl %eax, 0x5405(%rip)      # 0x914c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/termbox.c
// Function: update_term_size
static void update_term_size(void) {
    struct winsize sz;
    memset(&sz, 0, sizeof(sz));

    ioctl(inout, TIOCGWINSZ, &sz);

    termw = sz.ws_col > 0 ? sz.ws_col : 80;
    termh = sz.ws_row > 0 ? sz.ws_row : 24;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movl 0x5b30(%rip), %edi      # 0x9890
movl $0x5413, %esi           # imm = 0x5413
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3110
movzwl 0x2(%rbx), %eax
testw %ax, %ax
movl $0x50, %ecx
cmovnel %eax, %ecx
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %ecx
movl %ecx, 0x53b5(%rip)      # 0x9140
movl (%rbx), %ecx
testw %cx, %cx
movl $0x18, %edx
cmovnel %ecx, %edx
andl %eax, %edx
movl %edx, 0x53a4(%rip)      # 0x9144
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/termbox.c
// Function: cellbuf_init
static void cellbuf_init(struct cellbuf *buf, int width, int height) {
    buf->cells =
        (struct tb_cell *)malloc(sizeof(struct tb_cell) * width * height);
    assert(buf->cells);
    buf->width = width;
    buf->height = height;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %rax
movslq %edx, %rdi
imulq %rax, %rdi
shlq $0x3, %rdi
callq 0x31b0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x3dd9
movl %ebp, (%r14)
movl %ebx, 0x4(%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x258b(%rip), %rdi      # 0x636b
leaq 0x258f(%rip), %rsi      # 0x6376
leaq 0x2592(%rip), %rcx      # 0x6380
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/termbox.c
// Function: tb_shutdown
void tb_shutdown(void) {
    if (termw == -1) {
        fputs("tb_shutdown() should not be called twice.", stderr);
        abort();
    }

    bytebuffer_puts(&output_buffer, funcs[T_SHOW_CURSOR]);
    bytebuffer_puts(&output_buffer, funcs[T_SGR0]);
    bytebuffer_puts(&output_buffer, funcs[T_CLEAR_SCREEN]);
    bytebuffer_puts(&output_buffer, funcs[T_EXIT_CA]);
    bytebuffer_puts(&output_buffer, funcs[T_EXIT_KEYPAD]);
    bytebuffer_puts(&output_buffer, funcs[T_EXIT_MOUSE]);
    bytebuffer_flush(&output_buffer, inout);
    tcsetattr(inout, TCSAFLUSH, &orig_tios);

    shutdown_term();
    close(inout);
    close(winch_fds[0]);
    close(winch_fds[1]);

    cellbuf_free(&back_buffer);
    cellbuf_free(&front_buffer);
    bytebuffer_free(&output_buffer);
    bytebuffer_free(&input_buffer);
    termw = termh = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $-0x1, 0x530b(%rip)     # 0x9140
je 0x3fe6
movq 0x5ab6(%rip), %rax      # 0x98f8
movq 0x10(%rax), %rbx
movq %rbx, %rdi
callq 0x30c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ceb
movq 0x5a99(%rip), %rax      # 0x98f8
movq 0x28(%rax), %rbx
movq %rbx, %rdi
callq 0x30c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ceb
movq 0x5a7c(%rip), %rax      # 0x98f8
movq 0x20(%rax), %rbx
movq %rbx, %rdi
callq 0x30c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ceb
movq 0x5a5f(%rip), %rax      # 0x98f8
movq 0x8(%rax), %rbx
movq %rbx, %rdi
callq 0x30c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ceb
movq 0x5a42(%rip), %rax      # 0x98f8
movq 0x58(%rax), %rbx
movq %rbx, %rdi
callq 0x30c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ceb
movq 0x5a25(%rip), %rax      # 0x98f8
movq 0x68(%rax), %rbx
movq %rbx, %rdi
callq 0x30c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ceb
movl 0x59a1(%rip), %edi      # 0x9890
movq 0x59f2(%rip), %rsi      # 0x98e8
movslq 0x59f3(%rip), %rdx      # 0x98f0
callq 0x30a0
movl $0x0, 0x59e4(%rip)      # 0x98f0
movl 0x597e(%rip), %edi      # 0x9890
leaq 0x5983(%rip), %rdx      # 0x989c
movl $0x2, %esi
callq 0x31f0
cmpb $0x1, 0x59fe(%rip)      # 0x9928
jne 0x3f74
movq 0x59fd(%rip), %rbx      # 0x9930
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x3040
incq %r14
cmpq $0x16, %r14
jne 0x3f36
movq 0x59a9(%rip), %r14      # 0x98f8
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0x3040
incq %r15
cmpq $0xc, %r15
jne 0x3f52
movq %rbx, %rdi
callq 0x3040
movq %r14, %rdi
callq 0x3040
movl 0x5916(%rip), %edi      # 0x9890
callq 0x3120
movl 0x590f(%rip), %edi      # 0x9894
callq 0x3120
movl 0x5908(%rip), %edi      # 0x9898
callq 0x3120
movq 0x596c(%rip), %rdi      # 0x9908
callq 0x3040
movq 0x5970(%rip), %rdi      # 0x9918
callq 0x3040
movq 0x5934(%rip), %rdi      # 0x98e8
testq %rdi, %rdi
je 0x3fbe
callq 0x3040
movq 0x5913(%rip), %rdi      # 0x98d8
testq %rdi, %rdi
je 0x3fcf
callq 0x3040
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x516a(%rip)      # 0x9144
movl %eax, 0x5160(%rip)      # 0x9140
popq %rbx
popq %r14
popq %r15
retq
callq 0x3270
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/termbox.c
// Function: update_size
static void update_size(void) {
    update_term_size();
    cellbuf_resize(&back_buffer, termw, termh);
    cellbuf_resize(&front_buffer, termw, termh);
    cellbuf_clear(&front_buffer);
    send_clear();
}

// Assembly:
pushq %rax
callq 0x3d49
movl 0x4f4d(%rip), %esi      # 0x9140
movl 0x4f4b(%rip), %edx      # 0x9144
leaq 0x5700(%rip), %rdi      # 0x9900
callq 0x4dbb
movl 0x4f35(%rip), %esi      # 0x9140
movl 0x4f33(%rip), %edx      # 0x9144
leaq 0x56f8(%rip), %rdi      # 0x9910
callq 0x4dbb
movl 0x56f1(%rip), %esi      # 0x9914
imull 0x56e6(%rip), %esi      # 0x9910
testl %esi, %esi
jle 0x4260
movq 0x56e3(%rip), %rax      # 0x9918
movzwl 0x56e8(%rip), %ecx      # 0x9924
movzwl 0x56e3(%rip), %edx      # 0x9926
movl %esi, %esi
xorl %edi, %edi
movl $0x20, (%rax,%rdi,8)
movw %cx, 0x4(%rax,%rdi,8)
movw %dx, 0x6(%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rsi
jne 0x4247
popq %rax
jmp 0x3cc1
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/termbox.c
// Function: send_char
static void send_char(int x, int y, uint32_t c) {
    char buf[7];
    int bw = tb_utf8_unicode_to_char(buf, c);
    if (x - 1 != lastx || y != lasty)
        write_cursor(x, y);
    lastx = x;
    lasty = y;
    if (!c)
        buf[0] = ' '; // replace 0 with whitespace
    bytebuffer_append(&output_buffer, buf, bw);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leaq 0x1(%rsp), %rdi
movl %edx, %esi
callq 0x54c5
movl %eax, %ebx
leal -0x1(%r15), %eax
cmpl 0x4bf3(%rip), %eax      # 0x9148
jne 0x4560
cmpl %r14d, 0x4bee(%rip)     # 0x914c
je 0x456b
movl %r15d, %edi
movl %r14d, %esi
callq 0x4599
movl %r15d, 0x4bd6(%rip)     # 0x9148
movl %r14d, 0x4bd3(%rip)     # 0x914c
testl %ebp, %ebp
jne 0x4582
movb $0x20, 0x1(%rsp)
leaq 0x1(%rsp), %rdi
movl %ebx, %esi
callq 0x4ceb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/termbox.c
// Function: write_cursor
static void write_cursor(int x, int y) {
    char buf[32];
    WRITE_LITERAL("\033[");
    WRITE_INT(y + 1);
    WRITE_LITERAL(";");
    WRITE_INT(x + 1);
    WRITE_LITERAL("H");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0x1dbc(%rip), %rdi      # 0x6368
movl $0x2, %esi
callq 0x4ceb
incl %ebp
movq %rsp, %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0x4d5b
movq %r14, %rdi
movl %eax, %esi
callq 0x4ceb
leaq 0x1ddc(%rip), %rdi      # 0x63b2
movl $0x1, %esi
callq 0x4ceb
incl %ebx
movl %ebx, %edi
movq %r14, %rsi
callq 0x4d5b
movq %r14, %rdi
movl %eax, %esi
callq 0x4ceb
leaq 0x1cbf(%rip), %rdi      # 0x62bc
movl $0x1, %esi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4ceb
// File: /workspace/github_c_makefile_star2_O3/termbox[P]termbox/termbox.c
// Function: tb_set_cursor
void tb_set_cursor(int cx, int cy) {
    if (IS_CURSOR_HIDDEN(cursor_x, cursor_y) && !IS_CURSOR_HIDDEN(cx, cy))
        bytebuffer_puts(&output_buffer, funcs[T_SHOW_CURSOR]);

    if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y) && IS_CURSOR_HIDDEN(cx, cy))
        bytebuffer_puts(&output_buffer, funcs[T_HIDE_CURSOR]);

    cursor_x = cx;
    cursor_y = cy;
    if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y))
        write_cursor(cursor_x, cursor_y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl 0x4b30(%rip), %ecx      # 0x9150
cmpl $-0x1, %ecx
setne %dl
movl 0x4b28(%rip), %eax      # 0x9154
cmpl $-0x1, %eax
setne %sil
cmpl $-0x1, %ebx
je 0x466b
cmpl $-0x1, %ebp
je 0x466b
andb %sil, %dl
jne 0x466b
movq 0x52af(%rip), %rax      # 0x98f8
movq 0x10(%rax), %r14
movq %r14, %rdi
callq 0x30c0
movq %r14, %rdi
movl %eax, %esi
callq 0x4ceb
movl 0x4aeb(%rip), %ecx      # 0x9150
movl 0x4ae9(%rip), %eax      # 0x9154
cmpl $-0x1, %ebx
sete %dl
cmpl $-0x1, %ebp
sete %r15b
orb %dl, %r15b
cmpb $0x1, %r15b
jne 0x46a8
cmpl $-0x1, %ecx
je 0x46a8
cmpl $-0x1, %eax
je 0x46a8
movq 0x5266(%rip), %rax      # 0x98f8
movq 0x18(%rax), %r14
movq %r14, %rdi
callq 0x30c0
movq %r14, %rdi
movl %eax, %esi
callq 0x4ceb
movl %ebp, 0x4aa2(%rip)      # 0x9150
movl %ebx, 0x4aa0(%rip)      # 0x9154
testb %r15b, %r15b
je 0x46c4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4599