LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: check_conflict
static void check_conflict(LexState*ls,struct LHS_assign*lh,expdesc*v){
FuncState*fs=ls->fs;
int extra=fs->freereg;
int conflict=0;
for(;lh;lh=lh->prev){
if(lh->v.k==VINDEXED){
if(lh->v.u.s.info==v->u.s.info){
conflict=1;
lh->v.u.s.info=extra;
}
if(lh->v.u.s.aux==v->u.s.info){
conflict=1;
lh->v.u.s.aux=extra;
}
}
}
if(conflict){
luaK_codeABC(fs,OP_MOVE,fs->freereg,v->u.s.info,0);
luaK_reserveregs(fs,1);
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x4(%rsp)
movl $0x0, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1a0e4
movq 0x18(%rsp), %rax
cmpl $0x9, 0x8(%rax)
jne 0x1a0d3
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1a0ac
movl $0x1, (%rsp)
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1a0d1
movl $0x1, (%rsp)
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x14(%rax)
jmp 0x1a0d3
jmp 0x1a0d5
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x1a074
cmpl $0x0, (%rsp)
je 0x1a119
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %edx
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
xorl %r8d, %r8d
movl %r8d, %esi
callq 0x164d0
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x17170
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getfunc
static void getfunc(lua_State*L,int opt){
if(lua_isfunction(L,1))lua_pushvalue(L,1);
else{
lua_Debug ar;
int level=opt?luaL_optint(L,1,1):luaL_checkint(L,1);
luaL_argcheck(L,level>=0,1,"level must be non-negative");
if(lua_getstack(L,level,&ar)==0)
luaL_argerror(L,1,"invalid level");
lua_getinfo(L,"f",&ar);
if(lua_isnil(L,-1))
luaL_error(L,"no function environment for tail call at level %d",
level);
}
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq 0x90(%rsp), %rdi
movl $0x1, %esi
callq 0x10930
cmpl $0x6, %eax
jne 0x1a2d4
movq 0x90(%rsp), %rdi
movl $0x1, %esi
callq 0xf7f0
jmp 0x1a3cd
cmpl $0x0, 0x8c(%rsp)
je 0x1a2fb
movq 0x90(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x115b0
movl %eax, 0x8(%rsp)
jmp 0x1a311
movq 0x90(%rsp), %rdi
movl $0x1, %esi
callq 0x116e0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
movb $0x1, %al
cmpl $0x0, 0xc(%rsp)
movb %al, 0x7(%rsp)
jge 0x1a349
movq 0x90(%rsp), %rdi
movl $0x1, %esi
leaq 0x8c6f(%rip), %rdx      # 0x22fa9
callq 0x10980
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movq 0x90(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdx
callq 0x10ab0
cmpl $0x0, %eax
jne 0x1a381
movq 0x90(%rsp), %rdi
movl $0x1, %esi
leaq 0x8c48(%rip), %rdx      # 0x22fc4
callq 0x10980
movq 0x90(%rsp), %rdi
leaq 0x9102(%rip), %rsi      # 0x23492
leaq 0x10(%rsp), %rdx
callq 0x10bb0
movq 0x90(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10930
cmpl $0x0, %eax
jne 0x1a3cb
movq 0x90(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0x8c0e(%rip), %rsi      # 0x22fd2
movb $0x0, %al
callq 0x10790
jmp 0x1a3cd
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_tonumber
static lua_Number lua_tonumber(lua_State*L,int idx){
TValue n;
const TValue*o=index2adr(L,idx);
if(tonumber(o,&n))
return nvalue(o);
else
return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xfd90
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x3, 0x8(%rax)
je 0x1a425
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xb540
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1a436
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1a43f
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_setfenv
static int lua_setfenv(lua_State*L,int idx){
StkId o;
int res=1;
api_checknelems(L,1);
o=index2adr(L,idx);
api_checkvalidindex(L,o);
luai_apicheck(L,ttistable(L->top-1));
switch(ttype(o)){
case 6:
clvalue(o)->c.env=hvalue(L->top-1);
break;
case 7:
uvalue(o)->env=hvalue(L->top-1);
break;
case 8:
sethvalue(L,gt(thvalue(o)),hvalue(L->top-1));
break;
default:
res=0;
break;
}
if(res)luaC_objbarrier(L,gcvalue(o),hvalue(L->top-1));
L->top--;
return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xfd90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x6, %eax
je 0x1a501
jmp 0x1a4eb
movl 0xc(%rsp), %eax
subl $0x7, %eax
je 0x1a51c
jmp 0x1a4f6
movl 0xc(%rsp), %eax
subl $0x8, %eax
je 0x1a537
jmp 0x1a56b
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x1a573
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x1a573
movq 0x20(%rsp), %rax
movq (%rax), %rax
addq $0x78, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x5, 0x8(%rax)
jmp 0x1a573
movl $0x0, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x1a5c8
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x1a5c6
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1a5c6
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rdx
callq 0x5150
jmp 0x1a5c8
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_getmetafield
static int luaL_getmetafield(lua_State*L,int obj,const char*event){
if(!lua_getmetatable(L,obj))
return 0;
lua_pushstring(L,event);
lua_rawget(L,-2);
if(lua_isnil(L,-1)){
lua_pop(L,2);
return 0;
}
else{
lua_remove(L,-2);
return 1;
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1a6f0
cmpl $0x0, %eax
jne 0x1a67f
movl $0x0, 0x24(%rsp)
jmp 0x1a6e1
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x36c0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1a210
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10930
cmpl $0x0, %eax
jne 0x1a6ca
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x11600
movl $0x0, 0x24(%rsp)
jmp 0x1a6e1
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1a7e0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_getmetatable
static int lua_getmetatable(lua_State*L,int objindex){
const TValue*obj;
Table*mt=NULL;
int res;
obj=index2adr(L,objindex);
switch(ttype(obj)){
case 5:
mt=hvalue(obj)->metatable;
break;
case 7:
mt=uvalue(obj)->metatable;
break;
default:
mt=G(L)->mt[ttype(obj)];
break;
}
if(mt==NULL)
res=0;
else{
sethvalue(L,L->top,mt);
api_incr_top(L);
res=1;
}
return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xfd90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x5, %eax
je 0x1a737
jmp 0x1a72c
movl 0x4(%rsp), %eax
subl $0x7, %eax
je 0x1a74a
jmp 0x1a75d
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x1a77c
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x1a77c
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq 0xe0(%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1a78e
movl $0x0, 0x14(%rsp)
jmp 0x1a7ce
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x5, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_remove
static void lua_remove(lua_State*L,int idx){
StkId p;
p=index2adr(L,idx);
api_checkvalidindex(L,p);
while(++p<L->top)setobj(L,p-1,p);
L->top--;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xfd90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1a850
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $-0x10, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x1a800
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_objlen
static size_t lua_objlen(lua_State*L,int idx){
StkId o=index2adr(L,idx);
switch(ttype(o)){
case 4:return tsvalue(o)->len;
case 7:return uvalue(o)->len;
case 5:return luaH_getn(hvalue(o));
case 3:{
size_t l;
l=(luaV_tostring(L,o)?tsvalue(o)->len:0);
return l;
}
default:return 0;
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xfd90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x4, %eax
ja 0x1a98f
movq 0x8(%rsp), %rax
leaq 0x7a85(%rip), %rcx      # 0x2238c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1a998
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1a998
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xb020
cltq
movq %rax, 0x30(%rsp)
jmp 0x1a998
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6790
cmpl $0x0, %eax
je 0x1a972
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x1a97a
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x1a97a
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1a998
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
cmpl $0x1f40, 0xc(%rsp)      # imm = 0x1F40
jg 0x1a9f8
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
cmpq $0x1f40, %rax           # imm = 0x1F40
jle 0x1aa05
movl $0x0, 0x8(%rsp)
jmp 0x1aa93
cmpl $0x0, 0xc(%rsp)
jle 0x1aa91
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl 0xc(%rsp), %ecx
shll $0x4, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jg 0x1aa44
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x61d0
jmp 0x1aa46
jmp 0x1aa46
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x1aa8f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movslq 0xc(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x1aa91
jmp 0x1aa93
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xfd90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x18(%rsp), %esi
callq 0xbaf0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_next
static int lua_next(lua_State*L,int idx){
StkId t;
int more;
t=index2adr(L,idx);
luai_apicheck(L,ttistable(t));
more=luaH_next(L,hvalue(t),L->top-1);
if(more){
api_incr_top(L);
}
else
L->top-=1;
return more;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xfd90
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdx
addq $-0x10, %rdx
callq 0x1abf0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1abcd
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
jmp 0x1abde
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaH_next
static int luaH_next(lua_State*L,Table*t,StkId key){
int i=findindex(L,t,key);
for(i++;i<t->sizearray;i++){
if(!ttisnil(&t->array[i])){
setnvalue(key,cast_num(i+1));
setobj(L,key+1,&t->array[i]);
return 1;
}
}
for(i-=t->sizearray;i<(int)sizenode(t);i++){
if(!ttisnil(gval(gnode(t,i)))){
setobj(L,key,key2tval(gnode(t,i)));
setobj(L,key+1,gval(gnode(t,i)));
return 1;
}
}
return 0;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x1ae00
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x50(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x1ace4
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x44(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x1acd2
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x44(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, 0x64(%rsp)
jmp 0x1adeb
jmp 0x1acd4
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x1ac26
movq 0x50(%rsp), %rax
movl 0x38(%rax), %ecx
movl 0x44(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x50(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpl %ecx, %eax
jge 0x1ade3
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x44(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x1add1
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x44(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x44(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, 0x64(%rsp)
jmp 0x1adeb
jmp 0x1add3
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x1acf6
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: findindex
static int findindex(lua_State*L,Table*t,StkId key){
int i;
if(ttisnil(key))return-1;
i=arrayindex(key);
if(0<i&&i<=t->sizearray)
return i-1;
else{
Node*n=mainposition(t,key);
do{
if(luaO_rawequalObj(key2tval(n),key)||
(ttype(gkey(n))==(8+3)&&iscollectable(key)&&
gcvalue(gkey(n))==gcvalue(key))){
i=cast_int(n-gnode(t,0));
return i+t->sizearray;
}
else n=gnext(n);
}while(n);
luaG_runerror(L,"invalid key to "LUA_QL("next"));
return 0;
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1ae2b
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1af1c
movq 0x18(%rsp), %rdi
callq 0xc9b0
movl %eax, 0x14(%rsp)
xorl %eax, %eax
cmpl 0x14(%rsp), %eax
jge 0x1ae5f
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jg 0x1ae5f
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1af1c
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xbbb0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x18(%rsp), %rsi
callq 0xbd50
cmpl $0x0, %eax
jne 0x1aeb4
movq 0x8(%rsp), %rax
cmpl $0xb, 0x18(%rax)
jne 0x1aee5
movq 0x18(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jl 0x1aee5
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x1aee5
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
addl 0x38(%rcx), %eax
movl %eax, 0x34(%rsp)
jmp 0x1af1c
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1aef5
cmpq $0x0, 0x8(%rsp)
jne 0x1ae73
movq 0x28(%rsp), %rdi
leaq 0x816a(%rip), %rsi      # 0x23077
movb $0x0, %al
callq 0x54a0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x70(%rcx), %rax
jb 0x1af64
movq 0x30(%rsp), %rdi
callq 0xa270
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1b190
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x1b0c0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl $0x7, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x28, %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_rawset
static void lua_rawset(lua_State*L,int idx){
StkId t;
api_checknelems(L,2);
t=index2adr(L,idx);
luai_apicheck(L,ttistable(t));
setobj(L,luaH_set(L,hvalue(t),L->top-2),L->top-1);
luaC_barriert(L,hvalue(t),L->top-1);
L->top-=2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xfd90
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdx
addq $-0x20, %rdx
callq 0xbee0
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, -0x8(%rax)
jl 0x1b0a1
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x1b0a1
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1b0a1
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0xb6d0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaS_newudata
static Udata*luaS_newudata(lua_State*L,size_t s,Table*e){
Udata*u;
if(s>((size_t)(~(size_t)0)-2)-sizeof(Udata))
luaM_toobig(L);
u=cast(Udata*,luaM_malloc(L,s+sizeof(Udata)));
u->uv.marked=luaC_white(G(L));
u->uv.tt=7;
u->uv.len=s;
u->uv.metatable=NULL;
u->uv.env=e;
u->uv.next=G(L)->mainthread->next;
G(L)->mainthread->next=obj2gco(u);
return u;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $-0x2b, 0x18(%rsp)
jbe 0x1b0e5
movq 0x20(%rsp), %rdi
callq 0x5480
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
addq $0x28, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x4b30
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movzbl 0x20(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movq 0x8(%rsp), %rax
movb $0x7, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0xb0(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0xb0(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getcurrenv
static Table*getcurrenv(lua_State*L){
if(L->ci==L->base_ci)
return hvalue(gt(L));
else{
Closure*func=curr_func(L);
return func->c.env;
}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x1b1b9
movq -0x10(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1b1dc
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2040(%rsp)
movq 0x2040(%rsp), %rdi
movl $0x2, %esi
leaq 0x78c3(%rip), %rdx      # 0x22ad6
leaq 0x20(%rsp), %rcx
callq 0x10880
movq %rax, 0x10(%rsp)
movq 0x2040(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movq 0x2040(%rsp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x115b0
movl %eax, 0x1c(%rsp)
movq 0x2040(%rsp), %rdi
movl $0x4, %esi
callq 0x10930
cmpl $0x0, %eax
jg 0x1b283
movq 0x2040(%rsp), %rdi
movl $0x1, %esi
callq 0x1a8c0
movl %eax, 0xc(%rsp)
jmp 0x1b299
movq 0x2040(%rsp), %rdi
movl $0x4, %esi
callq 0x116e0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x2040(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b5c0
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x1b2f4
movq 0x2040(%rsp), %rdi
movl 0x1c(%rsp), %edx
leaq 0x28(%rsp), %rsi
callq 0x1b600
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x1b690
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1b2b3
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jne 0x1b314
movq 0x2040(%rsp), %rdi
movl 0x1c(%rsp), %edx
leaq 0x28(%rsp), %rsi
callq 0x1b600
leaq 0x28(%rsp), %rdi
callq 0x1b730
movl $0x1, %eax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
movl %esi, 0x4(%rsp)
movl $0x5, %edx
callq 0x1a1d0
movl 0x4(%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x1a8c0
incl %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x10910
movl %eax, %ecx
movl %ecx, 0x8(%rsp)
subl $0x2, %eax
je 0x1b387
jmp 0x1b37c
movl 0x8(%rsp), %eax
subl $0x3, %eax
je 0x1b394
jmp 0x1b403
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x1b41c
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x116e0
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jle 0x1b3b9
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jle 0x1b401
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %edx
subl $0x1, %edx
movl $0x1, %esi
callq 0x1aaa0
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x1, %esi
callq 0x3720
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b3c1
jmp 0x1b41c
movq 0x18(%rsp), %rdi
leaq 0x7ce0(%rip), %rsi      # 0x230ef
movb $0x0, %al
callq 0x10790
movl %eax, 0x24(%rsp)
jmp 0x1b437
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %edx
movl $0x1, %esi
callq 0x3720
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1a8c0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rdx
movl $0x2, %esi
callq 0x115b0
movl %eax, (%rsp)
movl $0x1, %eax
cmpl (%rsp), %eax
jg 0x1b49a
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jle 0x1b4a4
movl $0x0, 0x14(%rsp)
jmp 0x1b516
movq 0x8(%rsp), %rdi
movl (%rsp), %edx
movl $0x1, %esi
callq 0x1aaa0
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x1b4f1
movq 0x8(%rsp), %rdi
movl (%rsp), %edx
addl $0x1, %edx
movl $0x1, %esi
callq 0x1aaa0
movq 0x8(%rsp), %rdi
movl (%rsp), %edx
movl $0x1, %esi
callq 0x3720
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1b4b6
movq 0x8(%rsp), %rdi
callq 0x11870
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %edx
movl $0x1, %esi
callq 0x3720
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x1a8c0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x28, %esi
leaq 0x7575(%rip), %rdx      # 0x22ad6
callq 0x1b9c0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x10930
cmpl $0x0, %eax
jle 0x1b58e
movq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x1a1d0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11600
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x1, %esi
callq 0x1ba00
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x1, %esi
callq 0x1aaa0
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x11690
cmpl $0x0, %eax
jne 0x1b680
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10930
movq (%rsp), %rdi
movl %eax, %esi
callq 0x11570
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0x14(%rsp), %ecx
leaq 0x7a41(%rip), %rsi      # 0x230ba
movb $0x0, %al
callq 0x10790
movq 0x18(%rsp), %rdi
callq 0x1b760
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rdx
callq 0x3c60
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rdx
movq 0x20(%rsp), %rcx
addq $0x18, %rcx
subq %rcx, %rdx
movl $0x2000, %ecx           # imm = 0x2000
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0x1b7ee
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x31c0
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x11600
jmp 0x1b824
movq 0x20(%rsp), %rdi
callq 0x1b830
cmpl $0x0, %eax
je 0x1b80c
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x118a0
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rdi
callq 0x1b8b0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
addq $0x18, %rcx
subq %rcx, %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1b862
movl $0x0, 0x14(%rsp)
jmp 0x1b8a4
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
movq (%rsp), %rdx
callq 0xf860
movq 0x8(%rsp), %rcx
addq $0x18, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jle 0x1b97c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1a8c0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
callq 0x1a8c0
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
subl 0x14(%rsp), %eax
addl $0x1, %eax
cmpl $0xa, %eax
jge 0x1b92a
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x1b945
movq (%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1b947
jmp 0x1b957
jmp 0x1b949
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x1b8f2
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x11240
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
subl 0x14(%rsp), %ecx
addl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x10930
cmpl $0x0, %eax
je 0x1be06
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0xf7f0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
subl $0x1, %esi
callq 0xf7f0
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
subl $0x2, %esi
callq 0xf7f0
movq 0x18(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xf480
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10720
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x11600
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1be1c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x1be70
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_lessthan
static int lua_lessthan(lua_State*L,int index1,int index2){
StkId o1,o2;
int i;
o1=index2adr(L,index1);
o2=index2adr(L,index2);
i=(o1==(&luaO_nilobject_)||o2==(&luaO_nilobject_))?0
:luaV_lessthan(L,o1,o2);
return i;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xfd90
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0xfd90
movq %rax, 0x8(%rsp)
leaq 0x672a(%rip), %rax      # 0x225d8
cmpq %rax, 0x10(%rsp)
je 0x1bec3
leaq 0x671c(%rip), %rax      # 0x225d8
cmpq %rax, 0x8(%rsp)
jne 0x1beca
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x1bee1
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xb300
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: createmeta
static void createmeta(lua_State*L){
luaL_newmetatable(L,"FILE*");
lua_pushvalue(L,-1);
lua_setfield(L,-2,"__index");
luaL_register(L,NULL,flib);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x7250(%rip), %rsi      # 0x23160
callq 0x1c390
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf7f0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x6a92(%rip), %rdx      # 0x229c5
callq 0x3800
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xcd19(%rip), %rdx      # 0x28c60
callq 0x3600
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x71a6(%rip), %rdx      # 0x23160
callq 0x1c630
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x30e0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c960
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
cmpl $0xffffd8ef, 0x2c(%rsp) # imm = 0xFFFFD8EF
jne 0x1c04e
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x1c04e
movq 0x30(%rsp), %rdi
leaq 0x719c(%rip), %rsi      # 0x231e3
movb $0x0, %al
callq 0x54a0
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xfd90
movq %rax, 0x20(%rsp)
cmpl $0xffffd8ef, 0x2c(%rsp) # imm = 0xFFFFD8EF
jne 0x1c0f4
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, -0x8(%rax)
jl 0x1c0ef
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x1c0ef
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1c0ef
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rdx
callq 0x5150
jmp 0x1c1a9
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
cmpl $0xffffd8ee, 0x2c(%rsp) # imm = 0xFFFFD8EE
jge 0x1c1a7
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, -0x8(%rax)
jl 0x1c1a5
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x1c1a5
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1c1a5
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rdx
callq 0x5150
jmp 0x1c1a7
jmp 0x1c1a9
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x1d6d0
movq (%rsp), %rcx
movq %rcx, (%rax)
cmpl $0x0, 0x14(%rsp)
jle 0x1c24a
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf7f0
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x3720
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf7f0
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1a4b0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x3800
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0xfd90
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x30f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x49c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x4, 0x8(%rax)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x18(%rsp), %rdx
callq 0xa910
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x6e06(%rip), %rdx      # 0x23160
callq 0x1c630
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c960
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_newmetatable
static int luaL_newmetatable(lua_State*L,const char*tname){
lua_getfield(L,(-10000),tname);
if(!lua_isnil(L,-1))
return 0;
lua_pop(L,1);
lua_newtable(L);
lua_pushvalue(L,-1);
lua_setfield(L,(-10000),tname);
return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x1c290
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10930
cmpl $0x0, %eax
je 0x1c3ce
movl $0x0, 0x14(%rsp)
jmp 0x1c415
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x11600
movq 0x8(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3630
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf7f0
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x3800
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x10930
cmpl $-0x1, %eax
jne 0x1c44b
movq (%rsp), %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x2, %edx
callq 0x1aaa0
movq (%rsp), %rdi
callq 0x1c5a0
movq (%rsp), %rdi
callq 0x1c5f0
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x6be6(%rip), %rdx      # 0x23160
callq 0x1c630
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1c599
movq 0x10(%rsp), %rdi
callq 0x1c5f0
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x6ba6(%rip), %rdx      # 0x23160
callq 0x1c630
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1c5e2
movq 0x10(%rsp), %rdi
leaq 0x6b97(%rip), %rsi      # 0x23172
movb $0x0, %al
callq 0x10790
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1c6e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1c6b9
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1a6f0
cmpl $0x0, %eax
je 0x1c6b7
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x1c290
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x1c760
cmpl $0x0, %eax
je 0x1c6b5
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x11600
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c6d5
jmp 0x1c6b7
jmp 0x1c6b9
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x114f0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xfd90
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x2, %eax
je 0x1c731
jmp 0x1c713
movl 0x4(%rsp), %eax
subl $0x7, %eax
jne 0x1c740
jmp 0x1c71e
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq $0x28, %rax
movq %rax, 0x20(%rsp)
jmp 0x1c749
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c749
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xfd90
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0xfd90
movq %rax, 0x8(%rsp)
leaq 0x5e3a(%rip), %rax      # 0x225d8
cmpq %rax, 0x10(%rsp)
je 0x1c7b3
leaq 0x5e2c(%rip), %rax      # 0x225d8
cmpq %rax, 0x8(%rsp)
jne 0x1c7bb
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x1c7ce
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xbd50
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)