LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaF_findupval
static UpVal*luaF_findupval(lua_State*L,StkId level){
global_State*g=G(L);
GCObject**pp=&L->openupval;
UpVal*p;
UpVal*uv;
while(*pp!=NULL&&(p=ngcotouv(*pp))->v>=level){
if(p->v==level){
if(isdead(g,obj2gco(p)))
changewhite(obj2gco(p));
return p;
}
pp=&p->next;
}
uv=luaM_new(L,UpVal);
uv->tt=(8+2);
uv->marked=luaC_white(g);
uv->v=level;
uv->next=*pp;
*pp=obj2gco(uv);
uv->u.l.prev=&g->uvhead;
uv->u.l.next=g->uvhead.u.l.next;
uv->u.l.next->u.l.prev=uv;
g->uvhead.u.l.next=uv;
return uv;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, 0xf(%rsp)
je 0xb83a
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rax
cmpq 0x30(%rsp), %rax
setae %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xb844
jmp 0xb8a0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x30(%rsp), %rax
jne 0xb891
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
movq 0x28(%rsp), %rcx
movzbl 0x20(%rcx), %ecx
xorl $0x3, %ecx
andl %ecx, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xb882
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %ecx
xorl $0x3, %ecx
movb %cl, 0x9(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xb95c
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xb80c
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x28, %ecx
movq %rdx, %rsi
callq 0x4b30
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movb $0xa, 0x8(%rax)
movq 0x28(%rsp), %rax
movzbl 0x20(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x9(%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
addq $0xb8, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
movq 0xd8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xd8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%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: luaH_get
static const TValue*luaH_get(Table*t,const TValue*key){
switch(ttype(key)){
case 0:return(&luaO_nilobject_);
case 4:return luaH_getstr(t,rawtsvalue(key));
case 3:{
int k;
lua_Number n=nvalue(key);
lua_number2int(k,n);
if(luai_numeq(cast_num(k),nvalue(key)))
return luaH_getnum(t,k);
}
default:{
Node*n=mainposition(t,key);
do{
if(luaO_rawequalObj(key2tval(n),key))
return gval(n);
else n=gnext(n);
}while(n);
return(&luaO_nilobject_);
}
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0xb9a6
jmp 0xb990
movl 0x4(%rsp), %eax
subl $0x3, %eax
je 0xb9d3
jmp 0xb99b
movl 0x4(%rsp), %eax
subl $0x4, %eax
je 0xb9b7
jmp 0xba16
leaq 0x16c2b(%rip), %rax     # 0x225d8
movq %rax, 0x30(%rsp)
jmp 0xba72
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x6c40
movq %rax, 0x30(%rsp)
jmp 0xba72
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
cvttsd2si 0x10(%rsp), %eax
movl %eax, 0x1c(%rsp)
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x20(%rsp), %rax
ucomisd (%rax), %xmm0
jne 0xba14
jp 0xba14
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xbaf0
movq %rax, 0x30(%rsp)
jmp 0xba72
jmp 0xba16
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xbbb0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x20(%rsp), %rsi
callq 0xbd50
cmpl $0x0, %eax
je 0xba4e
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xba72
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xba5e
cmpq $0x0, 0x8(%rsp)
jne 0xba2a
leaq 0x16b6b(%rip), %rax     # 0x225d8
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaT_gettm
static const TValue*luaT_gettm(Table*events,TMS event,TString*ename){
const TValue*tm=luaH_getstr(events,ename);
if(ttisnil(tm)){
events->flags|=cast_byte(1u<<event);
return NULL;
}
else return tm;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6c40
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xbad6
movl 0x14(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movzbl %al, %edx
movq 0x18(%rsp), %rax
movzbl 0xa(%rax), %ecx
orl %edx, %ecx
movb %cl, 0xa(%rax)
movq $0x0, 0x20(%rsp)
jmp 0xbadf
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaH_getnum
static const TValue*luaH_getnum(Table*t,int key){
if(cast(unsigned int,key-1)<cast(unsigned int,t->sizearray))
return&t->array[key-1];
else{
lua_Number nk=cast_num(key);
Node*n=hashnum(t,nk);
do{
if(ttisnumber(gkey(n))&&luai_numeq(nvalue(gkey(n)),nk))
return gval(n);
else n=gnext(n);
}while(n);
return(&luaO_nilobject_);
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
subl $0x1, %eax
movq 0x18(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jae 0xbb2f
movq 0x18(%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)
jmp 0xbb98
cvtsi2sdl 0x14(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0xbe30
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x3, 0x18(%rax)
jne 0xbb77
movq (%rsp), %rax
movsd 0x10(%rax), %xmm0
ucomisd 0x8(%rsp), %xmm0
jne 0xbb77
jp 0xbb77
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xbb98
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
jmp 0xbb85
cmpq $0x0, (%rsp)
jne 0xbb4f
leaq 0x16a45(%rip), %rax     # 0x225d8
movq %rax, 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: mainposition
static Node*mainposition(const Table*t,const TValue*key){
switch(ttype(key)){
case 3:
return hashnum(t,nvalue(key));
case 4:
return hashstr(t,rawtsvalue(key));
case 1:
return hashboolean(t,bvalue(key));
case 2:
return hashpointer(t,pvalue(key));
default:
return hashpointer(t,gcvalue(key));
}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x28(%rsp)
subl $0x3, %eax
ja 0xbced
movq 0x28(%rsp), %rax
leaq 0x1651c(%rip), %rcx     # 0x22100
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
callq 0xbe30
movq %rax, 0x40(%rsp)
jmp 0xbd39
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
movl 0xc(%rcx), %ecx
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq 0x20(%rsp), %rcx
subq $0x1, %rdx
andq %rdx, %rcx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
jmp 0xbd39
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
movslq (%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq 0x38(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq 0x18(%rsp), %rcx
subq $0x1, %rdx
andq %rdx, %rcx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
jmp 0xbd39
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl %eax, %eax
movq 0x38(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
orq $0x1, %rcx
xorl %edx, %edx
divq %rcx
movq 0x10(%rsp), %rax
imulq $0x28, %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
jmp 0xbd39
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl %eax, %eax
movq 0x38(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
orq $0x1, %rcx
xorl %edx, %edx
divq %rcx
movq 0x8(%rsp), %rax
imulq $0x28, %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%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: luaO_rawequalObj
static int luaO_rawequalObj(const TValue*t1,const TValue*t2){
if(ttype(t1)!=ttype(t2))return 0;
else switch(ttype(t1)){
case 0:
return 1;
case 3:
return luai_numeq(nvalue(t1),nvalue(t2));
case 1:
return bvalue(t1)==bvalue(t2);
case 2:
return pvalue(t1)==pvalue(t2);
default:
return gcvalue(t1)==gcvalue(t2);
}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0xbd79
movl $0x0, -0x4(%rsp)
jmp 0xbe26
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x20(%rsp)
subq $0x3, %rax
ja 0xbe0a
movq -0x20(%rsp), %rax
leaq 0x16378(%rip), %rcx     # 0x22110
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rsp)
jmp 0xbe26
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
ucomisd (%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0xbe26
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0xbe26
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0xbe26
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: hashnum
static Node*hashnum(const Table*t,lua_Number n){
unsigned int a[cast_int(sizeof(lua_Number)/sizeof(int))];
int i;
if(luai_numeq(n,0))
return gnode(t,0);
memcpy(a,&n,sizeof(a));
for(i=1;i<cast_int(sizeof(lua_Number)/sizeof(int));i++)a[0]+=a[i];
return hashmod(t,a[0]);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movsd -0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xbe5c
jp 0xbe5c
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xbed9
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x1, -0x24(%rsp)
cmpl $0x2, -0x24(%rsp)
jge 0xbe93
movslq -0x24(%rsp), %rax
movl -0x20(%rsp,%rax,4), %eax
addl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0xbe6e
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rsp)
movl -0x20(%rsp), %eax
movq -0x10(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
orq $0x1, %rcx
xorl %edx, %edx
divq %rcx
movq -0x30(%rsp), %rax
imulq $0x28, %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaH_set
static TValue*luaH_set(lua_State*L,Table*t,const TValue*key){
const TValue*p=luaH_get(t,key);
t->flags=0;
if(p!=(&luaO_nilobject_))
return cast(TValue*,p);
else{
if(ttisnil(key))luaG_runerror(L,"table index is nil");
else if(ttisnumber(key)&&luai_numisnan(nvalue(key)))
luaG_runerror(L,"table index is NaN");
return newkey(L,t,key);
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xb970
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movb $0x0, 0xa(%rax)
leaq 0x166c2(%rip), %rax     # 0x225d8
cmpq %rax, (%rsp)
je 0xbf27
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xbf98
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xbf47
movq 0x18(%rsp), %rdi
leaq 0x16a00(%rip), %rsi     # 0x2293e
movb $0x0, %al
callq 0x54a0
jmp 0xbf7f
movq 0x8(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0xbf7d
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rax
ucomisd (%rax), %xmm0
jne 0xbf6a
jp 0xbf6a
jmp 0xbf7d
movq 0x18(%rsp), %rdi
leaq 0x169db(%rip), %rsi     # 0x22951
movb $0x0, %al
callq 0x54a0
jmp 0xbf7f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xc120
movq %rax, 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: callTM
static void callTM(lua_State*L,const TValue*f,const TValue*p1,
const TValue*p2,const TValue*p3){
setobj(L,L->top,f);
setobj(L,L->top+1,p1);
setobj(L,L->top+2,p2);
setobj(L,L->top+3,p3);
luaD_checkstack(L,4);
L->top+=4;
luaD_call(L,L->top-4,0);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x10, %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 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x30, %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 0x60(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x60(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x40, %rax
jg 0xc0e2
movq 0x60(%rsp), %rdi
movl $0x4, %esi
callq 0x61d0
jmp 0xc0e4
jmp 0xc0e4
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rsi
addq $-0x40, %rsi
xorl %edx, %edx
callq 0x6ce0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: newkey
static TValue*newkey(lua_State*L,Table*t,const TValue*key){
Node*mp=mainposition(t,key);
if(!ttisnil(gval(mp))||mp==(&dummynode_)){
Node*othern;
Node*n=getfreepos(t);
if(n==NULL){
rehash(L,t,key);
return luaH_set(L,t,key);
}
othern=mainposition(t,key2tval(mp));
if(othern!=mp){
while(gnext(othern)!=mp)othern=gnext(othern);
gnext(othern)=n;
*n=*mp;
gnext(mp)=NULL;
setnilvalue(gval(mp));
}
else{
gnext(n)=gnext(mp);
gnext(mp)=n;
mp=n;
}
}
gkey(mp)->value=key->value;gkey(mp)->tt=key->tt;
luaC_barriert(L,t,key);
return gval(mp);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xbbb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xc164
leaq 0x1648f(%rip), %rax     # 0x225e8
cmpq %rax, 0x10(%rsp)
jne 0xc255
movq 0x20(%rsp), %rdi
callq 0xc2d0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xc1ab
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xc330
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xbee0
movq %rax, 0x30(%rsp)
jmp 0xc2bf
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
callq 0xbbb0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0xc22c
jmp 0xc1d1
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
cmpq 0x10(%rsp), %rax
je 0xc1f1
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc1d1
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x28, %edx
callq 0x31c0
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
jmp 0xc253
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xc255
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x18(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jl 0xc2b5
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xc2b5
movq 0x20(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc2b5
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb6d0
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getfreepos
static Node*getfreepos(Table*t){
while(t->lastfree-->t->node){
if(ttisnil(gkey(t->lastfree)))
return t->lastfree;
}
return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq 0x28(%rcx), %rax
movq %rax, %rdx
addq $-0x28, %rdx
movq %rdx, 0x28(%rcx)
movq -0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0xc315
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x18(%rax)
jne 0xc313
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xc31e
jmp 0xc2d5
movq $0x0, -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: rehash
static void rehash(lua_State*L,Table*t,const TValue*ek){
int nasize,na;
int nums[(32-2)+1];
int i;
int totaluse;
for(i=0;i<=(32-2);i++)nums[i]=0;
nasize=numusearray(t,nums);
totaluse=nasize;
totaluse+=numusehash(t,nums,&nasize);
nasize+=countint(ek,nums);
totaluse++;
na=computesizes(nums,&nasize);
resize(L,t,nasize,totaluse-na);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x1e, 0xc(%rsp)
jg 0xc378
movslq 0xc(%rsp), %rax
movl $0x0, 0x10(%rsp,%rax,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xc357
movq 0xa8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc440
movl %eax, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x9c(%rsp), %rdx
callq 0xc540
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc600
addl 0x9c(%rsp), %eax
movl %eax, 0x9c(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x9c(%rsp), %rsi
callq 0xc680
movl %eax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movl 0x9c(%rsp), %edx
movl 0x8(%rsp), %ecx
subl 0x98(%rsp), %ecx
callq 0xc760
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: numusearray
static int numusearray(const Table*t,int*nums){
int lg;
int ttlg;
int ause=0;
int i=1;
for(lg=0,ttlg=1;lg<=(32-2);lg++,ttlg*=2){
int lc=0;
int lim=ttlg;
if(lim>t->sizearray){
lim=t->sizearray;
if(i>lim)
break;
}
for(;i<=lim;i++){
if(!ttisnil(&t->array[i-1]))
lc++;
}
nums[lg]+=lc;
ause+=lc;
}
return ause;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x1, -0x20(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
cmpl $0x1e, -0x14(%rsp)
jg 0xc530
movl $0x0, -0x24(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jle 0xc4b0
movq -0x8(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x28(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x28(%rsp), %eax
jle 0xc4ae
jmp 0xc530
jmp 0xc4b0
jmp 0xc4b2
movl -0x20(%rsp), %eax
cmpl -0x28(%rsp), %eax
jg 0xc4f6
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0xc4e7
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0xc4e9
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0xc4b2
movl -0x24(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rsp), %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
shll %eax
movl %eax, -0x18(%rsp)
jmp 0xc46a
movl -0x1c(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: numusehash
static int numusehash(const Table*t,int*nums,int*pnasize){
int totaluse=0;
int ause=0;
int i=sizenode(t);
while(i--){
Node*n=&t->node[i];
if(!ttisnil(gval(n))){
ause+=countint(key2tval(n),nums);
totaluse++;
}
}
*pnasize+=ause;
return totaluse;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x30(%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 0xc5db
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x14(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0xc5d9
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x28(%rsp), %rsi
callq 0xc600
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xc57c
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%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: countint
static int countint(const TValue*key,int*nums){
int k=arrayindex(key);
if(0<k&&k<=(1<<(32-2))){
nums[ceillog2(k)]++;
return 1;
}
else
return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc9b0
movl %eax, 0xc(%rsp)
xorl %eax, %eax
cmpl 0xc(%rsp), %eax
jge 0xc662
cmpl $0x40000000, 0xc(%rsp)  # imm = 0x40000000
jg 0xc662
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %edi
subl $0x1, %edi
callq 0xca10
movl %eax, %ecx
movq (%rsp), %rax
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl $0x1, 0x24(%rsp)
jmp 0xc66a
movl $0x0, 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: computesizes
static int computesizes(int nums[],int*narray){
int i;
int twotoi;
int a=0;
int na=0;
int n=0;
for(i=0,twotoi=1;twotoi/2<*narray;i++,twotoi*=2){
if(nums[i]>0){
a+=nums[i];
if(a>twotoi/2){
n=twotoi;
na=a;
}
}
if(a==*narray)break;
}
*narray=n;
return na;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc74b
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0xc720
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x18(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rsp), %eax
cmpl %ecx, %eax
jle 0xc71e
movl -0x18(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0xc720
movl -0x1c(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xc72f
jmp 0xc74b
jmp 0xc731
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
shll %eax
movl %eax, -0x18(%rsp)
jmp 0xc6b2
movl -0x24(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x20(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: arrayindex
static int arrayindex(const TValue*key){
if(ttisnumber(key)){
lua_Number n=nvalue(key);
int k;
lua_number2int(k,n);
if(luai_numeq(cast_num(k),n))
return k;
}
return-1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0xc9f5
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rsp)
cvttsd2si -0x18(%rsp), %eax
movl %eax, -0x1c(%rsp)
cvtsi2sdl -0x1c(%rsp), %xmm0
ucomisd -0x18(%rsp), %xmm0
jne 0xc9f3
jp 0xc9f3
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xc9fd
jmp 0xc9f5
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaO_log2
static int luaO_log2(unsigned int x){
static const lu_byte log_2[256]={
0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
};
int l=-1;
while(x>=256){l+=8;x>>=8;}
return l+log_2[x];
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0xffffffff, -0x8(%rsp) # imm = 0xFFFFFFFF
cmpl $0x100, -0x4(%rsp)      # imm = 0x100
jb 0xca3e
movl -0x8(%rsp), %eax
addl $0x8, %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0x4(%rsp)
jmp 0xca1c
movl -0x8(%rsp), %eax
movl -0x4(%rsp), %ecx
movl %ecx, %edx
leaq 0x15bc1(%rip), %rcx     # 0x22610
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: setarrayvector
static void setarrayvector(lua_State*L,Table*t,int size){
int i;
luaM_reallocvector(L,t->array,t->sizearray,size,TValue);
for(i=t->sizearray;i<size;i++)
setnilvalue(&t->array[i]);
t->sizearray=size;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
cltq
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
cmpq %rcx, %rax
ja 0xcaba
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rax
movslq 0x38(%rax), %rdx
shlq $0x4, %rdx
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
callq 0x4b30
movq %rax, 0x8(%rsp)
jmp 0xcac9
movq 0x20(%rsp), %rdi
callq 0x5480
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xcb16
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xcae3
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x38(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: setnodevector
static void setnodevector(lua_State*L,Table*t,int size){
int lsize;
if(size==0){
t->node=cast(Node*,(&dummynode_));
lsize=0;
}
else{
int i;
lsize=ceillog2(size);
if(lsize>(32-2))
luaG_runerror(L,"table overflow");
size=twoto(lsize);
t->node=luaM_newvector(L,size,Node);
for(i=0;i<size;i++){
Node*n=gnode(t,i);
gnext(n)=NULL;
setnilvalue(gkey(n));
setnilvalue(gval(n));
}
}
t->lsizenode=cast_byte(lsize);
t->lastfree=gnode(t,size);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0xcb66
movq 0x28(%rsp), %rax
leaq 0x15a93(%rip), %rcx     # 0x225e8
movq %rcx, 0x20(%rax)
movl $0x0, 0x20(%rsp)
jmp 0xcc5b
movl 0x24(%rsp), %edi
subl $0x1, %edi
callq 0xca10
addl $0x1, %eax
movl %eax, 0x20(%rsp)
cmpl $0x1e, 0x20(%rsp)
jle 0xcb93
movq 0x30(%rsp), %rdi
leaq 0x161bd(%rip), %rsi     # 0x22d49
movb $0x0, %al
callq 0x54a0
movl 0x20(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
cltq
movabsq $0x666666666666666, %rcx # imm = 0x666666666666666
cmpq %rcx, %rax
ja 0xcbde
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rax
imulq $0x28, %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x4b30
movq %rax, 0x8(%rsp)
jmp 0xcbed
movq 0x30(%rsp), %rdi
callq 0x5480
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xcc59
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xcc03
jmp 0xcc5b
movl 0x20(%rsp), %eax
movb %al, %cl
movq 0x28(%rsp), %rax
movb %cl, 0xb(%rax)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rcx
movslq 0x24(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaG_aritherror
static void luaG_aritherror(lua_State*L,const TValue*p1,const TValue*p2){
TValue temp;
if(luaV_tonumber(p1,&temp)==NULL)
p2=p1;
luaG_typeerror(L,p2,"perform arithmetic on");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0xb540
cmpq $0x0, %rax
jne 0xccc0
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x15c93(%rip), %rdx     # 0x22964
callq 0xa800
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: unbound_search
static int unbound_search(Table*t,unsigned int j){
unsigned int i=j;
j++;
while(!ttisnil(luaH_getnum(t,j))){
i=j;
j*=2;
if(j>cast(unsigned int,(INT_MAX-2))){
i=1;
while(!ttisnil(luaH_getnum(t,i)))i++;
return i-1;
}
}
while(j-i>1){
unsigned int m=(i+j)/2;
if(ttisnil(luaH_getnum(t,m)))j=m;
else i=m;
}
return i;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xbaf0
cmpl $0x0, 0x8(%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xcd1d
jmp 0xcd7a
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
shll %eax
movl %eax, 0x14(%rsp)
cmpl $0x7ffffffd, 0x14(%rsp) # imm = 0x7FFFFFFD
jbe 0xcd78
movl $0x1, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xbaf0
cmpl $0x0, 0x8(%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xcd5e
jmp 0xcd6b
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xcd41
movl 0x10(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xcdc7
jmp 0xcd00
jmp 0xcd7c
movl 0x14(%rsp), %eax
subl 0x10(%rsp), %eax
cmpl $0x1, %eax
jbe 0xcdbf
movl 0x10(%rsp), %eax
addl 0x14(%rsp), %eax
shrl %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xbaf0
cmpl $0x0, 0x8(%rax)
jne 0xcdb5
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0xcdbd
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0xcd7c
movl 0x10(%rsp), %eax
movl %eax, 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: get_compTM
static const TValue*get_compTM(lua_State*L,Table*mt1,Table*mt2,
TMS event){
const TValue*tm1=fasttm(L,mt1,event);
const TValue*tm2;
if(tm1==NULL)return NULL;
if(mt1==mt2)return tm1;
tm2=fasttm(L,mt2,event);
if(tm2==NULL)return NULL;
if(luaO_rawequalObj(tm1,tm2))
return tm1;
return NULL;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0xcdf8
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0xce50
movq 0x40(%rsp), %rax
movzbl 0xa(%rax), %eax
movl 0x34(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xce1e
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0xce46
movq 0x40(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x34(%rsp), %ecx
movq 0x128(%rax,%rcx,8), %rdx
callq 0xba80
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xce70
movq $0x0, 0x50(%rsp)
jmp 0xcf37
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0xce8b
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xcf37
cmpq $0x0, 0x38(%rsp)
jne 0xce9c
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xcef1
movq 0x38(%rsp), %rax
movzbl 0xa(%rax), %eax
movl 0x34(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xcec1
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xcee8
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x34(%rsp), %ecx
movq 0x128(%rax,%rcx,8), %rdx
callq 0xba80
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xcf0e
movq $0x0, 0x50(%rsp)
jmp 0xcf37
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xbd50
cmpl $0x0, %eax
je 0xcf2e
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xcf37
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaG_ordererror
static int luaG_ordererror(lua_State*L,const TValue*p1,const TValue*p2){
const char*t1=luaT_typenames[ttype(p1)];
const char*t2=luaT_typenames[ttype(p2)];
if(t1[2]==t2[2])
luaG_runerror(L,"attempt to compare two %s values",t1);
else
luaG_runerror(L,"attempt to compare %s with %s",t1,t2);
return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movslq 0x8(%rax), %rcx
leaq 0x1b8dd(%rip), %rax     # 0x28850
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movslq 0x8(%rax), %rcx
leaq 0x1b8c4(%rip), %rax     # 0x28850
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movsbl 0x2(%rax), %eax
movq (%rsp), %rcx
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0xcfc3
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x159c0(%rip), %rsi     # 0x2297a
movb $0x0, %al
callq 0x54a0
jmp 0xcfdf
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x159c3(%rip), %rsi     # 0x2299b
movb $0x0, %al
callq 0x54a0
xorl %eax, %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: l_strcmp
static int l_strcmp(const TString*ls,const TString*rs){
const char*l=getstr(ls);
size_t ll=ls->tsv.len;
const char*r=getstr(rs);
size_t lr=rs->tsv.len;
for(;;){
int temp=strcoll(l,r);
if(temp!=0)return temp;
else{
size_t len=strlen(l);
if(len==lr)
return(len==ll)?0:1;
else if(len==ll)
return-1;
len++;
l+=len;ll-=len;r+=len;lr-=len;
}
}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3200
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xd05d
movl 0xc(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xd0f8
movq 0x28(%rsp), %rdi
callq 0x30f0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0xd092
movq (%rsp), %rdx
movq 0x20(%rsp), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, 0x44(%rsp)
jmp 0xd0f8
movq (%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0xd0a7
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xd0f8
jmp 0xd0a9
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xd036
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: call_orderTM
static int call_orderTM(lua_State*L,const TValue*p1,const TValue*p2,
TMS event){
const TValue*tm1=luaT_gettmbyobj(L,p1,event);
const TValue*tm2;
if(ttisnil(tm1))return-1;
tm2=luaT_gettmbyobj(L,p2,event);
if(!luaO_rawequalObj(tm1,tm2))
return-1;
callTMres(L,L->top,tm1,p1,p2);
return!l_isfalse(L->top);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0x69e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xd157
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xd203
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0x69e0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xbd50
cmpl $0x0, %eax
jne 0xd18d
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xd203
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x6aa0
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rcx
movb $0x1, %al
cmpl $0x0, 0x8(%rcx)
movb %al, 0xf(%rsp)
je 0xd1f4
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
cmpl $0x1, 0x8(%rcx)
movb %al, 0xe(%rsp)
jne 0xd1ec
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaO_str2d
static int luaO_str2d(const char*s,lua_Number*result){
char*endptr;
*result=lua_str2number(s,&endptr);
if(endptr==s)return 0;
if(*endptr=='x'||*endptr=='X')
*result=cast_num(strtoul(s,&endptr,16));
if(*endptr=='\0')return 1;
while(isspace(cast(unsigned char,*endptr)))endptr++;
if(*endptr!='\0')return 0;
return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x30c0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0xd24f
movl $0x0, 0x24(%rsp)
jmp 0xd316
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
je 0xd269
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x58, %eax
jne 0xd2ad
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x3250
movq %rax, %xmm0
movaps 0x154d7(%rip), %xmm1    # 0x22760
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x154db(%rip), %xmm1    # 0x22770
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xd2c4
movl $0x1, 0x24(%rsp)
jmp 0xd316
jmp 0xd2c6
callq 0x32d0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xd2f7
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xd2c6
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xd30e
movl $0x0, 0x24(%rsp)
jmp 0xd316
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaC_link
static void luaC_link(lua_State*L,GCObject*o,lu_byte tt){
global_State*g=G(L);
o->gch.next=g->rootgc;
g->rootgc=o;
o->gch.marked=luaC_white(g);
o->gch.tt=tt;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x9(%rax)
movb -0x11(%rsp), %cl
movq -0x10(%rsp), %rax
movb %cl, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: singlestep
static l_mem singlestep(lua_State*L){
global_State*g=G(L);
switch(g->gcstate){
case 0:{
markroot(L);
return 0;
}
case 1:{
if(g->gray)
return propagatemark(g);
else{
atomic(L);
return 0;
}
}
case 2:{
lu_mem old=g->totalbytes;
sweepwholelist(L,&g->strt.hash[g->sweepstrgc++]);
if(g->sweepstrgc>=g->strt.size)
g->gcstate=3;
g->estimate-=old-g->totalbytes;
return 10;
}
case 3:{
lu_mem old=g->totalbytes;
g->sweepgc=sweeplist(L,g->sweepgc,40);
if(*g->sweepgc==NULL){
checkSizes(L);
g->gcstate=4;
}
g->estimate-=old-g->totalbytes;
return 40*10;
}
case 4:{
if(g->tmudata){
GCTM(L);
if(g->estimate>100)
g->estimate-=100;
return 100;
}
else{
g->gcstate=0;
g->gcdept=0;
return 0;
}
}
default:return 0;
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl 0x21(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x4, %rax
ja 0xd58f
movq 0x8(%rsp), %rax
leaq 0x14d65(%rip), %rcx     # 0x22120
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsp), %rdi
callq 0xd5b0
movq $0x0, 0x30(%rsp)
jmp 0xd598
movq 0x20(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0xd3fc
movq 0x20(%rsp), %rdi
callq 0xd6d0
movq %rax, 0x30(%rsp)
jmp 0xd598
movq 0x28(%rsp), %rdi
callq 0xd960
movq $0x0, 0x30(%rsp)
jmp 0xd598
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rcx
movl 0x24(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x24(%rcx)
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq $-0x3, %rdx
callq 0xdaa0
movq 0x20(%rsp), %rax
movl 0x24(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jl 0xd46f
movq 0x20(%rsp), %rax
movb $0x3, 0x21(%rax)
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq 0x78(%rax), %rdx
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x80(%rax)
movq $0xa, 0x30(%rsp)
jmp 0xd598
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rsi
movl $0x28, %edx
callq 0xdaa0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, (%rax)
jne 0xd4f5
movq 0x28(%rsp), %rdi
callq 0xdbe0
movq 0x20(%rsp), %rax
movb $0x4, 0x21(%rax)
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
subq 0x78(%rax), %rdx
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x80(%rax)
movq $0x190, 0x30(%rsp)      # imm = 0x190
jmp 0xd598
movq 0x20(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0xd56b
movq 0x28(%rsp), %rdi
callq 0xdcd0
movq 0x20(%rsp), %rax
cmpq $0x64, 0x80(%rax)
jbe 0xd560
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rcx
subq $0x64, %rcx
movq %rcx, 0x80(%rax)
movq $0x64, 0x30(%rsp)
jmp 0xd598
movq 0x20(%rsp), %rax
movb $0x0, 0x21(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x88(%rax)
movq $0x0, 0x30(%rsp)
jmp 0xd598
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: markroot
static void markroot(lua_State*L){
global_State*g=G(L);
g->gray=NULL;
g->grayagain=NULL;
g->weak=NULL;
markobject(g,g->mainthread);
markvalue(g,gt(g->mainthread));
markvalue(g,registry(L));
markmt(g);
g->gcstate=1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xd61c
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rsi
callq 0x51c0
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rax
cmpl $0x4, 0x80(%rax)
jl 0xd667
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rax
movq 0x78(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xd667
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rax
movq 0x78(%rax), %rsi
callq 0x51c0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
cmpl $0x4, 0xa8(%rax)
jl 0xd6af
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0xa0(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xd6af
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0xa0(%rax), %rsi
callq 0x51c0
movq 0x8(%rsp), %rdi
callq 0xdef0
movq 0x8(%rsp), %rax
movb $0x1, 0x21(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: atomic
static void atomic(lua_State*L){
global_State*g=G(L);
size_t udsize;
remarkupvals(g);
propagateall(g);
g->gray=g->weak;
g->weak=NULL;
markobject(g,L);
markmt(g);
propagateall(g);
g->gray=g->grayagain;
g->grayagain=NULL;
propagateall(g);
udsize=luaC_separateudata(L,0);
marktmu(g);
udsize+=propagateall(g);
cleartable(g->weak);
g->currentwhite=cast_byte(otherwhite(g));
g->sweepstrgc=0;
g->sweepgc=&g->rootgc;
g->gcstate=2;
g->estimate=g->totalbytes-udsize;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xe840
movq 0x8(%rsp), %rdi
callq 0xe8f0
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x10(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xd9ca
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x51c0
movq 0x8(%rsp), %rdi
callq 0xdef0
movq 0x8(%rsp), %rdi
callq 0xe8f0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rdi
callq 0xe8f0
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xe930
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xeaf0
movq 0x8(%rsp), %rdi
callq 0xe8f0
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0xeb70
movq 0x8(%rsp), %rax
movzbl 0x20(%rax), %eax
xorl $0x3, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq 0x8(%rsp), %rcx
addq $0x28, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movb $0x2, 0x21(%rax)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rcx
subq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x80(%rax)
addq $0x18, %rsp
retq
nopl (%rax)