LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: sweeplist
static GCObject**sweeplist(lua_State*L,GCObject**p,lu_mem count){
GCObject*curr;
global_State*g=G(L);
int deadmask=otherwhite(g);
while((curr=*p)!=NULL&&count-->0){
if(curr->gch.tt==8)
sweepwholelist(L,&gco2th(curr)->openupval);
if((curr->gch.marked^bit2mask(0,1))&deadmask){
makewhite(g,curr);
p=&curr->gch.next;
}
else{
*p=curr->gch.next;
if(curr==g->rootgc)
g->rootgc=curr->gch.next;
freeobj(L,curr);
}
}
return p;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x20(%rax), %eax
xorl $0x3, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0xb(%rsp)
je 0xdb06
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rsp)
cmpq $0x0, %rax
seta %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0xdb13
jmp 0xdbcd
movq 0x18(%rsp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x8, %eax
jne 0xdb3e
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x98, %rsi
movq $-0x3, %rdx
callq 0xdaa0
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
xorl $0x3, %eax
andl 0xc(%rsp), %eax
cmpl $0x0, %eax
je 0xdb88
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0xf8, %eax
movq 0x10(%rsp), %rcx
movzbl 0x20(%rcx), %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x9(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0xdbc8
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jne 0xdbb9
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xed60
jmp 0xdad1
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: checkSizes
static void checkSizes(lua_State*L){
global_State*g=G(L);
if(g->strt.nuse<cast(lu_int32,g->strt.size/4)&&
g->strt.size>32*2)
luaS_resize(L,g->strt.size/2);
if(luaZ_sizebuffer(&g->buff)>32*2){
size_t newsize=luaZ_sizebuffer(&g->buff)/2;
luaZ_resizebuffer(L,&g->buff,newsize);
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl 0xc(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0xdc44
movq 0x18(%rsp), %rax
cmpl $0x40, 0xc(%rax)
jle 0xdc44
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0xc(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x46d0
movq 0x18(%rsp), %rax
cmpq $0x40, 0x68(%rax)
jbe 0xdcc8
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
shrq %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
cmpq $-0x3, %rax
ja 0xdc9f
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rdx
shlq $0x0, %rdx
movq 0x10(%rsp), %rcx
shlq $0x0, %rcx
callq 0x4b30
movq %rax, (%rsp)
jmp 0xdcad
movq 0x20(%rsp), %rdi
callq 0x5480
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x68(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: GCTM
static void GCTM(lua_State*L){
global_State*g=G(L);
GCObject*o=g->tmudata->gch.next;
Udata*udata=rawgco2u(o);
const TValue*tm;
if(o==g->tmudata)
g->tmudata=NULL;
else
g->tmudata->gch.next=udata->uv.next;
udata->uv.next=g->mainthread->next;
g->mainthread->next=o;
makewhite(g,o);
tm=fasttm(L,udata->uv.metatable,TM_GC);
if(tm!=NULL){
lu_byte oldah=L->allowhook;
lu_mem oldt=g->GCthreshold;
L->allowhook=0;
g->GCthreshold=2*g->totalbytes;
setobj(L,L->top,tm);
setuvalue(L,L->top+1,udata);
L->top+=2;
luaD_call(L,L->top-2,0);
L->allowhook=oldah;
g->GCthreshold=oldt;
}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jne 0xdd21
movq 0x58(%rsp), %rax
movq $0x0, 0x50(%rax)
jmp 0xdd35
movq 0x48(%rsp), %rax
movq (%rax), %rcx
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x58(%rsp), %rax
movq 0xb0(%rax), %rax
movq (%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rcx, (%rax)
movq 0x50(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0xf8, %eax
movq 0x58(%rsp), %rcx
movzbl 0x20(%rcx), %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, %cl
movq 0x50(%rsp), %rax
movb %cl, 0x9(%rax)
movq 0x48(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdd9e
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0xddee
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0xa(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xddbc
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xdde4
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x138(%rax), %rdx
movl $0x2, %esi
callq 0xba80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xdee3
movq 0x60(%rsp), %rax
movb 0x65(%rax), %al
movb %al, 0x3f(%rsp)
movq 0x58(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movb $0x0, 0x65(%rax)
movq 0x58(%rsp), %rax
movq 0x78(%rax), %rcx
shlq %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl $0x7, 0x8(%rax)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rsi
addq $-0x20, %rsi
xorl %edx, %edx
callq 0x6ce0
movb 0x3f(%rsp), %cl
movq 0x60(%rsp), %rax
movb %cl, 0x65(%rax)
movq 0x30(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x70(%rax)
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: traverseclosure
static void traverseclosure(global_State*g,Closure*cl){
markobject(g,cl->c.env);
if(cl->c.isC){
int i;
for(i=0;i<cl->c.nupvalues;i++)
markvalue(g,&cl->c.upvalue[i]);
}
else{
int i;
markobject(g,cl->l.p);
for(i=0;i<cl->l.nupvalues;i++)
markobject(g,cl->l.upvals[i]);
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe2e6
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x51c0
movq 0x8(%rsp), %rax
cmpb $0x0, 0xa(%rax)
je 0xe386
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
cmpl %ecx, %eax
jge 0xe381
movq 0x8(%rsp), %rax
addq $0x28, %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x4, 0x8(%rax)
jl 0xe36f
movq 0x8(%rsp), %rax
addq $0x28, %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe36f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
addq $0x28, %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x51c0
jmp 0xe371
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe2fd
jmp 0xe406
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe3ae
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x51c0
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
cmpl %ecx, %eax
jge 0xe404
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movq 0x28(%rax,%rcx,8), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe3f7
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movq 0x28(%rax,%rcx,8), %rsi
callq 0x51c0
jmp 0xe3f9
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xe3b5
jmp 0xe406
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: traversestack
static void traversestack(global_State*g,lua_State*l){
StkId o,lim;
CallInfo*ci;
markvalue(g,gt(l));
lim=l->top;
for(ci=l->base_ci;ci<=l->ci;ci++){
if(lim<ci->top)lim=ci->top;
}
for(o=l->stack;o<l->top;o++)
markvalue(g,o);
for(;o<=lim;o++)
setnilvalue(o);
checkstacksizes(l,lim);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x4, 0x80(%rax)
jl 0xe454
movq 0x18(%rsp), %rax
movq 0x78(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe454
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x78(%rax), %rsi
callq 0x51c0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x28(%rcx), %rax
ja 0xe4aa
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xe49a
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xe49c
movq (%rsp), %rax
addq $0x28, %rax
movq %rax, (%rsp)
jmp 0xe46f
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xe50b
movq 0x10(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jl 0xe4f9
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe4f9
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x51c0
jmp 0xe4fb
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0xe4b8
jmp 0xe50d
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
ja 0xe535
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0xe50d
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe760
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: traverseproto
static void traverseproto(global_State*g,Proto*f){
int i;
if(f->source)stringmark(f->source);
for(i=0;i<f->sizek;i++)
markvalue(g,&f->k[i]);
for(i=0;i<f->sizeupvalues;i++){
if(f->upvalues[i])
stringmark(f->upvalues[i]);
}
for(i=0;i<f->sizep;i++){
if(f->p[i])
markobject(g,f->p[i]);
}
for(i=0;i<f->sizelocvars;i++){
if(f->locvars[i].varname)
stringmark(f->locvars[i].varname);
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0xe580
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movzbl 0x9(%rax), %ecx
andl $0xfc, %ecx
movb %cl, 0x9(%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x4c(%rcx), %eax
jge 0xe606
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x4, 0x8(%rax)
jl 0xe5f7
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe5f7
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x51c0
jmp 0xe5f9
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe588
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jge 0xe65f
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x4(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xe650
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x9(%rax), %ecx
andl $0xfc, %ecx
movb %cl, 0x9(%rax)
jmp 0xe652
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe60e
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jge 0xe6d5
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xe6c6
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe6c4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x51c0
jmp 0xe6c6
jmp 0xe6c8
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe667
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x5c(%rcx), %eax
jge 0xe73a
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xe72b
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movzbl 0x9(%rax), %ecx
andl $0xfc, %ecx
movb %cl, 0x9(%rax)
jmp 0xe72d
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe6dd
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: checkstacksizes
static void checkstacksizes(lua_State*L,StkId max){
int ci_used=cast_int(L->ci-L->base_ci);
int s_used=cast_int(max-L->stack);
if(L->size_ci>20000)
return;
if(4*ci_used<L->size_ci&&2*8<L->size_ci)
luaD_reallocCI(L,L->size_ci/2);
condhardstacktests(luaD_reallocCI(L,ci_used+1));
if(4*s_used<L->stacksize&&
2*((2*20)+5)<L->stacksize)
luaD_reallocstack(L,L->stacksize/2);
condhardstacktests(luaD_reallocstack(L,s_used));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, (%rsp)
movq 0x10(%rsp), %rax
cmpl $0x4e20, 0x5c(%rax)     # imm = 0x4E20
jle 0xe7b9
jmp 0xe830
movl 0x4(%rsp), %eax
shll $0x2, %eax
movq 0x10(%rsp), %rcx
cmpl 0x5c(%rcx), %eax
jge 0xe7f5
movq 0x10(%rsp), %rcx
movl $0x10, %eax
cmpl 0x5c(%rcx), %eax
jge 0xe7f5
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x5c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x5390
movl (%rsp), %eax
shll $0x2, %eax
movq 0x10(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jge 0xe830
movq 0x10(%rsp), %rcx
movl $0x5a, %eax
cmpl 0x58(%rcx), %eax
jge 0xe830
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x58(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x6550
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: remarkupvals
static void remarkupvals(global_State*g){
UpVal*uv;
for(uv=g->uvhead.u.l.next;uv!=&g->uvhead;uv=uv->u.l.next){
if(isgray(obj2gco(uv)))
markvalue(g,uv->v);
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0xb8, %rcx
cmpq %rcx, %rax
je 0xe8e6
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xe8d1
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xe8d1
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, 0x8(%rax)
jl 0xe8cf
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe8cf
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x51c0
jmp 0xe8d1
jmp 0xe8d3
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xe85a
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaC_separateudata
static size_t luaC_separateudata(lua_State*L,int all){
global_State*g=G(L);
size_t deadmem=0;
GCObject**p=&g->mainthread->next;
GCObject*curr;
while((curr=*p)!=NULL){
if(!(iswhite(curr)||all)||isfinalized(gco2u(curr)))
p=&curr->gch.next;
else if(fasttm(L,gco2u(curr)->metatable,TM_GC)==NULL){
markfinalized(gco2u(curr));
p=&curr->gch.next;
}
else{
deadmem+=sizeudata(gco2u(curr));
markfinalized(gco2u(curr));
*p=curr->gch.next;
if(g->tmudata==NULL)
g->tmudata=curr->gch.next=curr;
else{
curr->gch.next=g->tmudata->gch.next;
g->tmudata->gch.next=curr;
g->tmudata=curr;
}
}
}
return deadmem;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xead8
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xe994
cmpl $0x0, 0x3c(%rsp)
je 0xe9a5
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xe9b4
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xead3
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe9c9
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0xea19
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0xa(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe9e7
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xea0f
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x138(%rax), %rdx
movl $0x2, %esi
callq 0xba80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0xea42
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x9(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xead1
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
addq $0x28, %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x9(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xea9c
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%rax)
jmp 0xeacf
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%rax)
jmp 0xead1
jmp 0xead3
jmp 0xe965
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: marktmu
static void marktmu(global_State*g){
GCObject*u=g->tmudata;
if(u){
do{
u=u->gch.next;
makewhite(g,u);
reallymarkobject(g,u);
}while(u!=g->tmudata);
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xeb68
jmp 0xeb11
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0xf8, %eax
movq 0x10(%rsp), %rcx
movzbl 0x20(%rcx), %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x51c0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jne 0xeb11
jmp 0xeb68
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: cleartable
static void cleartable(GCObject*l){
while(l){
Table*h=gco2h(l);
int i=h->sizearray;
if(testbit(h->marked,4)){
while(i--){
TValue*o=&h->array[i];
if(iscleared(o,0))
setnilvalue(o);
}
}
i=sizenode(h);
while(i--){
Node*n=gnode(h,i);
if(!ttisnil(gval(n))&&
(iscleared(key2tval(n),1)||iscleared(gval(n),0))){
setnilvalue(gval(n));
removeentry(n);
}
}
l=h->gclist;
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xec99
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xebfb
jmp 0xebae
movl 0x14(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rsp)
cmpl $0x0, %eax
je 0xebf9
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xeca0
cmpl $0x0, %eax
je 0xebf7
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
jmp 0xebae
jmp 0xebfb
movq 0x18(%rsp), %rax
movzbl 0xb(%rax), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rsp)
cmpl $0x0, %eax
je 0xec86
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x14(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0xec84
movq (%rsp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0xeca0
cmpl $0x0, %eax
jne 0xec70
movq (%rsp), %rdi
xorl %esi, %esi
callq 0xeca0
cmpl $0x0, %eax
je 0xec84
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rdi
callq 0xe740
jmp 0xec14
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xeb79
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: iscleared
static int iscleared(const TValue*o,int iskey){
if(!iscollectable(o))return 0;
if(ttisstring(o)){
stringmark(rawtsvalue(o));
return 0;
}
return iswhite(gcvalue(o))||
(ttisuserdata(o)&&(!iskey&&isfinalized(uvalue(o))));
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jge 0xecc1
movl $0x0, -0x4(%rsp)
jmp 0xed59
movq -0x10(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jne 0xeceb
movq -0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %ecx
andl $0xfc, %ecx
movb %cl, 0x9(%rax)
movl $0x0, -0x4(%rsp)
jmp 0xed59
movq -0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %ecx
andl $0x3, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rsp)
jne 0xed4c
movq -0x10(%rsp), %rcx
xorl %eax, %eax
cmpl $0x7, 0x8(%rcx)
movb %al, -0x16(%rsp)
jne 0xed44
xorl %eax, %eax
cmpl $0x0, -0x14(%rsp)
movb %al, -0x17(%rsp)
jne 0xed3c
movq -0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x17(%rsp)
movb -0x17(%rsp), %al
movb %al, -0x16(%rsp)
movb -0x16(%rsp), %al
movb %al, -0x15(%rsp)
movb -0x15(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: freeobj
static void freeobj(lua_State*L,GCObject*o){
switch(o->gch.tt){
case(8+1):luaF_freeproto(L,gco2p(o));break;
case 6:luaF_freeclosure(L,gco2cl(o));break;
case(8+2):luaF_freeupval(L,gco2uv(o));break;
case 5:luaH_free(L,gco2h(o));break;
case 8:{
luaE_freethread(L,gco2th(o));
break;
}
case 4:{
G(L)->strt.nuse--;
luaM_freemem(L,o,sizestring(gco2ts(o)));
break;
}
case 7:{
luaM_freemem(L,o,sizeudata(gco2u(o)));
break;
}
default:;
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl 0x8(%rax), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x6, %eax
ja 0xee59
movq (%rsp), %rax
leaq 0x133b4(%rip), %rcx     # 0x22148
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xee60
jmp 0xee5b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xef70
jmp 0xee5b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4fa0
jmp 0xee5b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xeff0
jmp 0xee5b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf090
jmp 0xee5b
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
addq $0x18, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
jmp 0xee5b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
addq $0x28, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
jmp 0xee5b
jmp 0xee5b
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaF_freeproto
static void luaF_freeproto(lua_State*L,Proto*f){
luaM_freearray(L,f->code,f->sizecode,Instruction);
luaM_freearray(L,f->p,f->sizep,Proto*);
luaM_freearray(L,f->k,f->sizek,TValue);
luaM_freearray(L,f->lineinfo,f->sizelineinfo,int);
luaM_freearray(L,f->locvars,f->sizelocvars,struct LocVar);
luaM_freearray(L,f->upvalues,f->sizeupvalues,TString*);
luaM_free(L,f);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rsp), %rax
movslq 0x50(%rax), %rdx
shlq $0x2, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x8(%rsp), %rax
movslq 0x58(%rax), %rdx
shlq $0x3, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rax
movslq 0x4c(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x8(%rsp), %rax
movslq 0x54(%rax), %rdx
shlq $0x2, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x8(%rsp), %rax
movslq 0x5c(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rax
movslq 0x48(%rax), %rdx
shlq $0x3, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x78, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaH_free
static void luaH_free(lua_State*L,Table*t){
if(t->node!=(&dummynode_))
luaM_freearray(L,t->node,sizenode(t),Node);
luaM_freearray(L,t->array,t->sizearray,TValue);
luaM_free(L,t);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
leaq 0x135de(%rip), %rcx     # 0x225e8
cmpq %rcx, 0x20(%rax)
je 0xf040
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x8(%rsp), %rax
movzbl 0xb(%rax), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
imulq $0x28, %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rsp), %rax
movslq 0x38(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x40, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: newlstr
static TString*newlstr(lua_State*L,const char*str,size_t l,
unsigned int h){
TString*ts;
stringtable*tb;
if(l+1>(((size_t)(~(size_t)0)-2)-sizeof(TString))/sizeof(char))
luaM_toobig(L);
ts=cast(TString*,luaM_malloc(L,(l+1)*sizeof(char)+sizeof(TString)));
ts->tsv.len=l;
ts->tsv.hash=h;
ts->tsv.marked=luaC_white(G(L));
ts->tsv.tt=4;
ts->tsv.reserved=0;
memcpy(ts+1,str,l*sizeof(char));
((char*)(ts+1))[l]='\0';
tb=&G(L)->strt;
h=lmod(h,tb->size);
ts->tsv.next=tb->hash[h];
tb->hash[h]=obj2gco(ts);
tb->nuse++;
if(tb->nuse>cast(lu_int32,tb->size)&&tb->size<=(INT_MAX-2)/2)
luaS_resize(L,tb->size*2);
return ts;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
cmpq $-0x1b, %rax
jbe 0xf170
movq 0x30(%rsp), %rdi
callq 0x5480
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
addq $0x1, %rcx
shlq $0x0, %rcx
addq $0x18, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x4b30
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movzbl 0x20(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x9(%rax)
movq 0x10(%rsp), %rax
movb $0x4, 0x8(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0xa(%rax)
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
shlq $0x0, %rdx
callq 0x31c0
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movb $0x0, 0x18(%rax,%rcx)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0xf29a
movq 0x8(%rsp), %rax
cmpl $0x3ffffffe, 0xc(%rax)  # imm = 0x3FFFFFFE
jg 0xf29a
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %esi
shll %esi
callq 0x46d0
movq 0x10(%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: luaC_freeall
static void luaC_freeall(lua_State*L){
global_State*g=G(L);
int i;
g->currentwhite=bit2mask(0,1)|bitmask(6);
sweepwholelist(L,&g->rootgc);
for(i=0;i<g->strt.size;i++)
sweepwholelist(L,&g->strt.hash[i]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x43, 0x20(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x28, %rsi
movq $-0x3, %rdx
callq 0xdaa0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xf332
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movslq 0x4(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq $-0x3, %rdx
callq 0xdaa0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xf2f2
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_pushcclosure
static void lua_pushcclosure(lua_State*L,lua_CFunction fn,int n){
Closure*cl;
luaC_checkGC(L);
api_checknelems(L,n);
cl=luaF_newCclosure(L,n,getcurrenv(L));
cl->c.f=fn;
L->top-=n;
while(n--)
setobj(L,&cl->c.upvalue[n],L->top+n);
setclvalue(L,L->top,cl);
api_incr_top(L);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rax
movq 0x40(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x70(%rcx), %rax
jb 0xf378
movq 0x40(%rsp), %rdi
callq 0xa270
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1b190
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq %rax, %rdx
callq 0x207a0
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x20(%rax)
movl 0x34(%rsp), %edx
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
movslq %edx, %rsi
xorl %edx, %edx
subq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl 0x34(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x34(%rsp)
cmpl $0x0, %eax
je 0xf43e
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x34(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x28, %rax
movslq 0x34(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %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)
jmp 0xf3d6
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x6, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_call
static void lua_call(lua_State*L,int nargs,int nresults){
StkId func;
api_checknelems(L,nargs+1);
checkresults(L,nargs,nresults);
func=L->top-(nargs+1);
luaD_call(L,func,nresults);
adjustresults(L,nresults);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl 0x8(%rsp), %edx
callq 0x6ce0
cmpl $-0x1, 0x8(%rsp)
jne 0xf4fb
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0xf4fb
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaopen_io
static int luaopen_io(lua_State*L){
createmeta(L);
newfenv(L,io_fclose);
lua_replace(L,(-10001));
luaL_register(L,"io",iolib);
newfenv(L,io_noclose);
createstdfile(L,stdin,1,"stdin");
createstdfile(L,stdout,2,"stdout");
createstdfile(L,stderr,0,"stderr");
lua_pop(L,1);
lua_getfield(L,-1,"popen");
newfenv(L,io_pclose);
lua_setfenv(L,-2);
lua_pop(L,1);
return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x1bf00
movq (%rsp), %rdi
leaq 0xca37(%rip), %rsi      # 0x1bfa0
callq 0x1bf50
movq (%rsp), %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x1c010
movq (%rsp), %rdi
leaq 0x13550(%rip), %rsi     # 0x22ad7
leaq 0x19632(%rip), %rdx     # 0x28bc0
callq 0x3600
movq (%rsp), %rdi
leaq 0xcc22(%rip), %rsi      # 0x1c1c0
callq 0x1bf50
movq (%rsp), %rdi
movq 0x19a2a(%rip), %rax     # 0x28fd8
movq (%rax), %rsi
movl $0x1, %edx
leaq 0x13ee9(%rip), %rcx     # 0x234a6
callq 0x1c1f0
movq (%rsp), %rdi
movq 0x19a03(%rip), %rax     # 0x28fd0
movq (%rax), %rsi
movl $0x2, %edx
leaq 0x13b70(%rip), %rcx     # 0x2314c
callq 0x1c1f0
movq (%rsp), %rdi
movq 0x19a0c(%rip), %rax     # 0x28ff8
movq (%rax), %rsi
xorl %edx, %edx
leaq 0x13b5b(%rip), %rcx     # 0x23153
callq 0x1c1f0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x11600
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x13b3f(%rip), %rdx     # 0x2315a
callq 0x1c290
movq (%rsp), %rdi
leaq 0xcd15(%rip), %rsi      # 0x1c340
callq 0x1bf50
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1a4b0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x11600
movl $0x1, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: base_open
static void base_open(lua_State*L){
lua_pushvalue(L,(-10002));
lua_setglobal(L,"_G");
luaL_register(L,"_G",base_funcs);
lua_pushliteral(L,"Lua 5.1");
lua_setglobal(L,"_VERSION");
auxopen(L,"ipairs",luaB_ipairs,ipairsaux);
auxopen(L,"pairs",luaB_pairs,luaB_next);
lua_createtable(L,0,1);
lua_pushvalue(L,-1);
lua_setmetatable(L,-2);
lua_pushliteral(L,"kv");
lua_setfield(L,-2,"__mode");
lua_pushcclosure(L,luaB_newproxy,1);
lua_setglobal(L,"newproxy");
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0xf7f0
movq (%rsp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x133fa(%rip), %rdx     # 0x22add
callq 0x3800
movq (%rsp), %rdi
leaq 0x133ea(%rip), %rsi     # 0x22add
leaq 0x193a6(%rip), %rdx     # 0x28aa0
callq 0x3600
movq (%rsp), %rdi
leaq 0x133d6(%rip), %rsi     # 0x22ae0
movl $0x7, %edx
callq 0xf860
movq (%rsp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x133c4(%rip), %rdx     # 0x22ae8
callq 0x3800
movq (%rsp), %rdi
leaq 0x133bd(%rip), %rsi     # 0x22af1
leaq 0x215(%rip), %rdx       # 0xf950
leaq 0x25e(%rip), %rcx       # 0xf9a0
callq 0xf8f0
movq (%rsp), %rdi
leaq 0x133a0(%rip), %rsi     # 0x22af2
leaq 0x2c7(%rip), %rdx       # 0xfa20
leaq 0x310(%rip), %rcx       # 0xfa70
callq 0xf8f0
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x3630
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf7f0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfae0
movq (%rsp), %rdi
leaq 0x1335c(%rip), %rsi     # 0x22af8
movl $0x2, %edx
callq 0xf860
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x13227(%rip), %rdx     # 0x229dd
callq 0x3800
movq (%rsp), %rdi
leaq 0x47a(%rip), %rsi       # 0xfc40
movl $0x1, %edx
callq 0xf340
movq (%rsp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x1331b(%rip), %rdx     # 0x22afb
callq 0x3800
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_ipairs
static int luaB_ipairs(lua_State*L){
luaL_checktype(L,1,5);
lua_pushvalue(L,lua_upvalueindex(1));
lua_pushvalue(L,1);
lua_pushinteger(L,0);
return 3;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movq (%rsp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0xf7f0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0xf7f0
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1ab20
movl $0x3, %eax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: ipairsaux
static int ipairsaux(lua_State*L){
int i=luaL_checkint(L,2);
luaL_checktype(L,1,5);
i++;
lua_pushinteger(L,i);
lua_rawgeti(L,1,i);
return(lua_isnil(L,-1))?0:2;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x116e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x1ab20
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x1, %esi
callq 0x1aaa0
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10930
movl %eax, %edx
movl $0x2, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_pairs
static int luaB_pairs(lua_State*L){
luaL_checktype(L,1,5);
lua_pushvalue(L,lua_upvalueindex(1));
lua_pushvalue(L,1);
lua_pushnil(L);
return 3;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movq (%rsp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0xf7f0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0xf7f0
movq (%rsp), %rdi
callq 0x11870
movl $0x3, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_next
static int luaB_next(lua_State*L){
luaL_checktype(L,1,5);
lua_settop(L,2);
if(lua_next(L,1))
return 2;
else{
lua_pushnil(L);
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 $0x2, %esi
callq 0x11600
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1ab70
cmpl $0x0, %eax
je 0xfaba
movl $0x2, 0x14(%rsp)
jmp 0xfacc
movq 0x8(%rsp), %rdi
callq 0x11870
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
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_setmetatable
static int lua_setmetatable(lua_State*L,int objindex){
TValue*obj;
Table*mt;
api_checknelems(L,1);
obj=index2adr(L,objindex);
api_checkvalidindex(L,obj);
if(ttisnil(L->top-1))
mt=NULL;
else{
luai_apicheck(L,ttistable(L->top-1));
mt=hvalue(L->top-1);
}
switch(ttype(obj)){
case 5:{
hvalue(obj)->metatable=mt;
if(mt)
luaC_objbarriert(L,hvalue(obj),mt);
break;
}
case 7:{
uvalue(obj)->metatable=mt;
if(mt)
luaC_objbarrier(L,rawuvalue(obj),mt);
break;
}
default:{
G(L)->mt[ttype(obj)]=mt;
break;
}
}
L->top--;
return 1;
}

// 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
cmpl $0x0, -0x8(%rax)
jne 0xfb1a
movq $0x0, 0x8(%rsp)
jmp 0xfb2c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x5, %eax
je 0xfb4d
jmp 0xfb3f
movl 0x4(%rsp), %eax
subl $0x7, %eax
je 0xfba1
jmp 0xfbfa
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x8(%rsp)
je 0xfb9f
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xfb9d
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xfb9d
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0xb6d0
jmp 0xfb9f
jmp 0xfc19
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x8(%rsp)
je 0xfbf8
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xfbf6
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xfbf6
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x5150
jmp 0xfbf8
jmp 0xfc19
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, 0xe0(%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movl $0x1, %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: luaB_newproxy
static int luaB_newproxy(lua_State*L){
lua_settop(L,1);
lua_newuserdata(L,0);
if(lua_toboolean(L,1)==0)
return 1;
else if(lua_isboolean(L,1)){
lua_newtable(L);
lua_pushvalue(L,-1);
lua_pushboolean(L,1);
lua_rawset(L,lua_upvalueindex(1));
}
else{
int validproxy=0;
if(lua_getmetatable(L,1)){
lua_rawget(L,lua_upvalueindex(1));
validproxy=lua_toboolean(L,-1);
lua_pop(L,1);
}
luaL_argcheck(L,validproxy,1,"boolean or proxy expected");
lua_getmetatable(L,1);
}
lua_setmetatable(L,2);
return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x11600
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1af30
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x10720
cmpl $0x0, %eax
jne 0xfc87
movl $0x1, 0x14(%rsp)
jmp 0xfd81
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x10930
cmpl $0x1, %eax
jne 0xfcdb
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
movl $0x1, %esi
callq 0x1a180
movq 0x8(%rsp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x1afe0
jmp 0xfd68
movl $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1a6f0
cmpl $0x0, %eax
je 0xfd28
movq 0x8(%rsp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x1a210
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10720
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x11600
movb $0x1, %al
cmpl $0x0, 0x4(%rsp)
movb %al, 0x3(%rsp)
jne 0xfd55
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13347(%rip), %rdx     # 0x2308d
callq 0x10980
cmpl $0x0, %eax
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1a6f0
jmp 0xfd6a
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0xfae0
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: index2adr
static TValue*index2adr(lua_State*L,int idx){
if(idx>0){
TValue*o=L->base+(idx-1);
luai_apicheck(L,idx<=L->ci->top-L->base);
if(o>=L->top)return cast(TValue*,(&luaO_nilobject_));
else return o;
}
else if(idx>(-10000)){
luai_apicheck(L,idx!=0&&-idx<=L->top-L->base);
return L->top+idx;
}
else switch(idx){
case(-10000):return registry(L);
case(-10001):{
Closure*func=curr_func(L);
sethvalue(L,&L->env,func->c.env);
return&L->env;
}
case(-10002):return gt(L);
default:{
Closure*func=curr_func(L);
idx=(-10002)-idx;
return(idx<=func->c.nupvalues)
?&func->c.upvalue[idx-1]
:cast(TValue*,(&luaO_nilobject_));
}
}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jle 0xfdef
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xfde0
leaq 0x12802(%rip), %rax     # 0x225d8
movq %rax, -0x8(%rsp)
jmp 0xff30
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xff30
cmpl $0xffffd8f0, -0x14(%rsp) # imm = 0xFFFFD8F0
jle 0xfe18
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0xff30
movl -0x14(%rsp), %eax
movl %eax, -0x3c(%rsp)
subl $0xffffd8ee, %eax       # imm = 0xFFFFD8EE
je 0xfeb4
jmp 0xfe2d
movl -0x3c(%rsp), %eax
subl $0xffffd8ef, %eax       # imm = 0xFFFFD8EF
je 0xfe60
jmp 0xfe3a
movl -0x3c(%rsp), %eax
subl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
jne 0xfec4
jmp 0xfe47
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
addq $0xa0, %rax
movq %rax, -0x8(%rsp)
jmp 0xff30
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
addq $0x88, %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rsp), %rax
movq %rcx, (%rax)
movq -0x30(%rsp), %rax
movl $0x5, 0x8(%rax)
movq -0x10(%rsp), %rax
addq $0x88, %rax
movq %rax, -0x8(%rsp)
jmp 0xff30
movq -0x10(%rsp), %rax
addq $0x78, %rax
movq %rax, -0x8(%rsp)
jmp 0xff30
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rsp)
movl $0xffffd8ee, %eax       # imm = 0xFFFFD8EE
subl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x38(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
cmpl %ecx, %eax
jg 0xff18
movq -0x38(%rsp), %rax
addq $0x28, %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rsp)
jmp 0xff26
leaq 0x126b9(%rip), %rax     # 0x225d8
movq %rax, -0x48(%rsp)
jmp 0xff26
movq -0x48(%rsp), %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: luaB_assert
static int luaB_assert(lua_State*L){
luaL_checkany(L,1);
if(!lua_toboolean(L,1))
return luaL_error(L,"%s",luaL_optstring(L,2,"assertion failed!"));
return lua_gettop(L);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x106e0
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x10720
cmpl $0x0, %eax
jne 0xffaa
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x2, %esi
leaq 0x12bce(%rip), %rdx     # 0x22b54
xorl %eax, %eax
movl %eax, %ecx
callq 0x10880
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x12862(%rip), %rsi     # 0x227ff
movb $0x0, %al
callq 0x10790
movl %eax, 0x14(%rsp)
jmp 0xffb8
movq 0x8(%rsp), %rdi
callq 0x10910
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_error
static int luaB_error(lua_State*L){
int level=luaL_optint(L,2,1);
lua_settop(L,1);
if(lua_isstring(L,1)&&level>0){
luaL_where(L,level);
lua_pushvalue(L,1);
lua_concat(L,2);
}
return lua_error(L);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x115b0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11600
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11690
cmpl $0x0, %eax
je 0x10047
cmpl $0x0, 0xc(%rsp)
jle 0x10047
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x11150
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xf7f0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11240
movq 0x10(%rsp), %rdi
callq 0x11330
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)