LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_checkstack
static int lua_checkstack(lua_State*L,int size){
int res=1;
if(size>8000||(L->top-L->base+size)>8000)
res=0;
else if(size>0){
luaD_checkstack(L,size);
if(L->ci->top<L->top+size)
L->ci->top=L->top+size;
}
return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpl $0x1f40, %esi           # imm = 0x1F40
jg 0xe3c8
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, %rcx
subq 0x18(%rdi), %rcx
sarq $0x4, %rcx
movslq %esi, %r15
addq %r15, %rcx
cmpq $0x1f40, %rcx           # imm = 0x1F40
jg 0xe3c8
pushq $0x1
popq %rbx
testl %esi, %esi
jle 0xe3c8
movq 0x38(%r14), %rcx
subq %rax, %rcx
movl %esi, %edx
shll $0x4, %edx
cmpq %rdx, %rcx
jg 0xe3b3
movq %r14, %rdi
callq 0x4b6b
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
shlq $0x4, %r15
addq %rax, %r15
cmpq %r15, 0x10(%rcx)
jae 0xe3c8
movq %r15, 0x10(%rcx)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_rawgeti
static void lua_rawgeti(lua_State*L,int idx,int n){
StkId o;
o=index2adr(L,idx);
luai_apicheck(L,ttistable(o));
setobj(L,L->top,luaH_getnum(hvalue(o),n));
api_incr_top(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
callq 0x8e4b
movq (%rax), %rdi
movl %ebx, %esi
callq 0x7262
movq 0x10(%r14), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_newuserdata
static void*lua_newuserdata(lua_State*L,size_t size){
Udata*u;
luaC_checkGC(L);
u=luaS_newudata(L,size,getcurrenv(L));
setuvalue(L,L->top,u);
api_incr_top(L);
return u+1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xe426
movq %rbx, %rdi
callq 0x662b
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0xe43d
movq 0x8(%rax), %rax
movq (%rax), %rax
addq $0x18, %rax
jmp 0xe441
leaq 0x78(%rbx), %rax
movq (%rax), %r15
leaq 0x28(%r14), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4158
movq 0x20(%rbx), %rcx
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0x7, 0x8(%rax)
movq %r14, 0x20(%rax)
andq $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq %rax, (%rcx)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x7, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
addq $0x28, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tconcat
static int tconcat(lua_State*L){
luaL_Buffer b;
size_t lsep;
int i,last;
const char*sep=luaL_optlstring(L,2,"",&lsep);
luaL_checktype(L,1,5);
i=luaL_optint(L,3,1);
last=luaL_opt(L,luaL_checkint,4,luaL_getn(L,1));
luaL_buffinit(L,&b);
for(;i<last;i++){
addfield(L,&b,i);
luaL_addlstring(&b,sep,lsep);
}
if(i==last)
addfield(L,&b,i);
luaL_pushresult(&b);
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %rbx
leaq 0x445b(%rip), %rdx      # 0x12923
pushq $0x2
popq %rsi
movq %rsp, %rcx
callq 0x9605
movq %rax, %r14
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0xe177
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x9c2f
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x965e
testl %eax, %eax
jle 0xe511
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x9cae
jmp 0xe51c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xe2fc
movq %rax, %r12
leaq 0x20(%rsp), %rax
movq %rbx, -0x8(%rax)
movq %rax, -0x18(%rax)
andl $0x0, -0x10(%rax)
leaq 0x8(%rsp), %r13
cmpl %r12d, %r15d
jge 0xe55c
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0xe752
movq (%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0xe7bc
incl %r15d
jmp 0xe535
jne 0xe56e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0xe752
leaq 0x8(%rsp), %rdi
callq 0xe80c
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tinsert
static int tinsert(lua_State*L){
int e=aux_getn(L,1)+1;
int pos;
switch(lua_gettop(L)){
case 2:{
pos=e;
break;
}
case 3:{
int i;
pos=luaL_checkint(L,2);
if(pos>e)e=pos;
for(i=e;i>pos;i--){
lua_rawgeti(L,1,i-1);
lua_rawseti(L,1,i);
}
break;
}
default:{
return luaL_error(L,"wrong number of arguments to "LUA_QL("insert"));
}
}
luaL_setn(L,1,e);
lua_rawseti(L,1,pos);
return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xe177
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe2fc
movq %rax, %r14
incl %r14d
movq 0x10(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x4, %rax
cmpl $0x2, %eax
je 0xe60d
cmpl $0x3, %eax
jne 0xe626
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x9cae
movq %rax, %r15
cmpl %r15d, %r14d
cmovlel %r15d, %r14d
pushq $0x1
popq %rbp
cmpl %r15d, %r14d
jle 0xe60a
leal -0x1(%r14), %r12d
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0xe3d0
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x3864
movl %r12d, %r14d
jmp 0xe5e2
movl %r15d, %r14d
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x3864
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4913(%rip), %rsi      # 0x12f40
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tremove
static int tremove(lua_State*L){
int e=aux_getn(L,1);
int pos=luaL_optint(L,2,e);
if(!(1<=pos&&pos<=e))
return 0;
luaL_setn(L,1,e-1);
lua_rawgeti(L,1,pos);
for(;pos<e;pos++){
lua_rawgeti(L,1,pos+1);
lua_rawseti(L,1,pos);
}
lua_pushnil(L);
lua_rawseti(L,1,e);
return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xe177
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe2fc
movq %rax, %r14
movslq %r14d, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9c2f
movq %rax, %r15
testl %r15d, %r15d
setle %al
cmpl %r12d, %r15d
setg %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0xe6d7
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0xe3d0
cmpl %r15d, %r14d
je 0xe6ba
leal 0x1(%r15), %r12d
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0xe3d0
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x3864
movl %r12d, %r15d
jmp 0xe692
movq 0x10(%rbx), %rax
andl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x3864
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: sort
static int sort(lua_State*L){
int n=aux_getn(L,1);
luaL_checkstack(L,40,"");
if(!lua_isnoneornil(L,2))
luaL_checktype(L,2,6);
lua_settop(L,2);
auxsort(L,1,n);
return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xe177
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe2fc
movq %rax, %r14
leaq 0x4219(%rip), %rdx      # 0x12923
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0xe997
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x965e
testl %eax, %eax
jle 0xe732
pushq $0x2
popq %rsi
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0xe177
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x9c5a
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xe9c6
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: addfield
static void addfield(lua_State*L,luaL_Buffer*b,int i){
lua_rawgeti(L,1,i);
if(!lua_isstring(L,-1))
luaL_error(L,"invalid value (%s) at index %d in table for "
LUA_QL("concat"),luaL_typename(L,-1),i);
luaL_addvalue(b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0xe3d0
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x9c99
testl %eax, %eax
je 0xe783
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe82a
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x965e
cmpl $-0x1, %eax
jne 0xe79c
leaq 0x42c4(%rip), %rdx      # 0x12a5e
jmp 0xe7a9
cltq
leaq 0xc0bb(%rip), %rcx      # 0x1a860
movq (%rcx,%rax,8), %rdx
leaq 0x475b(%rip), %rsi      # 0x12f0b
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_addvalue
static void luaL_addvalue(luaL_Buffer*B){
lua_State*L=B->L;
size_t vl;
const char*s=lua_tolstring(L,-1,&vl);
if(vl<=bufffree(B)){
memcpy(B->p,s,vl);
B->p+=vl;
lua_pop(L,1);
}
else{
if(emptybuffer(B))
lua_insert(L,-2);
B->lvl++;
adjuststack(B);
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
pushq $-0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x3b4c
movq (%r15), %rdx
movq (%rbx), %rdi
movq %rbx, %rcx
subq %rdi, %rcx
addq $0x2018, %rcx           # imm = 0x2018
cmpq %rcx, %rdx
jbe 0xe889
movq %rbx, %rdi
callq 0xe8a8
testl %eax, %eax
je 0xe87c
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x9d72
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xe8dc
jmp 0xe89e
movq %rax, %rsi
callq 0x31a0
movq 0x8(%rsp), %rax
addq %rax, (%rbx)
addq $-0x10, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: emptybuffer
static int emptybuffer(luaL_Buffer*B){
size_t l=bufflen(B);
if(l==0)return 0;
else{
lua_pushlstring(B->L,B->buffer,l);
B->p=B->buffer;
B->lvl++;
return 1;
}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rdx
leaq 0x18(%rdi), %r14
subq %r14, %rdx
je 0xe8d2
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %r14, %rsi
callq 0x8937
movq %r14, (%rbx)
incl 0x8(%rbx)
pushq $0x1
popq %rax
jmp 0xe8d4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: adjuststack
static void adjuststack(luaL_Buffer*B){
if(B->lvl>1){
lua_State*L=B->L;
int toget=1;
size_t toplen=lua_strlen(L,-1);
do{
size_t l=lua_strlen(L,-(toget+1));
if(B->lvl-toget+1>=(20/2)||toplen>l){
toplen+=l;
toget++;
}
else break;
}while(toget<B->lvl);
lua_concat(L,toget);
B->lvl=B->lvl-toget+1;
}
}

// Assembly:
cmpl $0x2, 0x8(%rdi)
jl 0xe978
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
pushq $-0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0xe2fc
movq %rax, %r15
xorl %r13d, %r13d
movl %ebp, %r12d
leal -0x1(%r12), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0xe2fc
movl 0x8(%rbx), %edx
addl %edx, %r12d
cmpl $0x9, %r12d
setge %sil
cmpq %rax, %r15
seta %cl
orb %sil, %cl
leal 0x1(%r13), %r12d
cmpb $0x1, %cl
jne 0xe94c
addl $0x2, %r13d
addq %rax, %r15
cmpl %edx, %r13d
movl %r12d, %r13d
jl 0xe90b
negl %ebp
testb %cl, %cl
cmovnel %ebp, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x9a6a
movl 0x8(%rbx), %eax
subl %r12d, %eax
incl %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: sort_comp
static int sort_comp(lua_State*L,int a,int b){
if(!lua_isnil(L,2)){
int res;
lua_pushvalue(L,2);
lua_pushvalue(L,a-1);
lua_pushvalue(L,b-2);
lua_call(L,2,1);
res=lua_toboolean(L,-1);
lua_pop(L,1);
return res;
}
else
return lua_lessthan(L,a,b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x965e
testl %eax, %eax
je 0xecc0
pushq $0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8917
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8917
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8917
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x85eb
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x9522
addq $-0x10, 0x10(%rbx)
jmp 0xecf1
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8e4b
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e4b
leaq 0x3761(%rip), %rcx      # 0x12440
cmpq %rcx, %r14
sete %dl
cmpq %rcx, %rax
sete %cl
orb %dl, %cl
je 0xecfc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7051
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_fclose
static int io_fclose(lua_State*L){
FILE**p=tofilep(L);
int ok=(fclose(*p)==0);
*p=NULL;
return pushresult(L,ok,NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf0bd
movq %rax, %r14
movq (%rax), %rdi
callq 0x30d0
xorl %esi, %esi
testl %eax, %eax
sete %sil
andq $0x0, (%r14)
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf195
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_replace
static void lua_replace(lua_State*L,int idx){
StkId o;
if(idx==(-10001)&&L->ci==L->base_ci)
luaG_runerror(L,"no calling environment");
api_checknelems(L,1);
o=index2adr(L,idx);
api_checkvalidindex(L,o);
if(idx==(-10001)){
Closure*func=curr_func(L);
luai_apicheck(L,ttistable(L->top-1));
func->c.env=hvalue(L->top-1);
luaC_barrier(L,func,L->top-1);
}
else{
setobj(L,o,L->top-1);
if(idx<(-10002))
luaC_barrier(L,curr_func(L),L->top-1);
}
L->top--;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
jne 0xedc3
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0xee54
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e4b
cmpl $0xffffd8ef, %ebp       # imm = 0xFFFFD8EF
jne 0xee02
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rsi
movq -0x10(%rax), %rax
movq %rax, 0x18(%rsi)
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0xee48
movq -0x10(%rax), %rdx
testb $0x3, 0x9(%rdx)
jne 0xee3a
jmp 0xee48
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, (%rax)
movl -0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
cmpl $0xffffd8ed, %ebp       # imm = 0xFFFFD8ED
jg 0xee48
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0xee48
movq -0x10(%rax), %rdx
testb $0x3, 0x9(%rdx)
je 0xee48
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0xee48
movq %rbx, %rdi
callq 0x43bc
addq $-0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x41d9(%rip), %rsi      # 0x13034
movq %rbx, %rdi
xorl %eax, %eax
callq 0x450d
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: createstdfile
static void createstdfile(lua_State*L,FILE*f,int k,const char*fname){
*newfile(L)=f;
if(k>0){
lua_pushvalue(L,-1);
lua_rawseti(L,(-10001),k);
}
lua_pushvalue(L,-2);
lua_setfenv(L,-2);
lua_setfield(L,-3,fname);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0xf9fd
movq %r15, (%rax)
testl %ebp, %ebp
jle 0xeec2
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x8917
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebp, %edx
callq 0x3864
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x8917
movq %r14, %rdi
callq 0xe1f3
pushq $-0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38e3
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_getfield
static void lua_getfield(lua_State*L,int idx,const char*k){
StkId t;
TValue key;
t=index2adr(L,idx);
api_checkvalidindex(L,t);
setsvalue(L,&key,luaS_new(L,k));
luaV_gettable(L,t,&key,L->top);
api_incr_top(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
callq 0x8e4b
movq %rax, %r15
movq %rbx, %rdi
callq 0x30e0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4008
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x4, 0x8(%rdx)
movq 0x10(%r14), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x6b95
addq $0x10, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_pclose
static int io_pclose(lua_State*L){
FILE**p=tofilep(L);
int ok=lua_pclose(L,*p);
*p=NULL;
return pushresult(L,ok,NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xf0bd
andq $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0xf195
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_close
static int io_close(lua_State*L){
if(lua_isnone(L,1))
lua_rawgeti(L,(-10001),2);
tofile(L);
return aux_close(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x965e
cmpl $-0x1, %eax
jne 0xef80
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0xe3d0
movq %rbx, %rdi
callq 0xf023
movq %rbx, %rdi
popq %rbx
jmp 0xf047
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_gc
static int io_gc(lua_State*L){
FILE*f=*tofilep(L);
if(f!=NULL)
aux_close(L);
return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xf0bd
cmpq $0x0, (%rax)
je 0xf01f
movq %rbx, %rdi
callq 0xf047
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tofile
static FILE*tofile(lua_State*L){
FILE**f=tofilep(L);
if(*f==NULL)
luaL_error(L,"attempt to use a closed file");
return*f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xf0bd
movq (%rax), %rax
testq %rax, %rax
je 0xf036
popq %rbx
retq
leaq 0x3f86(%rip), %rsi      # 0x12fc3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_checkudata
static void*luaL_checkudata(lua_State*L,int ud,const char*tname){
void*p=lua_touserdata(L,ud);
if(p!=NULL){
if(lua_getmetatable(L,ud)){
lua_getfield(L,(-10000),tname);
if(lua_rawequal(L,-1,-2)){
lua_pop(L,2);
return p;
}
}
}
luaL_typerror(L,ud,tname);
return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xf128
testq %rax, %rax
je 0xf116
movq %rax, %r14
movq %rbx, %rdi
callq 0xe272
testl %eax, %eax
je 0xf116
leaq 0x3eca(%rip), %rdx      # 0x12fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0xeeed
pushq $-0x1
popq %rsi
pushq $-0x2
popq %rdx
movq %rbx, %rdi
callq 0xf14d
testl %eax, %eax
je 0xf116
addq $-0x20, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3e94(%rip), %rdx      # 0x12fb1
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x9be1
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_touserdata
static void*lua_touserdata(lua_State*L,int idx){
StkId o=index2adr(L,idx);
switch(ttype(o)){
case 7:return(rawuvalue(o)+1);
case 2:return pvalue(o);
default:return NULL;
}
}

// Assembly:
pushq %rax
callq 0x8e4b
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0xf144
cmpl $0x7, %ecx
jne 0xf149
movq (%rax), %rax
addq $0x28, %rax
jmp 0xf14b
movq (%rax), %rax
jmp 0xf14b
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_rawequal
static int lua_rawequal(lua_State*L,int index1,int index2){
StkId o1=index2adr(L,index1);
StkId o2=index2adr(L,index2);
return(o1==(&luaO_nilobject_)||o2==(&luaO_nilobject_))?0
:luaO_rawequalObj(o1,o2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %r14
callq 0x8e4b
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x8e4b
leaq 0x32d1(%rip), %rcx      # 0x12440
cmpq %rcx, %rbx
sete %dl
cmpq %rcx, %rax
sete %cl
orb %dl, %cl
je 0xf186
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7318
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: pushresult
static int pushresult(lua_State*L,int i,const char*filename){
int en=errno;
if(i){
lua_pushboolean(L,1);
return 1;
}
else{
lua_pushnil(L);
if(filename)
lua_pushfstring(L,"%s: %s",filename,strerror(en));
else
lua_pushfstring(L,"%s",strerror(en));
lua_pushinteger(L,en);
return 3;
}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3050
movq 0x10(%rbx), %rcx
testl %ebp, %ebp
je 0xf1b8
movl $0x1, (%rcx)
pushq $0x1
jmp 0xf20d
movl (%rax), %ebp
andl $0x0, 0x8(%rcx)
addq $0x10, %rcx
movq %rcx, 0x10(%rbx)
movl %ebp, %edi
callq 0x32b0
testq %r14, %r14
je 0xf1eb
leaq 0x413c(%rip), %rsi      # 0x13315
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x9ae7
jmp 0xf1ff
leaq 0x347d(%rip), %rsi      # 0x1266f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x9ae7
movq 0x10(%rbx), %rcx
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rcx)
pushq $0x3
popq %rax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_readline
static int io_readline(lua_State*L){
FILE*f=*(FILE**)lua_touserdata(L,lua_upvalueindex(1));
int sucess;
if(f==NULL)
luaL_error(L,"file is already closed");
sucess=read_line(L,f);
if(ferror(f))
return luaL_error(L,"%s",strerror(errno));
if(sucess)return 1;
else{
if(lua_toboolean(L,lua_upvalueindex(2))){
lua_settop(L,0);
lua_pushvalue(L,lua_upvalueindex(1));
aux_close(L);
}
return 0;
}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0xf128
movq (%rax), %r14
testq %r14, %r14
je 0xf2cf
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf300
movl %eax, %ebp
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
jne 0xf2e0
testl %ebp, %ebp
je 0xf296
pushq $0x1
popq %rbp
jmp 0xf2c8
movq %rbx, %rdi
movl $0xffffd8ec, %esi       # imm = 0xFFFFD8EC
callq 0x9522
xorl %ebp, %ebp
testl %eax, %eax
je 0xf2c8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9c5a
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x8917
movq %rbx, %rdi
callq 0xf047
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3d12(%rip), %rsi      # 0x12fe8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9546
callq 0x3050
movl (%rax), %edi
callq 0x32b0
leaq 0x337c(%rip), %rsi      # 0x1266f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: read_line
static int read_line(lua_State*L,FILE*f){
luaL_Buffer b;
luaL_buffinit(L,&b);
for(;;){
size_t l;
char*p=luaL_prepbuffer(&b);
if(fgets(p,BUFSIZ,f)==NULL){
luaL_pushresult(&b);
return(lua_objlen(L,-1)>0);
}
l=strlen(p);
if(l==0||p[l-1]!='\n')
luaL_addsize(&b,l);
else{
luaL_addsize(&b,l-1);
luaL_pushresult(&b);
return 1;
}
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rdi, -0x8(%rax)
movq %rax, -0x18(%rax)
andl $0x0, -0x10(%rax)
movq %rsp, %r15
movq %r15, %rdi
callq 0xe979
movq %rax, %r12
movq %rax, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdx
callq 0x3140
testq %rax, %rax
je 0xf363
movq %r12, %rdi
callq 0x30e0
testq %rax, %rax
je 0xf35d
cmpb $0xa, -0x1(%r12,%rax)
je 0xf383
addq %rax, (%rsp)
jmp 0xf328
movq %rsp, %rdi
callq 0xe80c
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xe2fc
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0xf394
decq %rax
movq %rsp, %rdi
addq %rax, (%rdi)
callq 0xe80c
pushq $0x1
popq %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: g_read
static int g_read(lua_State*L,FILE*f,int first){
int nargs=lua_gettop(L)-1;
int success;
int n;
clearerr(f);
if(nargs==0){
success=read_line(L,f);
n=first+1;
}
else{
luaL_checkstack(L,nargs+20,"too many arguments");
success=1;
for(n=first;nargs--&&success;n++){
if(lua_type(L,n)==3){
size_t l=(size_t)lua_tointeger(L,n);
success=(l==0)?test_eof(L,f):read_chars(L,f,l);
}
else{
const char*p=lua_tostring(L,n);
luaL_argcheck(L,p&&p[0]=='*',n,"invalid option");
switch(p[1]){
case'n':
success=read_number(L,f);
break;
case'l':
success=read_line(L,f);
break;
case'a':
read_chars(L,f,~((size_t)0));
success=1;
break;
default:
return luaL_argerror(L,n,"invalid format");
}
}
}
}
if(ferror(f))
return pushresult(L,0,NULL);
if(!success){
lua_pop(L,1);
lua_pushnil(L);
}
return n-first;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdi), %r14
subq 0x18(%rdi), %r14
shrq $0x4, %r14
movq %rsi, %rdi
callq 0x3190
movl %r14d, %r15d
decl %r15d
movq %r13, 0x8(%rsp)
je 0xf521
addl $0x13, %r14d
leaq 0x3c15(%rip), %rdx      # 0x12fff
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe997
movq %r12, %r14
pushq $0x1
popq %r12
movl %r13d, %ebp
addl $-0x1, %r15d
jae 0xf536
testl %r12d, %r12d
je 0xf536
movq %rbx, %rdi
movl %ebp, %esi
callq 0x965e
movq %rbx, %rdi
movl %ebp, %esi
cmpl $0x3, %eax
jne 0xf447
callq 0x9ce9
testq %rax, %rax
je 0xf4b5
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf592
jmp 0xf4ee
xorl %edx, %edx
callq 0x3b4c
testq %rax, %rax
je 0xf578
cmpb $0x2a, (%rax)
jne 0xf578
movzbl 0x1(%rax), %eax
cmpl $0x61, %eax
je 0xf4f3
cmpl $0x6c, %eax
je 0xf4e3
cmpl $0x6e, %eax
jne 0xf589
movq %r14, %rdi
leaq 0x3bab(%rip), %rsi      # 0x13030
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x3080
cmpl $0x1, %eax
jne 0xf507
movsd 0x10(%rsp), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
movq 0x10(%rbx), %rax
pushq $0x1
popq %r12
jmp 0xf512
movq %r14, %rdi
callq 0x32c0
movl %eax, %r13d
movl %eax, %edi
movq %r14, %rsi
callq 0x31e0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8937
xorl %r12d, %r12d
cmpl $-0x1, %r13d
setne %r12b
jmp 0xf51a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf300
movl %eax, %r12d
jmp 0xf51a
movq %rbx, %rdi
movq %r14, %rsi
pushq $-0x1
popq %rdx
callq 0xf592
pushq $0x1
popq %r12
jmp 0xf51a
movq 0x10(%rbx), %rax
andl $0x0, 0x8(%rax)
xorl %r12d, %r12d
addq $0x10, %rax
movq %rax, 0x10(%rbx)
incl %ebp
jmp 0xf3ff
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf300
movq %r12, %r14
movl %eax, %r12d
leal 0x1(%r13), %ebp
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0xf552
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf195
movl %eax, %ebp
jmp 0xf567
testl %r12d, %r12d
jne 0xf563
movq 0x10(%rbx), %rax
andl $0x0, -0x8(%rax)
movq %rax, 0x10(%rbx)
subl 0x8(%rsp), %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3a93(%rip), %rdx      # 0x13012
movq %rbx, %rdi
movl %ebp, %esi
callq 0x967a
leaq 0x3a91(%rip), %rdx      # 0x13021
jmp 0xf57f
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: read_chars
static int read_chars(lua_State*L,FILE*f,size_t n){
size_t rlen;
size_t nr;
luaL_Buffer b;
luaL_buffinit(L,&b);
rlen=BUFSIZ;
do{
char*p=luaL_prepbuffer(&b);
if(rlen>n)rlen=n;
nr=fread(p,sizeof(char),rlen,f);
luaL_addsize(&b,nr);
n-=nr;
}while(n>0&&nr==rlen);
luaL_pushresult(&b);
return(n==0||lua_objlen(L,-1)>0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rdi, -0x8(%rax)
movq %rax, -0x18(%rax)
andl $0x0, -0x10(%rax)
movq %rsi, %r15
movl $0x2000, %r12d          # imm = 0x2000
movq %rsp, %r13
pushq $0x1
popq %rbp
movq %r13, %rdi
callq 0xe979
cmpq %r14, %r12
cmovaeq %r14, %r12
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x30a0
addq %rax, (%rsp)
subq %rax, %r14
cmpq %r12, %rax
jne 0xf5fa
testq %r14, %r14
jne 0xf5c9
movq %rsp, %rdi
callq 0xe80c
testq %r14, %r14
je 0xf61f
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xe2fc
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0xf622
pushq $0x1
popq %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: g_write
static int g_write(lua_State*L,FILE*f,int arg){
int nargs=lua_gettop(L)-1;
int status=1;
for(;nargs--;arg++){
if(lua_type(L,arg)==3){
status=status&&
fprintf(f,"%.14g",lua_tonumber(L,arg))>0;
}
else{
size_t l;
const char*s=luaL_checklstring(L,arg,&l);
status=status&&(fwrite(s,sizeof(char),l,f)==l);
}
}
return pushresult(L,status,NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r13
subq 0x18(%rdi), %r13
shrq $0x4, %r13
decl %r13d
pushq $0x1
popq %r15
movq %rsp, %r12
subl $0x1, %r13d
jb 0xf6d5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x965e
cmpl $0x3, %eax
jne 0xf69d
testl %r15d, %r15d
je 0xf6ce
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe1c4
movq %r14, %rdi
leaq 0x301e(%rip), %rsi      # 0x126a9
movb $0x1, %al
callq 0x3170
xorl %r15d, %r15d
testl %eax, %eax
setg %r15b
jmp 0xf6d1
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x9b97
testl %r15d, %r15d
je 0xf6ce
movq (%rsp), %rdx
movq %rax, %rdi
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x32a0
xorl %r15d, %r15d
cmpq (%rsp), %rax
sete %r15b
jmp 0xf6d1
xorl %r15d, %r15d
incl %ebp
jmp 0xf65d
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0xf195
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_lines
static int io_lines(lua_State*L){
if(lua_isnoneornil(L,1)){
lua_rawgeti(L,(-10001),1);
return f_lines(L);
}
else{
const char*filename=luaL_checkstring(L,1);
FILE**pf=newfile(L);
*pf=fopen(filename,"r");
if(*pf==NULL)
fileerror(L,1,filename);
aux_lines(L,lua_gettop(L),1);
return 1;
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x965e
testl %eax, %eax
jle 0xf78d
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9b97
movq %rax, %r14
movq %rbx, %rdi
callq 0xf9fd
movq %rax, %r15
leaq 0x3acb(%rip), %rsi      # 0x1322f
movq %r14, %rdi
callq 0x3240
movq %rax, (%r15)
testq %rax, %rax
je 0xf7ae
movq 0x10(%rbx), %rsi
subq 0x18(%rbx), %rsi
shrq $0x4, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0xf21b
jmp 0xf7a5
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0xe3d0
movq %rbx, %rdi
callq 0xefb5
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfa3d
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_open
static int io_open(lua_State*L){
const char*filename=luaL_checkstring(L,1);
const char*mode=luaL_optstring(L,2,"r");
FILE**pf=newfile(L);
*pf=fopen(filename,mode);
return(*pf==NULL)?pushresult(L,0,filename):1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x9b97
movq %rax, %r14
leaq 0x3a57(%rip), %rdx      # 0x1322f
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x9605
movq %rax, %r15
movq %rbx, %rdi
callq 0xf9fd
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
movq %rax, (%r12)
testq %rax, %rax
je 0xf816
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf195
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x94f6
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf128
movq %rax, %r14
leaq 0x3726(%rip), %rdx      # 0x12fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0xeeed
testq %r14, %r14
je 0xf8cc
movq %rbx, %rdi
callq 0xe272
testl %eax, %eax
je 0xf8cc
pushq $-0x2
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0xf14d
testl %eax, %eax
je 0xf8cc
cmpq $0x0, (%r14)
je 0xf8de
leaq 0x3713(%rip), %rsi      # 0x12fdb
pushq $0x4
jmp 0xf8e7
movq 0x10(%rbx), %rax
andl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
jmp 0xf8f0
leaq 0x36ef(%rip), %rsi      # 0x12fd4
pushq $0xb
popq %rdx
movq %rbx, %rdi
callq 0x8937
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe3d0
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf128
movq (%rax), %rax
testq %rax, %rax
je 0xf945
addq $0x8, %rsp
popq %rbx
popq %r14
retq
decl %r14d
leaq 0x2c51(%rip), %rax      # 0x125a0
movslq (%rax,%r14,4), %rdx
addq %rax, %rdx
leaq 0x36fb(%rip), %rsi      # 0x13058
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x965e
testl %eax, %eax
jle 0xf9e5
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3b4c
testq %rax, %rax
je 0xf9c3
movq %rax, %r12
movq %r14, %rdi
callq 0xf9fd
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x3240
movq %rax, (%r13)
testq %rax, %rax
jne 0xf9d6
movq %r14, %rdi
movq %r12, %rsi
callq 0xfa3d
movq %r14, %rdi
callq 0xf023
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x8917
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebx, %edx
callq 0x3864
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe3d0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rsi
callq 0xe405
movq %rax, %r14
andq $0x0, (%rax)
leaq 0x3597(%rip), %rdx      # 0x12fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0xeeed
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x8c6a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
movq %rsp, %r13
movq %r13, %rdx
callq 0x9b97
movq %rax, %r15
pushq $0x2
popq %rsi
pushq $0x1
popq %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9c2f
movq (%r13), %rcx
incq %rcx
movq %rax, %rbp
sarq $0x3f, %rbp
andq %rcx, %rbp
addq %rax, %rbp
xorl %r14d, %r14d
testq %rbp, %rbp
movl $0x0, %edx
cmovgq %rbp, %rdx
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x9c2f
movq (%r13), %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, %rbp
cmovlq %r12, %rbp
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
cmpq %rbp, %rcx
jae 0xfbcc
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %r14d
subl %ebp, %r14d
incl %r14d
movslq %r14d, %rax
addq %rbp, %rax
cmpq %rcx, %rax
jle 0xfc24
leaq 0x34d7(%rip), %rdx      # 0x130be
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe997
leaq (%r15,%rbp), %rax
decq %rax
movl %r14d, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xfbba
movzbl (%rax,%rdx), %esi
movq 0x10(%rbx), %rdi
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rdi)
movl $0x3, 0x8(%rdi)
addq $0x10, 0x10(%rbx)
incq %rdx
jmp 0xfbfe
leaq 0x3493(%rip), %rsi      # 0x130be
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x4, %rax
leaq 0x18(%rsp), %rcx
movq %rdi, -0x8(%rcx)
movq %rcx, -0x18(%rcx)
andl $0x0, -0x10(%rcx)
xorl %r13d, %r13d
testl %eax, %eax
cmovgl %eax, %r13d
leaq 0x2018(%rsp), %rbp
negl %r13d
pushq $0x1
popq %r14
movq %rsp, %r15
leal (%r14,%r13), %eax
cmpl $0x1, %eax
je 0xfcc6
movq %rbx, %rdi
movl %r14d, %esi
callq 0x9cae
movq %rax, %r12
testl $0xffffff00, %r12d      # imm = 0xFFFFFF00
jne 0xfce3
movq (%rsp), %rax
cmpq %rbp, %rax
jb 0xfcb6
movq %r15, %rdi
callq 0xe979
movq (%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movb %r12b, (%rax)
incl %r14d
jmp 0xfc81
movq %rsp, %rdi
callq 0xe80c
pushq $0x1
popq %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33ea(%rip), %rdx      # 0x130d4
movq %rbx, %rdi
movl %r14d, %esi
callq 0x967a
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x9b97
pushq $0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x9b97
movq %rbx, %rdi
movl %r14d, %esi
callq 0x9c5a
movq 0x10(%rbx), %rax
andq $0x0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
leaq 0x1105(%rip), %rsi      # 0x11328
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x8511
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x9b97
leaq 0x20(%rsp), %rcx
movq %rbx, -0x8(%rcx)
movq %rcx, -0x18(%rcx)
andl $0x0, -0x10(%rcx)
movq %rax, %rbx
leaq 0x2020(%rsp), %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
cmpq (%rsp), %r12
jae 0x106a1
movq 0x8(%rsp), %r13
cmpq %r15, %r13
jb 0x1067f
movq %r14, %rdi
callq 0xe979
movq 0x8(%rsp), %r13
callq 0x32d0
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
movb (%rax,%rcx,4), %al
leaq 0x1(%r13), %rcx
movq %rcx, 0x8(%rsp)
movb %al, (%r13)
incq %r12
jmp 0x10662
leaq 0x8(%rsp), %rdi
callq 0xe80c
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x9b97
movq %rax, %rbx
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x9cae
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %r15, -0x8(%rax)
movq %rax, -0x18(%rax)
andl $0x0, -0x10(%rax)
leaq 0x8(%rsp), %r15
testl %r14d, %r14d
jle 0x10720
decl %r14d
movq (%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe7bc
jmp 0x10707
leaq 0x8(%rsp), %rdi
callq 0xe80c
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x9b97
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x9cae
movq (%r15), %rcx
incq %rcx
movq %rax, %r12
sarq $0x3f, %r12
andq %rcx, %r12
addq %rax, %r12
pushq $0x3
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x9c2f
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
pushq $0x1
popq %rax
cmovgeq %r12, %rax
cmpq %rcx, %rdx
cmovgeq %rcx, %rdx
subq %rax, %rdx
jge 0x107c4
leaq 0x2166(%rip), %rsi      # 0x12923
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x107d1
leaq (%r14,%rax), %rsi
decq %rsi
incq %rdx
movq %rbx, %rdi
callq 0x8937
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x9b97
leaq 0x20(%rsp), %rcx
movq %rbx, -0x8(%rcx)
movq %rcx, -0x18(%rcx)
andl $0x0, -0x10(%rcx)
movq %rax, %rbx
leaq 0x2020(%rsp), %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
cmpq (%rsp), %r12
jae 0x10866
movq 0x8(%rsp), %r13
cmpq %r15, %r13
jb 0x10844
movq %r14, %rdi
callq 0xe979
movq 0x8(%rsp), %r13
callq 0x3030
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
movb (%rax,%rcx,4), %al
leaq 0x1(%r13), %rcx
movq %rcx, 0x8(%rsp)
movb %al, (%r13)
incq %r12
jmp 0x10827
leaq 0x8(%rsp), %rdi
callq 0xe80c
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x18(%rdi), %eax
testl %eax, %eax
pushq $0x1
popq %rbp
cmovnel %eax, %ebp
testq %rsi, %rsi
cmovel %eax, %ebp
movq 0x10(%rdi), %rdi
leaq 0x224c(%rip), %rdx      # 0x13110
movl %ebp, %esi
callq 0xe997
xorl %r12d, %r12d
testl %ebp, %ebp
movl $0x0, %r13d
cmovgl %ebp, %r13d
cmpl %r12d, %r13d
je 0x10ef5
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x11241
incl %r12d
jmp 0x10eda
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10f3f
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 0x10afa
testq %rax, %rax
jne 0x10f3d
decl 0x18(%rbx)
popq %rbx
retq
movq 0x10(%rbx), %rdi
leaq 0x21c6(%rip), %rsi      # 0x13110
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/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 0x10f71
cmpl $0x25, %ecx
jne 0x10fad
cmpb $0x0, (%rax)
je 0x10fc1
addq $0x2, %rsi
movq %rsi, %rax
jmp 0x10fad
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 0x10faf
leaq 0x1(%rax), %rdx
cmpb $0x25, %cl
jne 0x10fa0
cmpb $0x0, 0x1(%rax)
je 0x10fa0
addq $0x2, %rax
movq %rax, %rdx
movq %rdx, %rax
movb (%rdx), %cl
cmpb $0x5d, %cl
jne 0x10f86
incq %rax
popq %rcx
retq
movq 0x10(%rdi), %rdi
leaq 0x21b6(%rip), %rsi      # 0x13170
xorl %eax, %eax
callq 0x9546
movq 0x10(%rdi), %rdi
leaq 0x2181(%rip), %rsi      # 0x1314d
jmp 0x10fba
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %rbx
movl %edi, %ebp
leaq 0x1(%rsi), %r12
cmpb $0x5e, 0x1(%rsi)
sete %r14b
setne %r15b
cmovneq %rsi, %r12
leaq 0x1(%r12), %rax
cmpq %rbx, %rax
jae 0x11042
movzbl 0x1(%r12), %ecx
movzbl 0x2(%r12), %esi
cmpl $0x25, %ecx
jne 0x1101b
addq $0x2, %r12
movl %ebp, %edi
callq 0x110f3
testl %eax, %eax
je 0x10fef
jmp 0x1103f
cmpl $0x2d, %esi
jne 0x11038
addq $0x3, %r12
cmpq %rbx, %r12
jae 0x11038
cmpl %ebp, %ecx
jg 0x10fef
movzbl (%r12), %eax
cmpl %ebp, %eax
jb 0x10fef
jmp 0x1103f
movq %rax, %r12
cmpl %ebp, %ecx
jne 0x10fef
movl %r15d, %r14d
movzbl %r14b, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq