LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_dischargevars
static void luaK_dischargevars(FuncState*fs,expdesc*e){
switch(e->k){
case VLOCAL:{
e->k=VNONRELOC;
break;
}
case VUPVAL:{
e->u.s.info=luaK_codeABC(fs,OP_GETUPVAL,0,e->u.s.info,0);
e->k=VRELOCABLE;
break;
}
case VGLOBAL:{
e->u.s.info=luaK_codeABx(fs,OP_GETGLOBAL,0,e->u.s.info);
e->k=VRELOCABLE;
break;
}
case VINDEXED:{
freereg(fs,e->u.s.aux);
freereg(fs,e->u.s.info);
e->u.s.info=luaK_codeABC(fs,OP_GETTABLE,0,e->u.s.info,e->u.s.aux);
e->k=VRELOCABLE;
break;
}
case VVARARG:
case VCALL:{
luaK_setoneret(fs,e);
break;
}
default:break;
}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x8, %eax
ja 0xc4f2
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5e9e(%rip), %rcx      # 0x12318
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc673
movl 0x8(%rbx), %ecx
pushq $0x5
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc64e
jmp 0xc4e9
movl $0xc, (%rbx)
jmp 0xc4f2
movl 0x8(%rbx), %ecx
pushq $0x4
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
jmp 0xc4e4
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0xc661
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0xc661
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
pushq $0x6
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc633
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: exp2reg
static void exp2reg(FuncState*fs,expdesc*e,int reg){
discharge2reg(fs,e,reg);
if(e->k==VJMP)
luaK_concat(fs,&e->t,e->u.s.info);
if(hasjumps(e)){
int final;
int p_f=(-1);
int p_t=(-1);
if(need_value(fs,e->t)||need_value(fs,e->f)){
int fj=(e->k==VJMP)?(-1):luaK_jump(fs);
p_f=code_label(fs,reg,0,1);
p_t=code_label(fs,reg,1,0);
luaK_patchtohere(fs,fj);
}
final=luaK_getlabel(fs);
patchlistaux(fs,e->f,final,reg,p_f);
patchlistaux(fs,e->t,final,reg,p_t);
}
e->f=e->t=(-1);
e->u.s.info=reg;
e->k=VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc939
cmpl $0xa, (%rbx)
jne 0xc526
leaq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0xbb74
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %r15d
cmpl %r15d, %esi
je 0xc5d0
movq %r14, %rdi
callq 0xc9f7
testl %eax, %eax
jne 0xc555
movq %r14, %rdi
movl %r15d, %esi
callq 0xc9f7
testl %eax, %eax
je 0xc5ed
cmpl $0xa, (%rbx)
jne 0xc560
pushq $-0x1
popq %r15
jmp 0xc56b
movq %r14, %rdi
callq 0xbbb1
movl %eax, %r15d
pushq $0x1
popq %r12
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
movl %r12d, %ecx
callq 0xca33
movl %eax, %r13d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0xca33
movl %eax, %r12d
movq %r14, %rdi
movl %r15d, %esi
callq 0xbbf3
movl %r13d, %r8d
movl 0x14(%rbx), %r15d
movl 0x30(%r14), %r13d
movl %r13d, 0x34(%r14)
movq %r14, %rdi
movl %r15d, %esi
movl %r13d, %edx
movl %ebp, %ecx
callq 0xc7e6
movl 0x10(%rbx), %esi
movq %r14, %rdi
movl %r13d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0xc7e6
orq $-0x1, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %r12
movl %r12d, %r8d
jmp 0xc5a5
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_exp2nextreg
static void luaK_exp2nextreg(FuncState*fs,expdesc*e){
luaK_dischargevars(fs,e);
freeexp(fs,e);
luaK_reserveregs(fs,1);
exp2reg(fs,e,fs->freereg-1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc45b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcbdf
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xcbed
movl 0x3c(%r14), %edx
decl %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc4fa
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_code
static int luaK_code(FuncState*fs,Instruction i,int line){
Proto*f=fs->f;
dischargejpc(fs);
luaM_growvector(fs->L,f->code,fs->pc,f->sizecode,Instruction,
(INT_MAX-2),"code size overflow");
f->code[fs->pc]=i;
luaM_growvector(fs->L,f->lineinfo,fs->pc,f->sizelineinfo,int,
(INT_MAX-2),"code size overflow");
f->lineinfo[fs->pc]=line;
return fs->pc++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r15
movl 0x38(%rdi), %esi
movl 0x30(%rdi), %edx
movl $0xff, %ecx
movl %edx, %r8d
callq 0xc7e6
orl $-0x1, 0x38(%rbx)
movl 0x30(%rbx), %ecx
cmpl 0x50(%r15), %ecx
jge 0xc6f8
movq 0x18(%r15), %rax
jmp 0xc720
leaq 0x50(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x18(%r15), %rsi
leaq 0x6458(%rip), %r9       # 0x12b63
pushq $0x4
popq %rcx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xc778
movq %rax, 0x18(%r15)
movl 0x30(%rbx), %ecx
movslq %ecx, %rcx
movl %r14d, (%rax,%rcx,4)
movl 0x30(%rbx), %ecx
cmpl 0x54(%r15), %ecx
jge 0xc736
movq 0x28(%r15), %rax
jmp 0xc75e
leaq 0x54(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x28(%r15), %rsi
leaq 0x641a(%rip), %r9       # 0x12b63
pushq $0x4
popq %rcx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xc778
movq %rax, 0x28(%r15)
movl 0x30(%rbx), %ecx
movslq %ecx, %rcx
movl %ebp, (%rax,%rcx,4)
movl 0x30(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaM_growaux_
static void*luaM_growaux_(lua_State*L,void*block,int*size,size_t size_elems,
int limit,const char*errormsg){
void*newblock;
int newsize;
if(*size>=limit/2){
if(*size>=limit)
luaG_runerror(L,errormsg);
newsize=limit;
}
else{
newsize=(*size)*2;
if(newsize<4)
newsize=4;
}
newblock=luaM_reallocv(L,block,*size,newsize,size_elems);
*size=newsize;
return newblock;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %r14d
movq %rdx, %rbx
movslq (%rdx), %r8
movl %r14d, %eax
shrl %eax
cmpl %eax, %r8d
jge 0xc7a0
leal (%r8,%r8), %eax
cmpl $0x5, %eax
pushq $0x4
popq %r14
cmovgel %eax, %r14d
jmp 0xc7a5
cmpl %r14d, %r8d
jge 0xc7dc
leal 0x1(%r14), %r9d
pushq $-0x3
popq %rax
xorl %edx, %edx
divq %rcx
cmpq %r9, %rax
jb 0xc7d7
imulq %rcx, %r8
movl %r14d, %eax
imulq %rcx, %rax
movq %r8, %rdx
movq %rax, %rcx
callq 0x4158
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x44fe
movq %r9, %rsi
xorl %eax, %eax
callq 0x450d
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: patchlistaux
static void patchlistaux(FuncState*fs,int list,int vtarget,int reg,
int dtarget){
while(list!=(-1)){
int next=getjump(fs,list);
if(patchtestreg(fs,list,reg))
fixjump(fs,list,vtarget);
else
fixjump(fs,list,dtarget);
list=next;
}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
cmpl $-0x1, %r12d
je 0xc838
movq %r15, %rdi
movl %r12d, %esi
callq 0xc847
movl %eax, %r13d
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0xc86b
testl %eax, %eax
movl %r14d, %edx
cmovel %ebx, %edx
movq %r15, %rdi
movl %r12d, %esi
callq 0xc8c5
movl %r13d, %r12d
jmp 0xc7ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: patchtestreg
static int patchtestreg(FuncState*fs,int node,int reg){
Instruction*i=getjumpcontrol(fs,node);
if(GET_OPCODE(*i)!=OP_TESTSET)
return 0;
if(reg!=((1<<8)-1)&&reg!=GETARG_B(*i))
SETARG_A(*i,reg);
else
*i=CREATE_ABC(OP_TEST,GETARG_B(*i),0,GETARG_C(*i));
return 1;
}

// Assembly:
pushq %rbx
movl %edx, %ebx
callq 0xc90b
movl (%rax), %edx
movl %edx, %esi
andl $0x3f, %esi
xorl %ecx, %ecx
cmpl $0x1b, %esi
jne 0xc8c1
cmpl $0xff, %ebx
sete %cl
movl %edx, %esi
shrl $0x17, %esi
cmpl %ebx, %esi
sete %sil
orb %cl, %sil
je 0xc8ae
movl %edx, %ecx
shrl $0x11, %ecx
andl $-0x40, %ecx
andl $0x7fc01a, %edx         # imm = 0x7FC01A
orl %ecx, %edx
movl %edx, %ecx
jmp 0xc8bc
andl $0xffffc01b, %edx       # imm = 0xFFFFC01B
movzbl %bl, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
pushq $0x1
popq %rcx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: fixjump
static void fixjump(FuncState*fs,int pc,int dest){
Instruction*jmp=&fs->f->code[pc];
int offset=dest-(pc+1);
if(abs(offset)>(((1<<(9+9))-1)>>1))
luaX_syntaxerror(fs->ls,"control structure too long");
SETARG_sBx(*jmp,offset);
}

// Assembly:
movl %esi, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x20000, %ecx          # imm = 0x20000
jae 0xc8fa
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movslq %esi, %rdx
movl $0x3fff, %esi           # imm = 0x3FFF
andl (%rcx,%rdx,4), %esi
shll $0xe, %eax
addl %esi, %eax
addl $0x7fffc000, %eax       # imm = 0x7FFFC000
movl %eax, (%rcx,%rdx,4)
retq
pushq %rax
movq 0x18(%rdi), %rdi
leaq 0x6270(%rip), %rsi      # 0x12b76
callq 0xb9b8
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: discharge2reg
static void discharge2reg(FuncState*fs,expdesc*e,int reg){
luaK_dischargevars(fs,e);
switch(e->k){
case VNIL:{
luaK_nil(fs,reg,1);
break;
}
case VFALSE:case VTRUE:{
luaK_codeABC(fs,OP_LOADBOOL,reg,e->k==VTRUE,0);
break;
}
case VK:{
luaK_codeABx(fs,OP_LOADK,reg,e->u.s.info);
break;
}
case VKNUM:{
luaK_codeABx(fs,OP_LOADK,reg,luaK_numberK(fs,e->u.nval));
break;
}
case VRELOCABLE:{
Instruction*pc=&getcode(fs,e);
SETARG_A(*pc,reg);
break;
}
case VNONRELOC:{
if(reg!=e->u.s.info)
luaK_codeABC(fs,OP_MOVE,reg,e->u.s.info,0);
break;
}
default:{
return;
}
}
e->u.s.info=reg;
e->k=VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc45b
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0xc9f2
leaq 0x59dd(%rip), %rdx      # 0x1233c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
pushq $0x2
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %r8d, %r8d
callq 0xc633
jmp 0xc9e9
movq (%r14), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rbx), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movzbl %bpl, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
jmp 0xc9e9
movl 0x8(%rbx), %ecx
cmpl %ebp, %ecx
je 0xc9e9
movq %r14, %rdi
xorl %esi, %esi
jmp 0xc976
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0xca48
jmp 0xc9e9
movl 0x8(%rbx), %ecx
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
jmp 0xc9e4
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0xcad0
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
callq 0xc64e
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: need_value
static int need_value(FuncState*fs,int list){
for(;list!=(-1);list=getjump(fs,list)){
Instruction i=*getjumpcontrol(fs,list);
if(GET_OPCODE(i)!=OP_TESTSET)return 1;
}
return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rbx
cmpl $-0x1, %ebp
je 0xca2a
movq %r14, %rdi
movl %ebp, %esi
callq 0xc90b
movl (%rax), %eax
andl $0x3f, %eax
cmpl $0x1b, %eax
jne 0xca2c
movq %r14, %rdi
movl %ebp, %esi
callq 0xc847
movl %eax, %ebp
jmp 0xca03
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_nil
static void luaK_nil(FuncState*fs,int from,int n){
Instruction*previous;
if(fs->pc>fs->lasttarget){
if(fs->pc==0){
if(from>=fs->nactvar)
return;
}
else{
previous=&fs->f->code[fs->pc-1];
if(GET_OPCODE(*previous)==OP_LOADNIL){
int pfrom=GETARG_A(*previous);
int pto=GETARG_B(*previous);
if(pfrom<=from&&from<=pto+1){
if(from+n-1>pto)
SETARG_B(*previous,from+n-1);
return;
}
}
}
}
luaK_codeABC(fs,OP_LOADNIL,from,from+n-1,0);
}

// Assembly:
movl %esi, %eax
movslq 0x30(%rdi), %rcx
cmpl 0x34(%rdi), %ecx
jle 0xcabd
testl %ecx, %ecx
je 0xcab5
movq (%rdi), %rsi
movq 0x18(%rsi), %rsi
movl -0x4(%rsi,%rcx,4), %r8d
movl %r8d, %r9d
andl $0x3f, %r9d
cmpl $0x3, %r9d
jne 0xcabd
movl %r8d, %r9d
shrl $0x6, %r9d
movzbl %r9b, %r10d
movl %r8d, %r9d
shrl $0x17, %r9d
cmpl %eax, %r10d
setg %r10b
leal 0x1(%r9), %r11d
cmpl %eax, %r11d
setl %r11b
orb %r10b, %r11b
jne 0xcabd
addl %edx, %eax
decl %eax
cmpl %r9d, %eax
jle 0xcacf
andl $0x7fffc3, %r8d         # imm = 0x7FFFC3
shll $0x17, %eax
orl %r8d, %eax
movl %eax, -0x4(%rsi,%rcx,4)
jmp 0xcacf
movzbl 0x4a(%rdi), %ecx
cmpl %eax, %ecx
jle 0xcacf
leal (%rax,%rdx), %ecx
decl %ecx
pushq $0x3
popq %rsi
movl %eax, %edx
xorl %r8d, %r8d
jmp 0xc633
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: addk
static int addk(FuncState*fs,TValue*k,TValue*v){
lua_State*L=fs->L;
TValue*idx=luaH_set(L,fs->h,k);
Proto*f=fs->f;
int oldsize=f->sizek;
if(ttisnumber(idx)){
return cast_int(nvalue(idx));
}
else{
setnvalue(idx,cast_num(fs->nk));
luaM_growvector(L,f->k,fs->nk,f->sizek,TValue,
((1<<(9+9))-1),"constant table overflow");
while(oldsize<f->sizek)setnilvalue(&f->k[oldsize++]);
setobj(L,&f->k[fs->nk],v);
luaC_barrier(L,f,v);
return fs->nk++;
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x73a2
cmpl $0x3, 0x8(%rax)
jne 0xcb22
cvttsd2si (%rax), %eax
jmp 0xcbd5
movq (%rbx), %r12
leaq 0x4c(%r12), %rdx
movslq 0x4c(%r12), %r13
cvtsi2sdl 0x40(%rbx), %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
movl (%rdx), %eax
cmpl %eax, 0x40(%rbx)
jl 0xcb6d
movq 0x10(%r12), %rsi
leaq 0x603f(%rip), %r9       # 0x12b91
pushq $0x10
popq %rcx
movq %r14, %rdi
movl $0x3ffff, %r8d          # imm = 0x3FFFF
callq 0xc778
movq %rax, 0x10(%r12)
movl 0x4c(%r12), %eax
movslq %eax, %rcx
movq 0x10(%r12), %rax
movq %r13, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $0x8, %rdx
cmpq %rcx, %r13
jge 0xcb94
incq %r13
andl $0x0, (%rdx)
addq $0x10, %rdx
jmp 0xcb83
movslq 0x40(%rbx), %rcx
shlq $0x4, %rcx
movq (%r15), %rdx
movq %rdx, (%rax,%rcx)
movl 0x8(%r15), %edx
movl %edx, 0x8(%rax,%rcx)
cmpl $0x4, %edx
jl 0xcbcc
movq (%r15), %rdx
testb $0x3, 0x9(%rdx)
je 0xcbcc
testb $0x4, 0x9(%r12)
je 0xcbcc
movq %r14, %rdi
movq %r12, %rsi
callq 0x43bc
movl 0x40(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x40(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_checkstack
static void luaK_checkstack(FuncState*fs,int n){
int newstack=fs->freereg+n;
if(newstack>fs->f->maxstacksize){
if(newstack>=250)
luaX_syntaxerror(fs->ls,"function or expression too complex");
fs->f->maxstacksize=cast_byte(newstack);
}
}

// Assembly:
addl 0x3c(%rdi), %esi
movq (%rdi), %rax
movzbl 0x73(%rax), %ecx
cmpl %ecx, %esi
jle 0xcc21
cmpl $0xfa, %esi
jae 0xcc22
movb %sil, 0x73(%rax)
retq
pushq %rax
movq 0x18(%rdi), %rdi
leaq 0x5f7b(%rip), %rsi      # 0x12ba9
callq 0xb9b8
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_exp2RK
static int luaK_exp2RK(FuncState*fs,expdesc*e){
luaK_exp2val(fs,e);
switch(e->k){
case VKNUM:
case VTRUE:
case VFALSE:
case VNIL:{
if(fs->nk<=((1<<(9-1))-1)){
e->u.s.info=(e->k==VNIL)?nilK(fs):
(e->k==VKNUM)?luaK_numberK(fs,e->u.nval):
boolK(fs,(e->k==VTRUE));
e->k=VK;
return RKASK(e->u.s.info);
}
else break;
}
case VK:{
if(e->u.s.info<=((1<<(9-1))-1))
return RKASK(e->u.s.info);
else break;
}
default:break;
}
return luaK_exp2anyreg(fs,e);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xccf0
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0xcc59
cmpl $0x4, %eax
je 0xcc8e
cmpl $0x5, %eax
jne 0xcc98
cmpl $0xff, 0x40(%r14)
jg 0xcc98
cmpl $0x5, %eax
je 0xccaa
cmpl $0x1, %eax
jne 0xccb9
leaq 0x18(%rsp), %rdx
andl $0x0, 0x8(%rdx)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
movq %r14, %rdi
jmp 0xccd5
movl 0x8(%rbx), %eax
cmpl $0xff, %eax
jle 0xcce3
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xc2b5
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0xcad0
jmp 0xccda
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0xcaf1
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
orl $0x100, %eax            # imm = 0x100
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: primaryexp
static void primaryexp(LexState*ls,expdesc*v){
FuncState*fs=ls->fs;
prefixexp(ls,v);
for(;;){
switch(ls->t.token){
case'.':{
field(ls,v);
break;
}
case'[':{
expdesc key;
luaK_exp2anyreg(fs,v);
yindex(ls,&key);
luaK_indexed(fs,v,&key);
break;
}
case':':{
expdesc key;
luaX_next(ls);
checkname(ls,&key);
luaK_self(fs,v,&key);
funcargs(ls,v);
break;
}
case'(':case TK_STRING:case'{':{
luaK_exp2nextreg(fs,v);
funcargs(ls,v);
break;
}
default:return;
}
}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %r15
movl 0x10(%rdi), %eax
cmpl $0x11d, %eax            # imm = 0x11D
je 0xd268
cmpl $0x28, %eax
jne 0xd373
movl 0x4(%rbx), %ebp
movq %rbx, %rdi
callq 0xa1e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc52
pushq $0x29
popq %rsi
pushq $0x28
popq %rdx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0xba95
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xc45b
jmp 0xd273
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd956
movq %rsp, %r12
movl 0x10(%rbx), %eax
cmpl $0x28, %eax
je 0xd2ae
cmpl $0x11e, %eax            # imm = 0x11E
je 0xd2ae
cmpl $0x3a, %eax
je 0xd2bb
cmpl $0x5b, %eax
je 0xd33b
cmpl $0x7b, %eax
je 0xd2ae
cmpl $0x2e, %eax
jne 0xd364
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7b2
jmp 0xd276
movq %r15, %rdi
movq %r14, %rsi
callq 0xc5f6
jmp 0xd32b
movq %rbx, %rdi
callq 0xa1e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd572
movq %r15, %rdi
movq %r14, %rsi
callq 0xc2b5
movq %r15, %rdi
movq %r14, %rsi
callq 0xcbdf
movl 0x3c(%r15), %ebp
movq %r15, %rdi
pushq $0x2
popq %rsi
callq 0xcbed
movl 0x8(%r14), %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0xcc33
movq %r15, %rdi
pushq $0xb
popq %rsi
movl %ebp, %edx
movl %r13d, %ecx
movl %eax, %r8d
callq 0xc633
movq %r15, %rdi
movq %r12, %rsi
callq 0xcbdf
movl %ebp, 0x8(%r14)
movl $0xc, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd816
jmp 0xd276
movq %r15, %rdi
movq %r14, %rsi
callq 0xc2b5
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd596
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xd7ff
jmp 0xd276
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5915(%rip), %rsi      # 0x12c8f
movq %rbx, %rdi
callq 0xb9b8
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: listfield
static void listfield(LexState*ls,struct ConsControl*cc){
expr(ls,&cc->v);
luaY_checklimit(ls->fs,cc->na,(INT_MAX-2),"items in a constructor");
cc->na++;
cc->tostore++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbc52
movl 0x24(%rbx), %eax
cmpl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
jge 0xd3cb
incl %eax
movl %eax, 0x24(%rbx)
incl 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x30(%r14), %rdi
leaq 0x5821(%rip), %rdx      # 0x12bf7
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0xd52a
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: recfield
static void recfield(LexState*ls,struct ConsControl*cc){
FuncState*fs=ls->fs;
int reg=ls->fs->freereg;
expdesc key,val;
int rkkey;
if(ls->t.token==TK_NAME){
luaY_checklimit(fs,cc->nh,(INT_MAX-2),"items in a constructor");
checkname(ls,&key);
}
else
yindex(ls,&key);
cc->nh++;
checknext(ls,'=');
rkkey=luaK_exp2RK(fs,&key);
expr(ls,&val);
luaK_codeABC(fs,OP_SETTABLE,cc->t->u.s.info,rkkey,luaK_exp2RK(fs,&val));
fs->freereg=reg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rbx
movl 0x3c(%rbx), %r13d
cmpl $0x11d, 0x10(%rdi)      # imm = 0x11D
jne 0xd422
cmpl $0x7ffffffe, 0x20(%r14) # imm = 0x7FFFFFFE
jge 0xd496
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xd572
jmp 0xd42f
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xd596
incl 0x20(%r14)
pushq $0x3d
popq %rsi
movq %r15, %rdi
callq 0xbc40
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xcc33
movl %eax, %ebp
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xbc52
movq 0x18(%r14), %rax
movl 0x8(%rax), %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xcc33
pushq $0x9
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
movl %ebp, %ecx
movl %eax, %r8d
callq 0xc633
movl %r13d, 0x3c(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x575a(%rip), %rdx      # 0x12bf7
movq %rbx, %rdi
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0xd52a
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaO_int2fb
static int luaO_int2fb(unsigned int x){
int e=0;
while(x>=16){
x=(x+1)>>1;
e++;
}
if(x<8)return x;
else return((e+1)<<3)|(cast_int(x)-8);
}

// Assembly:
pushq $0x8
popq %rax
cmpl $0x10, %edi
jb 0xd4bb
incl %edi
shrl %edi
addl $0x8, %eax
jmp 0xd4ad
leal -0x8(%rdi), %ecx
orl %ecx, %eax
cmpl $0x8, %edi
cmovbl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_setlist
static void luaK_setlist(FuncState*fs,int base,int nelems,int tostore){
int c=(nelems-1)/50+1;
int b=(tostore==(-1))?0:tostore;
if(c<=((1<<9)-1))
luaK_codeABC(fs,OP_SETLIST,base,b,c);
else{
luaK_codeABC(fs,OP_SETLIST,base,b,0);
luaK_code(fs,cast(Instruction,c),fs->ls->lastline);
}
fs->freereg=base+1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %r8d
movl %edx, %r9d
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%r9), %eax
pushq $0x32
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
incl %ebp
xorl %ecx, %ecx
cmpl $-0x1, %r8d
cmovnel %r8d, %ecx
pushq $0x22
popq %rsi
movl %ebx, %edx
cmpl $0x63ce, %r9d           # imm = 0x63CE
jg 0xd506
movl %ebp, %r8d
callq 0xc633
jmp 0xd51f
xorl %r8d, %r8d
callq 0xc633
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0xc6c0
incl %ebx
movl %ebx, 0x3c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: errorlimit
static void errorlimit(FuncState*fs,int limit,const char*what){
const char*msg=(fs->f->linedefined==0)?
luaO_pushfstring(fs->L,"main function has more than %d %s",limit,what):
luaO_pushfstring(fs->L,"function at line %d has more than %d %s",
fs->f->linedefined,limit,what);
luaX_lexerror(fs->ls,msg,0);
}

// Assembly:
pushq %rbx
movq %rdx, %r8
movl %esi, %ecx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rdi), %rdi
movl 0x60(%rax), %edx
testl %edx, %edx
jne 0xd556
leaq 0x56c6(%rip), %rsi      # 0x12c0e
movl %ecx, %edx
movq %r8, %rcx
xorl %eax, %eax
callq 0x4a89
jmp 0xd564
leaq 0x56d3(%rip), %rsi      # 0x12c30
xorl %eax, %eax
callq 0x4a89
movq 0x18(%rbx), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xb6bb
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: yindex
static void yindex(LexState*ls,expdesc*v){
luaX_next(ls);
expr(ls,v);
luaK_exp2val(ls->fs,v);
checknext(ls,']');
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa1e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbc52
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0xccf0
pushq $0x5d
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbc40
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_checkname
static TString*str_checkname(LexState*ls){
TString*ts;
check(ls,TK_NAME);
ts=ls->t.seminfo.ts;
luaX_next(ls);
return ts;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x11d, %esi            # imm = 0x11D
callq 0xaaf9
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0xa1e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_setreturns
static void luaK_setreturns(FuncState*fs,expdesc*e,int nresults){
if(e->k==VCALL){
SETARG_C(getcode(fs,e),nresults+1);
}
else if(e->k==VVARARG){
SETARG_B(getcode(fs,e),nresults+1);
SETARG_A(getcode(fs,e),fs->freereg);
luaK_reserveregs(fs,1);
}
}

// Assembly:
movl (%rsi), %eax
cmpl $0xe, %eax
je 0xd62a
cmpl $0xd, %eax
jne 0xd629
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0xff803fff, %esi       # imm = 0xFF803FFF
andl (%rax,%rcx,4), %esi
shll $0xe, %edx
addl $0x4000, %edx           # imm = 0x4000
andl $0x7fc000, %edx         # imm = 0x7FC000
orl %esi, %edx
movl %edx, (%rax,%rcx,4)
retq
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %r8d         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %r8d
shll $0x17, %edx
addl %r8d, %edx
addl $0x800000, %edx         # imm = 0x800000
movl %edx, (%rax,%rcx,4)
movslq 0x8(%rsi), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movl 0x3c(%rdi), %esi
movzbl %sil, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
pushq $0x1
popq %rsi
jmp 0xcbed
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: adjustlocalvars
static void adjustlocalvars(LexState*ls,int nvars){
FuncState*fs=ls->fs;
fs->nactvar=cast_byte(fs->nactvar+nvars);
for(;nvars;nvars--){
getlocvar(fs,fs->nactvar-nvars).startpc=fs->pc;
}
}

// Assembly:
movq 0x30(%rdi), %rax
movb 0x4a(%rax), %dl
addb %sil, %dl
movb %dl, 0x4a(%rax)
movslq %esi, %rcx
negq %rcx
movzbl %dl, %edx
leaq (%rax,%rdx,2), %rdx
addq $0xc4, %rdx
testq %rcx, %rcx
je 0xd7b1
movl 0x30(%rax), %esi
movq (%rax), %rdi
movq 0x30(%rdi), %rdi
movzwl (%rdx,%rcx,2), %r8d
shll $0x4, %r8d
movl %esi, 0x8(%rdi,%r8)
incq %rcx
jmp 0xd78f
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: field
static void field(LexState*ls,expdesc*v){
FuncState*fs=ls->fs;
expdesc key;
luaK_exp2anyreg(fs,v);
luaX_next(ls);
checkname(ls,&key);
luaK_indexed(fs,v,&key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0xc2b5
movq %r14, %rdi
callq 0xa1e0
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xd572
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xd7ff
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: funcargs
static void funcargs(LexState*ls,expdesc*f){
FuncState*fs=ls->fs;
expdesc args;
int base,nparams;
int line=ls->linenumber;
switch(ls->t.token){
case'(':{
if(line!=ls->lastline)
luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
luaX_next(ls);
if(ls->t.token==')')
args.k=VVOID;
else{
explist1(ls,&args);
luaK_setmultret(fs,&args);
}
check_match(ls,')','(',line);
break;
}
case'{':{
constructor(ls,&args);
break;
}
case TK_STRING:{
codestring(ls,&args,ls->t.seminfo.ts);
luaX_next(ls);
break;
}
default:{
luaX_syntaxerror(ls,"function arguments expected");
return;
}
}
base=f->u.s.info;
if(hasmultret(args.k))
nparams=(-1);
else{
if(args.k!=VVOID)
luaK_exp2nextreg(fs,&args);
nparams=fs->freereg-(base+1);
}
init_exp(f,VCALL,luaK_codeABC(fs,OP_CALL,base,nparams+1,2));
luaK_fixline(fs,line);
fs->freereg=base+1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rbx
movl 0x4(%rdi), %ebp
movl 0x10(%rdi), %eax
cmpl $0x11e, %eax            # imm = 0x11E
je 0xd876
cmpl $0x7b, %eax
je 0xd867
cmpl $0x28, %eax
jne 0xd93e
cmpl 0x8(%r15), %ebp
jne 0xd947
movq %r15, %rdi
callq 0xa1e0
cmpl $0x29, 0x10(%r15)
jne 0xd8a2
andl $0x0, 0x8(%rsp)
jmp 0xd8c0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xcda9
jmp 0xd8d0
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0xd382
orq $-0x1, 0x18(%rsp)
movl $0x4, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movq %r15, %rdi
callq 0xa1e0
movl 0x8(%r14), %r15d
jmp 0xd8e6
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xdb41
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd5f6
pushq $0x29
popq %rsi
pushq $0x28
popq %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0xba95
movl 0x8(%rsp), %eax
movl 0x8(%r14), %r15d
leal -0xd(%rax), %edx
xorl %ecx, %ecx
cmpl $0x2, %edx
jb 0xd8f9
testl %eax, %eax
je 0xd8f3
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc5f6
movl 0x3c(%rbx), %ecx
subl %r15d, %ecx
pushq $0x1c
popq %rsi
pushq $0x2
popq %r8
movq %rbx, %rdi
movl %r15d, %edx
callq 0xc633
orq $-0x1, 0x10(%r14)
movl $0xd, (%r14)
movl %eax, 0x8(%r14)
movq (%rbx), %rax
movq 0x28(%rax), %rax
movslq 0x30(%rbx), %rcx
movl %ebp, -0x4(%rax,%rcx,4)
incl %r15d
movl %r15d, 0x3c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5396(%rip), %rsi      # 0x12cdb
jmp 0xd94e
leaq 0x535c(%rip), %rsi      # 0x12caa
movq %r15, %rdi
callq 0xb9b8
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: singlevar
static void singlevar(LexState*ls,expdesc*var){
TString*varname=str_checkname(ls);
FuncState*fs=ls->fs;
if(singlevaraux(fs,varname,var,1)==VGLOBAL)
var->u.s.info=luaK_stringK(fs,varname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0xd5ce
movq %rax, %r14
movq 0x30(%r15), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xd997
cmpl $0x8, %eax
jne 0xd991
movq %r15, %rdi
movq %r14, %rsi
callq 0xd382
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: singlevaraux
static int singlevaraux(FuncState*fs,TString*n,expdesc*var,int base){
if(fs==NULL){
init_exp(var,VGLOBAL,((1<<8)-1));
return VGLOBAL;
}
else{
int v=searchvar(fs,n);
if(v>=0){
init_exp(var,VLOCAL,v);
if(!base)
markupval(fs,v);
return VLOCAL;
}
else{
if(singlevaraux(fs->prev,n,var,0)==VGLOBAL)
return VGLOBAL;
var->u.s.info=indexupvalue(fs,n,var);
var->k=VUPVAL;
return VUPVAL;
}
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
testq %rdi, %rdi
je 0xda12
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x4a(%rdi), %edx
testq %rdx, %rdx
jle 0xda28
movq (%rbx), %rax
movq 0x30(%rax), %rax
movzwl 0xc2(%rbx,%rdx,2), %esi
decq %rdx
shll $0x4, %esi
cmpq %r15, (%rax,%rsi)
jne 0xd9b2
orq $-0x1, 0x10(%r14)
movl $0x6, (%r14)
movl %edx, 0x8(%r14)
pushq $0x6
popq %rax
testl %ecx, %ecx
jne 0xdb25
incq %rdx
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xdb25
movzbl 0xc(%rbx), %ecx
cmpq %rcx, %rdx
jle 0xd9f4
movb $0x1, 0xd(%rbx)
jmp 0xdb25
orq $-0x1, 0x10(%r14)
movl $0x8, (%r14)
movl $0xff, 0x8(%r14)
jmp 0xda3e
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xd997
cmpl $0x8, %eax
jne 0xda45
pushq $0x8
jmp 0xdb24
movq (%rbx), %r12
leaq 0x48(%r12), %rdx
movl 0x48(%r12), %eax
movslq %eax, %r13
movzbl 0x70(%r12), %ecx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xda80
movzbl 0x4b(%rbx,%rsi,2), %edi
cmpl %edi, (%r14)
jne 0xda7b
movzbl 0x4c(%rbx,%rsi,2), %edi
cmpl %edi, 0x8(%r14)
je 0xdb17
incq %rsi
jmp 0xda5d
cmpb $0x3c, %cl
jae 0xdb2f
cmpl %ecx, %eax
jg 0xdab5
movq 0x20(%rbx), %rdi
movq 0x38(%r12), %rsi
leaq 0x4e86(%rip), %r9       # 0x12923
pushq $0x8
popq %rcx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xc778
movq %rax, 0x38(%r12)
movl 0x48(%r12), %eax
cltq
movq 0x38(%r12), %rdx
cmpq %rax, %r13
jge 0xdacb
andq $0x0, (%rdx,%r13,8)
incq %r13
jmp 0xdab7
movzbl 0x70(%r12), %ecx
movl %ecx, %eax
movq %r15, (%rdx,%rcx,8)
testb $0x3, 0x9(%r15)
je 0xdafd
testb $0x4, 0x9(%r12)
je 0xdafd
movq 0x20(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x43bc
movb 0x70(%r12), %al
movzbl %al, %ecx
movb (%r14), %dl
movb %dl, 0x4b(%rbx,%rcx,2)
movb 0x8(%r14), %dl
movb %dl, 0x4c(%rbx,%rcx,2)
leal 0x1(%rax), %ecx
movb %cl, 0x70(%r12)
movzbl %al, %esi
movl %esi, 0x8(%r14)
movl $0x7, (%r14)
pushq $0x7
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x516b(%rip), %rdx      # 0x12ca1
pushq $0x3c
popq %rsi
movq %rbx, %rdi
callq 0xd52a
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: explist1
static int explist1(LexState*ls,expdesc*v){
int n=1;
expr(ls,v);
while(testnext(ls,',')){
luaK_exp2nextreg(ls->fs,v);
expr(ls,v);
n++;
}
return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbc52
pushq $0x1
popq %rbp
pushq $0x2c
popq %r15
movq %r14, %rdi
movl %r15d, %esi
callq 0xba44
testl %eax, %eax
je 0xdb84
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0xc5f6
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbc52
incl %ebp
jmp 0xdb5a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: jumponcond
static int jumponcond(FuncState*fs,expdesc*e,int cond){
if(e->k==VRELOCABLE){
Instruction ie=getcode(fs,e);
if(GET_OPCODE(ie)==OP_NOT){
fs->pc--;
return condjump(fs,OP_TEST,GETARG_B(ie),0,!cond);
}
}
discharge2anyreg(fs,e);
freeexp(fs,e);
return condjump(fs,OP_TESTSET,((1<<8)-1),e->u.s.info,cond);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0xb, (%rsi)
jne 0xdbd5
movq (%r14), %rax
movq 0x18(%rax), %rax
movslq 0x8(%r15), %rcx
movl (%rax,%rcx,4), %edx
movl %edx, %eax
andl $0x3f, %eax
cmpl $0x13, %eax
jne 0xdbd5
decl 0x30(%r14)
shrl $0x17, %edx
xorl %r8d, %r8d
testl %ebx, %ebx
sete %r8b
pushq $0x1a
popq %rsi
movq %r14, %rdi
xorl %ecx, %ecx
jmp 0xdbfd
movq %r14, %rdi
movq %r15, %rsi
callq 0xcd28
movq %r14, %rdi
movq %r15, %rsi
callq 0xcbdf
movl 0x8(%r15), %ecx
pushq $0x1b
popq %rsi
movq %r14, %rdi
movl $0xff, %edx
movl %ebx, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0xdc04
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: codecomp
static void codecomp(FuncState*fs,OpCode op,int cond,expdesc*e1,
expdesc*e2){
int o1=luaK_exp2RK(fs,e1);
int o2=luaK_exp2RK(fs,e2);
freeexp(fs,e2);
freeexp(fs,e1);
if(cond==0&&op!=OP_EQ){
int temp;
temp=o1;o1=o2;o2=temp;
cond=1;
}
e1->u.s.info=condjump(fs,op,cond,o1,o2);
e1->k=VJMP;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movq %rcx, %rsi
callq 0xcc33
movl %eax, %r13d
movq %r14, %rdi
movq %r12, %rsi
callq 0xcc33
movl %eax, %ebp
movq %r14, %rdi
movq %r12, %rsi
callq 0xcbdf
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcbdf
testl %r15d, %r15d
sete %al
movl 0x4(%rsp), %esi
cmpl $0x17, %esi
setne %cl
testb %al, %cl
movl %r13d, %ecx
cmovnel %ebp, %ecx
cmovnel %r13d, %ebp
pushq $0x1
popq %rdx
cmovel %r15d, %edx
movq %r14, %rdi
movl %ebp, %r8d
callq 0xdc04
movl %eax, 0x8(%rbx)
movl $0xa, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: leaveblock
static void leaveblock(FuncState*fs){
BlockCnt*bl=fs->bl;
fs->bl=bl->previous;
removevars(fs->ls,bl->nactvar);
if(bl->upval)
luaK_codeABC(fs,OP_CLOSE,bl->nactvar,0,0);
fs->freereg=fs->nactvar;
luaK_patchtohere(fs,bl->breaklist);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x28(%rbx), %r14
movq (%r14), %rax
movq %rax, 0x28(%rbx)
movzbl 0xc(%r14), %esi
callq 0xdd12
cmpb $0x0, 0xd(%r14)
je 0xdcf8
movzbl 0xc(%r14), %edx
pushq $0x23
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc633
movzbl 0x4a(%rbx), %eax
movl %eax, 0x3c(%rbx)
movl 0x8(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbbf3
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: exp1
static int exp1(LexState*ls){
expdesc e;
int k;
expr(ls,&e);
k=e.k;
luaK_exp2nextreg(ls->fs,&e);
return k;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0xbc52
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xc5f6
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: forbody
static void forbody(LexState*ls,int base,int line,int nvars,int isnum){
BlockCnt bl;
FuncState*fs=ls->fs;
int prep,endfor;
adjustlocalvars(ls,3);
checknext(ls,TK_DO);
prep=isnum?luaK_codeAsBx(fs,OP_FORPREP,base,(-1)):luaK_jump(fs);
enterblock(fs,&bl,0);
adjustlocalvars(ls,nvars);
luaK_reserveregs(fs,nvars);
block(ls);
leaveblock(fs);
luaK_patchtohere(fs,prep);
endfor=(isnum)?luaK_codeAsBx(fs,OP_FORLOOP,base,(-1)):
luaK_codeABC(fs,OP_TFORLOOP,base,0,nvars);
luaK_fixline(fs,line);
luaK_patchlist(fs,(isnum?endfor:luaK_jump(fs)),prep+1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movl %edx, 0x4(%rsp)
movl %esi, %r12d
movq %rdi, %r14
movq 0x30(%rdi), %rbx
pushq $0x3
popq %rsi
callq 0xd76e
movq %r14, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0xbc40
testl %ebp, %ebp
je 0xddf0
pushq $0x20
popq %rsi
movq %rbx, %rdi
movl %r12d, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0xc64e
jmp 0xddf8
movq %rbx, %rdi
callq 0xbbb1
movl %eax, %r15d
leaq 0x8(%rsp), %rax
orl $-0x1, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0xe(%rax)
movb 0x4a(%rbx), %dl
movb %dl, 0xc(%rax)
movb %cl, 0xd(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x28(%rbx)
movq %r14, %rdi
movl %r13d, %esi
callq 0xd76e
movq %rbx, %rdi
movl %r13d, %esi
callq 0xcbed
movq %r14, %rdi
callq 0xba59
movq %rbx, %rdi
callq 0xdcbc
movq %rbx, %rdi
movl %r15d, %esi
callq 0xbbf3
testl %ebp, %ebp
je 0xde67
pushq $0x1f
popq %rsi
movq %rbx, %rdi
movl %r12d, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0xc64e
jmp 0xde7a
pushq $0x21
popq %rsi
movq %rbx, %rdi
movl %r12d, %edx
xorl %ecx, %ecx
movl %r13d, %r8d
callq 0xc633
movq (%rbx), %rcx
movq 0x28(%rcx), %rcx
movslq 0x30(%rbx), %rdx
movl 0x4(%rsp), %esi
movl %esi, -0x4(%rcx,%rdx,4)
testl %ebp, %ebp
jne 0xde99
movq %rbx, %rdi
callq 0xbbb1
incl %r15d
movq %rbx, %rdi
movl %eax, %esi
movl %r15d, %edx
callq 0xdca5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: adjust_assign
static void adjust_assign(LexState*ls,int nvars,int nexps,expdesc*e){
FuncState*fs=ls->fs;
int extra=nvars-nexps;
if(hasmultret(e->k)){
extra++;
if(extra<0)extra=0;
luaK_setreturns(fs,e,extra);
if(extra>1)luaK_reserveregs(fs,extra-1);
}
else{
if(e->k!=VVOID)luaK_exp2nextreg(fs,e);
if(extra>0){
int reg=fs->freereg;
luaK_reserveregs(fs,extra);
luaK_nil(fs,reg,extra);
}
}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq 0x30(%rdi), %rbx
subl %edx, %ebp
movl (%rcx), %eax
leal -0xd(%rax), %edx
cmpl $0x2, %edx
jae 0xdefa
testl %ebp, %ebp
pushq $-0x1
popq %r14
cmovnsl %ebp, %r14d
leal 0x1(%r14), %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xd5f6
testl %ebp, %ebp
jle 0xdf2c
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xcbed
testl %eax, %eax
je 0xdf09
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xc5f6
testl %ebp, %ebp
jle 0xdf2c
movl 0x3c(%rbx), %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0xcbed
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xca48
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_storevar
static void luaK_storevar(FuncState*fs,expdesc*var,expdesc*ex){
switch(var->k){
case VLOCAL:{
freeexp(fs,ex);
exp2reg(fs,ex,var->u.s.info);
return;
}
case VUPVAL:{
int e=luaK_exp2anyreg(fs,ex);
luaK_codeABC(fs,OP_SETUPVAL,e,var->u.s.info,0);
break;
}
case VGLOBAL:{
int e=luaK_exp2anyreg(fs,ex);
luaK_codeABx(fs,OP_SETGLOBAL,e,var->u.s.info);
break;
}
case VINDEXED:{
int e=luaK_exp2RK(fs,ex);
luaK_codeABC(fs,OP_SETTABLE,var->u.s.info,var->u.s.aux,e);
break;
}
default:{
break;
}
}
freeexp(fs,ex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x3, %eax
ja 0xdfd7
movq %rsi, %r15
leaq 0x4418(%rip), %rcx      # 0x1236c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcbdf
movl 0x8(%r15), %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc4fa
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc2b5
movl 0x8(%r15), %ecx
pushq $0x7
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xc64e
jmp 0xdfd7
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcc33
movl 0x8(%r15), %edx
movl 0xc(%r15), %ecx
pushq $0x9
popq %rsi
movq %r14, %rdi
movl %eax, %r8d
jmp 0xdfd2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc2b5
movl 0x8(%r15), %ecx
pushq $0x8
popq %rsi
movq %r14, %rdi
movl %eax, %edx
xorl %r8d, %r8d
callq 0xc633
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xcbdf
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: assignment
static void assignment(LexState*ls,struct LHS_assign*lh,int nvars){
expdesc e;
check_condition(ls,VLOCAL<=lh->v.k&&lh->v.k<=VINDEXED,
"syntax error");
if(testnext(ls,',')){
struct LHS_assign nv;
nv.prev=lh;
primaryexp(ls,&nv.v);
if(nv.v.k==VLOCAL)
check_conflict(ls,lh,&nv.v);
luaY_checklimit(ls->fs,nvars,200-ls->L->nCcalls,
"variables in assignment");
assignment(ls,&nv,nvars+1);
}
else{
int nexps;
checknext(ls,'=');
nexps=explist1(ls,&e);
if(nexps!=nvars){
adjust_assign(ls,nvars,nexps,&e);
if(nexps>nvars)
ls->fs->freereg-=nexps-nvars;
}
else{
luaK_setoneret(ls->fs,&e);
luaK_storevar(ls->fs,&lh->v,&e);
return;
}
}
init_exp(&e,VNONRELOC,ls->fs->freereg-1);
luaK_storevar(ls->fs,&lh->v,&e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl 0x8(%rsi), %eax
addl $-0x6, %eax
cmpl $0x4, %eax
jae 0xe158
movl %edx, %ebp
movq %rsi, %rbx
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0xba44
testl %eax, %eax
je 0xe083
leaq 0x10(%rsp), %r15
movq %rbx, -0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xd209
cmpl $0x6, (%r15)
jne 0xe0db
movq 0x30(%r14), %r15
movl 0x3c(%r15), %eax
xorl %esi, %esi
pushq $0x1
popq %rcx
movq %rbx, %rdx
testq %rdx, %rdx
je 0xe0b7
cmpl $0x9, 0x8(%rdx)
jne 0xe07e
movl 0x18(%rsp), %edi
cmpl %edi, 0x10(%rdx)
jne 0xe074
movl %eax, 0x10(%rdx)
movl 0x18(%rsp), %edi
movl %ecx, %esi
cmpl %edi, 0x14(%rdx)
jne 0xe07e
movl %eax, 0x14(%rdx)
movl %ecx, %esi
movq (%rdx), %rdx
jmp 0xe057
pushq $0x3d
popq %rsi
movq %r14, %rdi
callq 0xbc40
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xdb41
cmpl %eax, %ebp
jne 0xe136
movq 0x30(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc673
movq 0x30(%r14), %rdi
jmp 0xe11a
testl %esi, %esi
je 0xe0db
movl 0x3c(%r15), %edx
movl 0x18(%rsp), %ecx
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xc633
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xcbed
movq 0x38(%r14), %rax
movzwl 0x60(%rax), %eax
movl $0xc8, %esi
subl %eax, %esi
cmpl %ebp, %esi
jl 0xe167
incl %ebp
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0xdff9
movq 0x30(%r14), %rdi
movl 0x3c(%rdi), %eax
orq $-0x1, 0x18(%rsp)
decl %eax
movl $0xc, 0x8(%rsp)
movl %eax, 0x10(%rsp)
addq $0x8, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0xdf31
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xdeb8
subl %r15d, %ebp
jge 0xe0ff
movq 0x30(%r14), %rax
addl %ebp, 0x3c(%rax)
jmp 0xe0ff
leaq 0x4c42(%rip), %rsi      # 0x12da1
movq %r14, %rdi
callq 0xb9b8
movq 0x30(%r14), %rdi
leaq 0x4c3c(%rip), %rdx      # 0x12dae
callq 0xd52a
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_tonumber
static lua_Number lua_tonumber(lua_State*L,int idx){
TValue n;
const TValue*o=index2adr(L,idx);
if(tonumber(o,&n))
return nvalue(o);
else
return 0;
}

// Assembly:
subq $0x18, %rsp
callq 0x8e4b
cmpl $0x3, 0x8(%rax)
je 0xe1e5
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x70bd
testq %rax, %rax
je 0xe1ee
movsd (%rax), %xmm0
addq $0x18, %rsp
retq
xorps %xmm0, %xmm0
jmp 0xe1e9
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_setfenv
static int lua_setfenv(lua_State*L,int idx){
StkId o;
int res=1;
api_checknelems(L,1);
o=index2adr(L,idx);
api_checkvalidindex(L,o);
luai_apicheck(L,ttistable(L->top-1));
switch(ttype(o)){
case 6:
clvalue(o)->c.env=hvalue(L->top-1);
break;
case 7:
uvalue(o)->env=hvalue(L->top-1);
break;
case 8:
sethvalue(L,gt(thvalue(o)),hvalue(L->top-1));
break;
default:
res=0;
break;
}
if(res)luaC_objbarrier(L,gcvalue(o),hvalue(L->top-1));
L->top--;
return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movl -0x18(%rax), %ecx
cmpl $0x8, %ecx
je 0xe21f
cmpl $0x7, %ecx
je 0xe211
xorl %ebp, %ebp
cmpl $0x6, %ecx
jne 0xe261
movq -0x20(%rax), %rcx
movq -0x10(%rax), %rdx
movq %rdx, 0x18(%rcx)
jmp 0xe235
movq -0x20(%rax), %rcx
movq -0x10(%rax), %rdx
movq %rdx, 0x78(%rcx)
movl $0x5, 0x80(%rcx)
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rdx
pushq $0x1
popq %rbp
testb $0x3, 0x9(%rdx)
je 0xe250
movq -0x20(%rax), %rsi
testb $0x4, 0x9(%rsi)
jne 0xe255
movq %rcx, %rax
jmp 0xe261
movq %rbx, %rdi
callq 0x43bc
movq 0x10(%rbx), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_getmetatable
static int lua_getmetatable(lua_State*L,int objindex){
const TValue*obj;
Table*mt=NULL;
int res;
obj=index2adr(L,objindex);
switch(ttype(obj)){
case 5:
mt=hvalue(obj)->metatable;
break;
case 7:
mt=uvalue(obj)->metatable;
break;
default:
mt=G(L)->mt[ttype(obj)];
break;
}
if(mt==NULL)
res=0;
else{
sethvalue(L,L->top,mt);
api_incr_top(L);
res=1;
}
return res;
}

// Assembly:
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdx
cmpq %rax, %rdx
leaq 0x41bc(%rip), %rcx      # 0x12440
cmovbq %rdx, %rcx
movslq 0x8(%rcx), %rdx
cmpq $0x7, %rdx
je 0xe297
cmpl $0x5, %edx
jne 0xe2a0
movq (%rcx), %rcx
addq $0x10, %rcx
jmp 0xe2af
movq 0x20(%rdi), %rcx
leaq (%rcx,%rdx,8), %rcx
addq $0xe0, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xe2ca
movq %rcx, (%rax)
movl $0x5, 0x8(%rax)
addq $0x10, 0x10(%rdi)
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_remove
static void lua_remove(lua_State*L,int idx){
StkId p;
p=index2adr(L,idx);
api_checkvalidindex(L,p);
while(++p<L->top)setobj(L,p-1,p);
L->top--;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8e4b
addq $0x10, %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jae 0xe2f2
movq (%rax), %rcx
movq %rcx, -0x10(%rax)
movl 0x8(%rax), %ecx
movl %ecx, -0x8(%rax)
jmp 0xe2d6
addq $-0x10, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_objlen
static size_t lua_objlen(lua_State*L,int idx){
StkId o=index2adr(L,idx);
switch(ttype(o)){
case 4:return tsvalue(o)->len;
case 7:return uvalue(o)->len;
case 5:return luaH_getn(hvalue(o));
case 3:{
size_t l;
l=(luaV_tostring(L,o)?tsvalue(o)->len:0);
return l;
}
default:return 0;
}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x8e4b
movq %rax, %rbx
movl 0x8(%rax), %ecx
xorl %eax, %eax
addl $-0x3, %ecx
cmpl $0x4, %ecx
ja 0xe357
leaq 0x405d(%rip), %rdx      # 0x1237c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4ea1
testl %eax, %eax
je 0xe355
movq (%rbx), %rax
movq 0x10(%rax), %rax
jmp 0xe357
movq (%rbx), %rdi
callq 0x6f72
cltq
jmp 0xe357
movq (%rbx), %rax
movq 0x20(%rax), %rax
jmp 0xe357
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq