LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: codearith
static void codearith(FuncState*fs,OpCode op,expdesc*e1,expdesc*e2){
if(constfolding(op,e1,e2))
return;
else{
int o2=(op!=OP_UNM&&op!=OP_LEN)?luaK_exp2RK(fs,e2):0;
int o1=luaK_exp2RK(fs,e1);
if(o1>o2){
freeexp(fs,e1);
freeexp(fs,e2);
}
else{
freeexp(fs,e2);
freeexp(fs,e1);
}
e1->u.s.info=luaK_codeABC(fs,op,0,o1,o2);
e1->k=VRELOCABLE;
}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x5, (%rdx)
jne 0xd458
cmpl $-0x1, 0x10(%rbx)
jne 0xd458
cmpl $-0x1, 0x14(%rbx)
jne 0xd458
cmpl $0x5, (%r12)
jne 0xd458
cmpl $-0x1, 0x10(%r12)
jne 0xd458
cmpl $-0x1, 0x14(%r12)
je 0xd517
xorl %ebp, %ebp
cmpl $0x12, %r15d
je 0xd473
cmpl $0x14, %r15d
je 0xd473
movq %r14, %rdi
movq %r12, %rsi
callq 0xddcb
movl %eax, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xddcb
cmpl %ebp, %eax
jle 0xd4ab
cmpl $0xc, (%rbx)
jne 0xd49d
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0xd49d
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xd49d
decl 0x3c(%r14)
cmpl $0xc, (%r12)
jne 0xd4e5
movl 0x8(%r12), %ecx
jmp 0xd4d2
cmpl $0xc, (%r12)
jne 0xd4ca
movl 0x8(%r12), %ecx
btl $0x8, %ecx
jb 0xd4ca
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xd4ca
decl 0x3c(%r14)
cmpl $0xc, (%rbx)
jne 0xd4e5
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0xd4e5
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xd4e5
decl 0x3c(%r14)
shll $0x17, %eax
shll $0xe, %ebp
orl %eax, %ebp
orl %r15d, %ebp
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0xd83d
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorpd %xmm0, %xmm0
leal -0xc(%r15), %eax
cmpl $0x8, %eax
ja 0xd582
movsd 0x8(%rbx), %xmm2
movsd 0x8(%r12), %xmm1
leaq 0x6db5(%rip), %rcx      # 0x142ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
jmp 0xd57e
movapd %xmm2, %xmm0
callq 0x30c0
jmp 0xd582
subsd %xmm1, %xmm2
jmp 0xd57e
xorpd 0x7051(%rip), %xmm2     # 0x145b0
jmp 0xd57e
xorl %ebp, %ebp
jmp 0xd473
mulsd %xmm1, %xmm2
jmp 0xd57e
ucomisd %xmm0, %xmm1
jne 0xd57a
jnp 0xd458
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
ucomisd %xmm0, %xmm0
jp 0xd458
movsd %xmm0, 0x8(%rbx)
jmp 0xd50a
ucomisd %xmm0, %xmm1
jne 0xd5a2
jnp 0xd458
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x3270
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xd582
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x8, %eax
ja 0xd668
movq %rsi, %rbx
leaq 0x6d26(%rip), %rcx      # 0x14310
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rsi
popq %rbx
jmp 0xd7f0
movl 0x8(%rbx), %esi
shll $0xe, %esi
orl $0x5, %esi
jmp 0xd653
movl $0xc, (%rbx)
jmp 0xd668
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x4, %esi
jmp 0xd653
movl 0xc(%rbx), %eax
btl $0x8, %eax
jb 0xd62e
movzbl 0x4a(%rdi), %ecx
cmpl %ecx, %eax
jl 0xd62e
decl 0x3c(%rdi)
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0xd642
movzbl 0x4a(%rdi), %ecx
cmpl %ecx, %eax
jl 0xd642
decl 0x3c(%rdi)
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %esi
shll $0x17, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x6, %esi
movq 0x18(%rdi), %rax
movl 0x8(%rax), %edx
callq 0xd83d
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda9f
cmpl $0xa, (%rbx)
jne 0xd696
leaq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0xca30
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %r15d
cmpl %r15d, %esi
je 0xd76e
movq %r14, %rdi
callq 0xdb8b
testl %eax, %eax
jne 0xd6c5
movq %r14, %rdi
movl %r15d, %esi
callq 0xdb8b
testl %eax, %eax
je 0xd78e
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0xa, (%rbx)
je 0xd6db
movq %r14, %rdi
callq 0xca74
movl %eax, %r15d
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
movl %ebp, %r13d
shll $0x6, %r13d
movl %r13d, %esi
orl $0x4002, %esi           # imm = 0x4002
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0xd83d
movl %eax, %r12d
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
orl $0x800002, %r13d        # imm = 0x800002
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %r13d, %esi
callq 0xd83d
movl %eax, %r13d
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
leaq 0x38(%r14), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0xca30
movl 0x30(%r14), %r15d
movl %r15d, 0x34(%r14)
movl 0x14(%rbx), %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0xd96b
movl 0x10(%rbx), %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movl %r13d, %r8d
callq 0xd96b
movq $-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
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0xd740
// File: /workspace/github_c_makefile_star2_O1/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 0xd5d1
cmpl $0xc, (%rbx)
jne 0xd7c6
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0xd7c6
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %eax
jl 0xd7c6
decl 0x3c(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0xdd9c
movl 0x3c(%r14), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x3c(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd66a
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_setoneret
static void luaK_setoneret(FuncState*fs,expdesc*e){
if(e->k==VCALL){
e->k=VNONRELOC;
e->u.s.info=GETARG_A(getcode(fs,e));
}
else if(e->k==VVARARG){
SETARG_B(getcode(fs,e),2);
e->k=VRELOCABLE;
}
}

// Assembly:
movl (%rsi), %eax
cmpl $0xe, %eax
je 0xd81a
cmpl $0xd, %eax
jne 0xd83c
movl $0xc, (%rsi)
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x6, %eax
movzbl %al, %eax
movl %eax, 0x8(%rsi)
retq
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %edx         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %edx
orl $0x1000000, %edx        # imm = 0x1000000
movl %edx, (%rax,%rcx,4)
movl $0xb, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd96b
movl $0xffffffff, 0x38(%rbx) # imm = 0xFFFFFFFF
movl 0x30(%rbx), %eax
cmpl 0x50(%r15), %eax
jl 0xd899
leaq 0x50(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x18(%r15), %rsi
leaq 0x72b6(%rip), %r9       # 0x14b3b
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xd8f4
movq %rax, 0x18(%r15)
movq 0x18(%r15), %rax
movslq 0x30(%rbx), %rcx
movl %r14d, (%rax,%rcx,4)
movl 0x30(%rbx), %eax
cmpl 0x54(%r15), %eax
jl 0xd8d5
leaq 0x54(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x28(%r15), %rsi
leaq 0x727a(%rip), %r9       # 0x14b3b
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xd8f4
movq %rax, 0x28(%r15)
movq 0x28(%r15), %rax
movslq 0x30(%rbx), %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_O1/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
movq %rdx, %rbx
movl (%rdx), %eax
movl %r8d, %edx
shrl %edx
cmpl %edx, %eax
jge 0xd917
addl %eax, %eax
cmpl $0x5, %eax
movl $0x4, %r14d
cmovgel %eax, %r14d
jmp 0xd91f
movl %r8d, %r14d
cmpl %r8d, %eax
jge 0xd961
leal 0x1(%r14), %eax
movslq %eax, %r8
movq $-0x3, %rax
xorl %edx, %edx
divq %rcx
cmpq %r8, %rax
jb 0xd958
movslq (%rbx), %rdx
imulq %rcx, %rdx
movslq %r14d, %rax
imulq %rcx, %rax
movq %rax, %rcx
callq 0x42ab
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6cba(%rip), %rsi      # 0x14619
jmp 0xd964
movq %r9, %rsi
xorl %eax, %eax
callq 0x46c4
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $-0x1, %esi
je 0xd9e3
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
movq (%r15), %rax
movq 0x18(%rax), %rax
movslq %r12d, %r13
movl (%rax,%r13,4), %eax
shrl $0xe, %eax
leal -0x1ffff(%rax), %ecx
cmpl $-0x1, %ecx
leal -0x1fffe(%r13,%rax), %r12d
cmovel %ecx, %r12d
movq %r15, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0xd9e4
testl %eax, %eax
movl %r14d, %edx
cmovel %ebx, %edx
movq %r15, %rdi
movl %r13d, %esi
callq 0xda56
cmpl $-0x1, %r12d
jne 0xd989
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rdi), %rax
movslq %esi, %rsi
leaq (,%rsi,4), %rcx
addq 0x18(%rax), %rcx
testl %esi, %esi
jle 0xda11
movl -0x4(%rcx), %eax
movabsq $0x3df07fffff, %rsi     # imm = 0x3DF07FFFFF
btq %rax, %rsi
jb 0xda11
addq $-0x4, %rcx
movl (%rcx), %esi
movl %esi, %edi
andl $0x3f, %edi
xorl %eax, %eax
cmpl $0x1b, %edi
jne 0xda55
cmpl $0xff, %edx
je 0xda3e
movl %esi, %eax
shrl $0x17, %eax
cmpl %edx, %eax
je 0xda3e
andl $0xffffc01b, %esi       # imm = 0xFFFFC01B
movzbl %dl, %eax
shll $0x6, %eax
jmp 0xda4c
movl %esi, %eax
shrl $0x11, %eax
andl $-0x40, %eax
andl $0x7fc01a, %esi         # imm = 0x7FC01A
orl %eax, %esi
movl %esi, (%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda8b
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
movl 0x10(%rdi), %edx
leaq 0x70b4(%rip), %rsi      # 0x14b4e
callq 0xc4a9
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd5d1
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0xdb82
leaq 0x686b(%rip), %rdx      # 0x14334
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %ebp, %ecx
shll $0x6, %ecx
cmpl $0x2, %eax
movl $0x800000, %eax         # imm = 0x800000
movl $0x2, %esi
cmovel %eax, %esi
orl %ecx, %esi
orl $0x2, %esi
jmp 0xdb6a
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 0xdb79
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0xdb79
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
jmp 0xdb6a
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0xdbf6
jmp 0xdb79
movl 0x8(%rbx), %esi
movl %ebp, %eax
shll $0x6, %eax
shll $0xe, %esi
jmp 0xdb66
movsd 0x8(%rbx), %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0xdc8d
movl %ebp, %esi
shll $0x6, %esi
shll $0xe, %eax
orl %eax, %esi
incl %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0xd83d
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
cmpl $-0x1, %esi
je 0xdbef
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movabsq $0x3df07fffff, %rdx     # imm = 0x3DF07FFFFF
movslq %esi, %r8
leaq (%rcx,%r8,4), %rdi
testl %r8d, %r8d
jle 0xdbbf
movl -0x4(%rdi), %r8d
btq %r8, %rdx
jb 0xdbbf
leaq -0x4(%rdi), %r8
jmp 0xdbc2
movq %rdi, %r8
movl (%r8), %r8d
andl $0x3f, %r8d
cmpl $0x1b, %r8d
jne 0xdbf0
movl (%rdi), %edi
shrl $0xe, %edi
leal -0x1ffff(%rdi), %r8d
cmpl $-0x1, %r8d
leal -0x1fffe(%rsi,%rdi), %esi
cmovel %r8d, %esi
cmpl $-0x1, %esi
jne 0xdba3
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movslq 0x30(%rdi), %rax
cmpl 0x34(%rdi), %eax
jle 0xdc69
testl %eax, %eax
je 0xdc61
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movl -0x4(%rcx,%rax,4), %r8d
movl %r8d, %r9d
andl $0x3f, %r9d
cmpl $0x3, %r9d
jne 0xdc69
movl %r8d, %r9d
shrl $0x6, %r9d
movzbl %r9b, %r10d
movl %r8d, %r9d
shrl $0x17, %r9d
cmpl %esi, %r10d
setg %r10b
leal 0x1(%r9), %r11d
cmpl %esi, %r11d
setl %r11b
orb %r10b, %r11b
jne 0xdc69
addl %esi, %edx
decl %edx
cmpl %r9d, %edx
jle 0xdc8c
andl $0x7fffc3, %r8d         # imm = 0x7FFFC3
shll $0x17, %edx
orl %r8d, %edx
movl %edx, -0x4(%rcx,%rax,4)
jmp 0xdc8c
movzbl 0x4a(%rdi), %eax
cmpl %esi, %eax
jle 0xdc8c
addl %esi, %edx
shll $0x6, %esi
shll $0x17, %edx
addl $0xff800000, %edx       # imm = 0xFF800000
orl %esi, %edx
orl $0x3, %edx
movq 0x18(%rdi), %rax
movl 0x8(%rax), %eax
movl %edx, %esi
movl %eax, %edx
jmp 0xd83d
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x7852
cmpl $0x3, 0x8(%rax)
jne 0xdcc0
cvttsd2si (%rax), %eax
jmp 0xdd8d
movq (%rbx), %r13
leaq 0x4c(%r13), %r12
movslq 0x4c(%r13), %rbp
cvtsi2sdl 0x40(%rbx), %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
movl 0x40(%rbx), %eax
cmpl (%r12), %eax
jl 0xdd09
movq 0x10(%r13), %rsi
leaq 0x6e7a(%rip), %r9       # 0x14b69
movl $0x10, %ecx
movq %r14, %rdi
movq %r12, %rdx
movl $0x3ffff, %r8d          # imm = 0x3FFFF
callq 0xd8f4
movq %rax, 0x10(%r13)
movslq (%r12), %rax
cmpl %eax, %ebp
jge 0xdd32
movq 0x10(%r13), %rcx
subq %rbp, %rax
shlq $0x4, %rbp
addq %rbp, %rcx
addq $0x8, %rcx
movl $0x0, (%rcx)
addq $0x10, %rcx
decq %rax
jne 0xdd23
movq 0x10(%r13), %rax
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, 0x8(%r15)
jl 0xdd84
movq (%r15), %rsi
testb $0x3, 0x9(%rsi)
je 0xdd84
movb 0x9(%r13), %al
testb $0x4, %al
je 0xdd84
movq 0x20(%r14), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0xdd76
callq 0x4593
jmp 0xdd84
andb $-0x8, %al
movb 0x20(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r13)
movl 0x40(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xddb6
cmpl $0xfa, %esi
jge 0xddb7
movb %sil, 0x73(%rax)
retq
pushq %rax
movq 0x18(%rdi), %rdi
movl 0x10(%rdi), %edx
leaq 0x6dbb(%rip), %rsi      # 0x14b81
callq 0xc4a9
// File: /workspace/github_c_makefile_star2_O1/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 0xde93
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0xddf1
cmpl $0x4, %eax
je 0xde29
cmpl $0x5, %eax
jne 0xde33
cmpl $0xff, 0x40(%r14)
jg 0xde33
cmpl $0x5, %eax
je 0xde45
cmpl $0x1, %eax
jne 0xde5c
leaq 0x18(%rsp), %rdx
movl $0x0, 0x8(%rdx)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
movq %r14, %rdi
jmp 0xde78
movl 0x8(%rbx), %eax
cmpl $0xff, %eax
jle 0xde86
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xd3bf
movsd 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
jmp 0xde72
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 0xdc8d
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_O1/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
xorl %edx, %edx
callq 0xcbb5
cmpl $0x7ffffffe, 0x24(%rbx) # imm = 0x7FFFFFFE
jge 0xe786
incl 0x24(%rbx)
incl 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x30(%r14), %rdi
leaq 0x643e(%rip), %rdx      # 0x14bcf
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0xe925
// File: /workspace/github_c_makefile_star2_O1/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 0xe80c
cmpl $0x7ffffffe, 0x20(%r14) # imm = 0x7FFFFFFE
jge 0xe894
movq %r15, %rdi
callq 0xe9da
movq 0x30(%r15), %rdi
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movl $0x4, %ebp
movl %ebp, 0x8(%r12)
movq %r12, %rsi
movq %r12, %rdx
callq 0xdc8d
movq $-0x1, 0x10(%r12)
movl %ebp, (%r12)
movl %eax, 0x8(%r12)
jmp 0xe819
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xe96d
incl 0x20(%r14)
movq %r15, %rdi
movl $0x3d, %esi
callq 0xcaf9
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xddcb
movl %eax, %ebp
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xcbb5
movq 0x18(%r14), %rax
movl 0x8(%rax), %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xddcb
shll $0x6, %r14d
shll $0x17, %ebp
shll $0xe, %eax
orl %eax, %ebp
orl %r14d, %ebp
orl $0x9, %ebp
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd83d
movl %r13d, 0x3c(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6334(%rip), %rdx      # 0x14bcf
movq %rbx, %rdi
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0xe925
// File: /workspace/github_c_makefile_star2_O1/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 %esi, %ebx
movq %rdi, %r14
leal -0x1(%rdx), %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rsi
sarq $0x24, %rsi
shrq $0x3f, %rax
leal (%rsi,%rax), %ebp
incl %ebp
movl %ecx, %edi
shll $0x17, %edi
movl %ebx, %esi
shll $0x6, %esi
xorl %eax, %eax
cmpl $-0x1, %ecx
cmovnel %edi, %eax
cmpl $0x63ce, %edx           # imm = 0x63CE
jg 0xe8f5
shll $0xe, %ebp
orl %esi, %eax
orl %ebp, %eax
orl $0x22, %eax
movl %eax, %ebp
jmp 0xe909
orl %eax, %esi
orl $0x22, %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0xd83d
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0xd83d
incl %ebx
movl %ebx, 0x3c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe951
leaq 0x62a3(%rip), %rsi      # 0x14be6
movl %ecx, %edx
movq %r8, %rcx
xorl %eax, %eax
callq 0x4c39
jmp 0xe95f
leaq 0x62b0(%rip), %rsi      # 0x14c08
xorl %eax, %eax
callq 0x4c39
movq 0x18(%rbx), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xc4a9
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xe999
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xbabb
movl %eax, 0x10(%rbx)
jmp 0xe9ad
leaq 0x20(%rbx), %rax
leaq 0x10(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xcbb5
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xde93
movq %rbx, %rdi
movl $0x5d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcaf9
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x11d, 0x10(%rdi)      # imm = 0x11D
jne 0xea2d
movq 0x18(%rbx), %r14
movl 0x4(%rbx), %eax
movl %eax, 0x8(%rbx)
cmpl $0x11f, 0x20(%rbx)      # imm = 0x11F
jne 0xea0e
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xbabb
movl %eax, 0x10(%rbx)
jmp 0xea22
leaq 0x10(%rbx), %rax
addq $0x20, %rbx
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl $0x11f, (%rbx)          # imm = 0x11F
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0x11d, %esi            # imm = 0x11D
callq 0xf391
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0xe, %eax
je 0xea73
cmpl $0xd, %eax
jne 0xeabf
movq (%rbx), %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)
jmp 0xeabf
movq (%rbx), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %edi         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %edi
shll $0x17, %edx
addl %edi, %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(%rbx), %esi
movzbl %sil, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xdd9c
incl 0x3c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rdi
movb 0x4a(%rdi), %r8b
addb %sil, %r8b
movb %r8b, 0x4a(%rdi)
testl %esi, %esi
je 0xec31
movl 0x30(%rdi), %eax
movq (%rdi), %rcx
movq 0x30(%rcx), %rcx
movslq %esi, %rdx
movzbl %r8b, %esi
leaq (%rdi,%rsi,2), %rsi
addq $0xc4, %rsi
negq %rdx
movzwl (%rsi,%rdx,2), %edi
shll $0x4, %edi
movl %eax, 0x8(%rcx,%rdi)
incq %rdx
jne 0xec21
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x30(%rdi), %r14
movq %r14, %rdi
callq 0xd3bf
movl 0x4(%r15), %eax
movl 0x20(%r15), %ecx
movl %eax, 0x8(%r15)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xec74
leaq 0x18(%r15), %rsi
movq %r15, %rdi
callq 0xbabb
movl %eax, 0x10(%r15)
jmp 0xec88
leaq 0x20(%r15), %rax
leaq 0x10(%r15), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %r15, %rdi
callq 0xe9da
movq 0x30(%r15), %rdi
movq %rsp, %r15
movq %rax, (%r15)
movl $0x4, %ebp
movl %ebp, 0x8(%r15)
movq %r15, %rsi
movq %r15, %rdx
callq 0xdc8d
movq $-0x1, 0x10(%r15)
movl %ebp, (%r15)
movl %eax, 0x8(%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0xddcb
movl %eax, 0xc(%rbx)
movl $0x9, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe9da
movq %rax, %r15
movq 0x30(%r14), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xef0d
cmpl $0x8, %eax
jne 0xef03
movq %rsp, %rdx
movq %r15, (%rdx)
movl $0x4, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0xdc8d
movl %eax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
testq %rdi, %rdi
je 0xef4c
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x4a(%rdi), %edx
testq %rdx, %rdx
jle 0xef6d
movq (%rbx), %rax
movq 0x30(%rax), %rax
movzwl 0xc2(%rbx,%rdx,2), %esi
decq %rdx
shll $0x4, %esi
cmpq %r15, (%rax,%rsi)
jne 0xef2a
jmp 0xef72
movq $-0x1, 0x10(%r14)
movl $0x8, (%r14)
movl $0xff, 0x8(%r14)
movl $0x8, %eax
jmp 0xf0cb
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
testl %edx, %edx
js 0xefb4
movq $-0x1, 0x10(%r14)
movl $0x6, (%r14)
movl %edx, 0x8(%r14)
movl $0x6, %eax
testl %ecx, %ecx
jne 0xf0cb
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xf0cb
cmpb %dl, 0xc(%rbx)
ja 0xef9a
movb $0x1, 0xd(%rbx)
jmp 0xf0cb
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xef0d
movl %eax, %ecx
movl $0x8, %eax
cmpl $0x8, %ecx
je 0xf0cb
movq (%rbx), %r13
movslq 0x48(%r13), %rbp
movzbl 0x70(%r13), %ecx
testq %rcx, %rcx
je 0xf00b
movl (%r14), %edx
xorl %eax, %eax
movzbl 0x4b(%rbx,%rax,2), %esi
cmpl %esi, %edx
jne 0xf003
movzbl 0x4c(%rbx,%rax,2), %esi
cmpl %esi, 0x8(%r14)
je 0xf0bb
incq %rax
cmpq %rax, %rcx
jne 0xefeb
cmpb $0x3c, %cl
jae 0xf0da
leaq 0x48(%r13), %r12
cmpl %ecx, %ebp
jg 0xf042
movq 0x20(%rbx), %rdi
movq 0x38(%r13), %rsi
leaq 0x58d0(%rip), %r9       # 0x148fb
movl $0x8, %ecx
movq %r12, %rdx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xd8f4
movq %rax, 0x38(%r13)
movslq (%r12), %rax
cmpl %eax, %ebp
jge 0xf05e
movq 0x38(%r13), %rcx
movq $0x0, (%rcx,%rbp,8)
incq %rbp
cmpq %rbp, %rax
jne 0xf04a
movq 0x38(%r13), %rax
movzbl 0x70(%r13), %ecx
movq %r15, (%rax,%rcx,8)
testb $0x3, 0x9(%r15)
je 0xf0a0
movb 0x9(%r13), %al
testb $0x4, %al
je 0xf0a0
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0xf092
movq %r15, %rsi
callq 0x4593
jmp 0xf0a0
andb $-0x8, %al
movb 0x20(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r13)
movb (%r14), %cl
movzbl 0x70(%r13), %eax
movb %cl, 0x4b(%rbx,%rax,2)
movb 0x8(%r14), %cl
movb %cl, 0x4c(%rbx,%rax,2)
leal 0x1(%rax), %ecx
movb %cl, 0x70(%r13)
movl %eax, 0x8(%r14)
movl $0x7, (%r14)
movl $0x7, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5b98(%rip), %rdx      # 0x14c79
movq %rbx, %rdi
movl $0x3c, %esi
callq 0xe925
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0xcbb5
movq %r14, %rdi
movl $0x2c, %esi
callq 0xc858
movl $0x1, %ebp
testl %eax, %eax
je 0xf13f
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0xd79c
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xcbb5
incl %ebp
movq %r14, %rdi
movl $0x2c, %esi
callq 0xc858
jmp 0xf111
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xb, (%rsi)
jne 0xf1b6
movq (%rbx), %rax
movq 0x18(%rax), %rax
movslq 0x8(%r14), %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, %r15d
andl $0x3f, %r15d
cmpl $0x13, %r15d
jne 0xf1a5
decl 0x30(%rbx)
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
shrl $0x11, %ecx
andl $-0x40, %ecx
shll $0xe, %esi
orl %ecx, %esi
orl $0x1a, %esi
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0xd83d
movq %rbx, %rdi
callq 0xca74
cmpl $0x13, %r15d
jne 0xf1b6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdef1
cmpl $0xc, (%r14)
jne 0xf1dc
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0xf1dc
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0xf1dc
decl 0x3c(%rbx)
movl 0x8(%r14), %eax
shll $0x17, %eax
shll $0xe, %ebp
orl %eax, %ebp
orl $0x3fdb, %ebp           # imm = 0x3FDB
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd83d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xca74
// File: /workspace/github_c_makefile_star2_O1/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, %r13
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, %rsi
callq 0xddcb
movl %eax, %r12d
movq %r14, %rdi
movq %r13, %rsi
callq 0xddcb
cmpl $0xc, (%r13)
jne 0xf25e
movl 0x8(%r13), %ecx
btl $0x8, %ecx
jb 0xf25e
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xf25e
decl 0x3c(%r14)
cmpl $0xc, (%rbx)
jne 0xf279
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0xf279
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xf279
decl 0x3c(%r14)
testl %r15d, %r15d
sete %cl
cmpl $0x17, %ebp
setne %dl
shll $0x6, %r15d
testb %cl, %dl
movl %r12d, %ecx
cmovnel %eax, %ecx
cmovnel %r12d, %eax
movl $0x40, %edx
cmovel %r15d, %edx
shll $0x17, %ecx
orl %edx, %ecx
shll $0xe, %eax
orl %ebp, %eax
orl %ecx, %eax
movq 0x18(%r14), %rcx
movl 0x8(%rcx), %edx
movq %r14, %rdi
movl %eax, %esi
callq 0xd83d
movq %r14, %rdi
callq 0xca74
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_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_patchlist
static void luaK_patchlist(FuncState*fs,int list,int target){
if(target==fs->pc)
luaK_patchtohere(fs,list);
else{
patchlistaux(fs,list,target,((1<<8)-1),target);
}
}

// Assembly:
movl %edx, %r8d
movl %esi, %edx
movl 0x30(%rdi), %eax
cmpl %r8d, %eax
jne 0xf2f4
movl %eax, 0x34(%rdi)
leaq 0x38(%rdi), %rsi
jmp 0xca30
movl %edx, %esi
movl %r8d, %edx
movl $0xff, %ecx
jmp 0xd96b
// File: /workspace/github_c_makefile_star2_O1/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), %rax
movq 0x28(%rdi), %r14
movq (%r14), %rcx
movq %rcx, 0x28(%rdi)
movzbl 0xc(%r14), %esi
movq 0x30(%rax), %rcx
movzbl 0x4a(%rcx), %edx
cmpb %sil, %dl
jbe 0xf355
movl 0x30(%rcx), %edi
movq (%rcx), %r8
movq 0x30(%r8), %r8
movl %esi, %r9d
movzwl 0xc2(%rcx,%rdx,2), %r10d
decq %rdx
shll $0x4, %r10d
movl %edi, 0xc(%r8,%r10)
cmpq %r9, %rdx
ja 0xf338
movb %dl, 0x4a(%rcx)
cmpb $0x0, 0xd(%r14)
je 0xf36d
shll $0x6, %esi
orl $0x23, %esi
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0xd83d
movzbl 0x4a(%rbx), %eax
movl %eax, 0x3c(%rbx)
movl 0x8(%r14), %edx
movl 0x30(%rbx), %eax
movl %eax, 0x34(%rbx)
leaq 0x38(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xca30
// File: /workspace/github_c_makefile_star2_O1/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, %r12d
movl %edx, 0x4(%rsp)
movl %esi, %r15d
movq %rdi, %r14
movq 0x30(%rdi), %rbx
movb 0x4a(%rbx), %dl
addb $0x3, %dl
movb %dl, 0x4a(%rbx)
movl 0x30(%rbx), %eax
movq (%rbx), %rcx
movq 0x30(%rcx), %rcx
movzbl %dl, %edx
leaq (%rbx,%rdx,2), %rdx
addq $0xbe, %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %edi
shll $0x4, %edi
movl %eax, 0x8(%rcx,%rdi)
incq %rsi
cmpq $0x3, %rsi
jne 0xf408
movq %r14, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0xcaf9
testl %ebp, %ebp
je 0xf44a
movl %r15d, %esi
shll $0x6, %esi
orl $0x7fff8020, %esi       # imm = 0x7FFF8020
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0xd83d
jmp 0xf452
movq %rbx, %rdi
callq 0xca74
movl %eax, %r13d
leaq 0x8(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
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 %r12d, %esi
callq 0xebef
movq %rbx, %rdi
movl %r12d, %esi
callq 0xdd9c
addl %r12d, 0x3c(%rbx)
movq %r14, %rdi
callq 0xc8a0
movq %rbx, %rdi
callq 0xf303
movl 0x30(%rbx), %eax
movl %eax, 0x34(%rbx)
leaq 0x38(%rbx), %rsi
movq %rbx, %rdi
movl %r13d, %edx
callq 0xca30
shll $0x6, %r15d
shll $0xe, %r12d
orl %r15d, %r12d
orl $0x21, %r12d
orl $0x7fff801f, %r15d      # imm = 0x7FFF801F
testl %ebp, %ebp
cmovel %r12d, %r15d
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0xd83d
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 0xf506
movq %rbx, %rdi
callq 0xca74
incl %r13d
movq %rbx, %rdi
movl %eax, %esi
movl %r13d, %edx
callq 0xf2db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf56b
testl %ebp, %ebp
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmovnsl %ebp, %r14d
leal 0x1(%r14), %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xea3a
testl %ebp, %ebp
jle 0xf5a0
movq %rbx, %rdi
movl %r14d, %esi
callq 0xdd9c
addl %r14d, 0x3c(%rbx)
jmp 0xf5a0
testl %eax, %eax
je 0xf57a
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xd79c
testl %ebp, %ebp
jle 0xf5a0
movl 0x3c(%rbx), %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0xdd9c
addl %ebp, 0x3c(%rbx)
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xdbf6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x3, %eax
ja 0xf66c
movq %rsi, %r15
leaq 0x4d9c(%rip), %rcx      # 0x14364
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0xc, (%r14)
jne 0xf5ec
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0xf5ec
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0xf5ec
decl 0x3c(%rbx)
movl 0x8(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd66a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd3bf
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x7, %esi
jmp 0xf65d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xddcb
movl %eax, %esi
movl 0x8(%r15), %eax
movl 0xc(%r15), %ecx
shll $0x6, %eax
shll $0x17, %ecx
shll $0xe, %esi
orl %eax, %esi
orl %ecx, %esi
orl $0x9, %esi
jmp 0xf65d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd3bf
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
orl $0x8, %esi
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0xd83d
cmpl $0xc, (%r14)
jne 0xf687
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0xf687
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0xf687
decl 0x3c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x975f
cmpl $0x3, 0x8(%rax)
je 0xf8fc
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x747e
testq %rax, %rax
je 0xf905
movsd (%rax), %xmm0
addq $0x18, %rsp
retq
xorps %xmm0, %xmm0
jmp 0xf900
// File: /workspace/github_c_makefile_star2_O1/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 0xf934
cmpl $0x7, %ecx
je 0xf926
cmpl $0x6, %ecx
jne 0xf953
movq -0x20(%rax), %rcx
movq -0x10(%rax), %rdx
movq %rdx, 0x18(%rcx)
jmp 0xf94a
movq -0x20(%rax), %rcx
movq -0x10(%rax), %rdx
movq %rdx, 0x78(%rcx)
movl $0x5, 0x80(%rcx)
movl $0x1, %ebp
xorl %ecx, %ecx
jmp 0xf957
xorl %ebp, %ebp
movb $0x1, %cl
testb %cl, %cl
jne 0xf994
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rsi
testb $0x3, 0x9(%rsi)
je 0xf994
movq -0x20(%rax), %rax
movb 0x9(%rax), %cl
testb $0x4, %cl
je 0xf994
movq 0x20(%rbx), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0xf986
callq 0x4593
jmp 0xf994
andb $-0x8, %cl
movb 0x20(%rdi), %dl
andb $0x3, %dl
orb %cl, %dl
movb %dl, 0x9(%rax)
addq $-0x10, 0x10(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4a6c(%rip), %rcx      # 0x14420
cmovbq %rdx, %rcx
movslq 0x8(%rcx), %rdx
cmpq $0x7, %rdx
je 0xf9c7
cmpl $0x5, %edx
jne 0xf9d0
movq (%rcx), %rcx
addq $0x10, %rcx
jmp 0xf9df
movq 0x20(%rdi), %rcx
leaq (%rcx,%rdx,8), %rcx
addq $0xe0, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xf9fc
movq %rcx, (%rax)
movl $0x5, 0x8(%rax)
addq $0x10, 0x10(%rdi)
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x975f
addq $0x10, %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jae 0xfa24
movq (%rax), %rcx
movq %rcx, -0x10(%rax)
movl 0x8(%rax), %ecx
movl %ecx, -0x8(%rax)
jmp 0xfa08
addq $-0x10, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
retq