LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xfb0f
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x4a(%rdi), %edx
testq %rdx, %rdx
jle 0xfb30
movq (%rbx), %rax
movq 0x30(%rax), %rax
movzwl 0xc2(%rbx,%rdx,2), %esi
decq %rdx
shll $0x4, %esi
cmpq %r15, (%rax,%rsi)
jne 0xfaa6
movq $-0x1, 0x10(%r14)
movl $0x6, (%r14)
movl %edx, 0x8(%r14)
movl $0x6, %eax
testl %ecx, %ecx
jne 0xfc5d
incq %rdx
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xfc5d
movzbl 0xc(%rbx), %ecx
cmpq %rcx, %rdx
jle 0xfaf1
movb $0x1, 0xd(%rbx)
jmp 0xfc5d
movq $-0x1, 0x10(%r14)
movl $0x8, (%r14)
movl $0xff, 0x8(%r14)
movl $0x8, %eax
jmp 0xfc5d
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xfa8b
movl %eax, %ecx
movl $0x8, %eax
cmpl $0x8, %ecx
je 0xfc5d
movq (%rbx), %r12
movslq 0x48(%r12), %r13
movzbl 0x70(%r12), %eax
testl %eax, %eax
je 0xfb90
movl (%r14), %edx
xorl %ecx, %ecx
movzbl 0x4b(%rbx,%rcx,2), %esi
cmpl %esi, %edx
jne 0xfb80
movzbl 0x4c(%rbx,%rcx,2), %esi
cmpl %esi, 0x8(%r14)
je 0xfc4d
incq %rcx
cmpq %rcx, %rax
jne 0xfb68
cmpb $0x3c, %al
jae 0xfc67
cmpl %eax, %r13d
jg 0xfbde
leaq 0x48(%r12), %rdx
movq 0x20(%rbx), %rdi
movq 0x38(%r12), %rsi
leaq 0x5d79(%rip), %r9       # 0x15923
movl $0x8, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xe350
movq %rax, 0x38(%r12)
movslq 0x48(%r12), %rax
cmpl %eax, %r13d
jge 0xfbde
movq 0x38(%r12), %rcx
movq $0x0, (%rcx,%r13,8)
incq %r13
cmpq %r13, %rax
jne 0xfbc9
movq 0x38(%r12), %rdx
movzbl 0x70(%r12), %ecx
movl %ecx, %eax
movq %r15, (%rdx,%rcx,8)
testb $0x3, 0x9(%r15)
je 0xfc33
movb 0x9(%r12), %dl
testb $0x4, %dl
je 0xfc33
movq 0x20(%rbx), %rsi
movq 0x20(%rsi), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0xfc20
movq %r15, %rsi
callq 0x46ab
movb 0x70(%r12), %al
movzbl %al, %ecx
jmp 0xfc33
andb $-0x8, %dl
movb 0x20(%rdi), %sil
andb $0x3, %sil
orb %dl, %sil
movb %sil, 0x9(%r12)
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, %ecx
movl %ecx, 0x8(%r14)
movl $0x7, (%r14)
movl $0x7, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6033(%rip), %rdx      # 0x15ca1
movq %rbx, %rdi
movl $0x3c, %esi
callq 0xf45a
// File: /workspace/github_c_makefile_star2_O3/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 0xd5a1
movq %r14, %rdi
movl $0x2c, %esi
callq 0xd1ff
movl $0x1, %ebp
testl %eax, %eax
je 0xfccc
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0xe1f0
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd5a1
incl %ebp
movq %r14, %rdi
movl $0x2c, %esi
callq 0xd1ff
jmp 0xfc9e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xb, (%rsi)
jne 0xfd21
movq (%rbx), %rax
movq 0x18(%rax), %rax
movslq 0x8(%r14), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
andl $0x3f, %ecx
cmpl $0x13, %ecx
jne 0xfd21
decl 0x30(%rbx)
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
shrl $0x11, %eax
andl $-0x40, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x1a, %esi
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
jmp 0xfd65
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe9d9
cmpl $0xc, (%r14)
jne 0xfd47
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0xfd47
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0xfd47
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 0xe291
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd417
// File: /workspace/github_c_makefile_star2_O3/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 0xe900
movl %eax, %r12d
movq %r14, %rdi
movq %r13, %rsi
callq 0xe900
cmpl $0xc, (%r13)
jne 0xfdc3
movl 0x8(%r13), %ecx
btl $0x8, %ecx
jb 0xfdc3
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xfdc3
decl 0x3c(%r14)
cmpl $0xc, (%rbx)
jne 0xfdde
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0xfdde
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xfdde
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 0xe291
movq %r14, %rdi
callq 0xd417
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_O3/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
cmpl %r8d, 0x30(%rdi)
jne 0xfe58
movl %r8d, 0x34(%rdi)
leaq 0x38(%rdi), %rsi
jmp 0xd3d7
movl %edx, %esi
movl %r8d, %edx
movl $0xff, %ecx
jmp 0xe3c8
// File: /workspace/github_c_makefile_star2_O3/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 0xfeb9
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 0xfe9c
movb %dl, 0x4a(%rcx)
cmpb $0x0, 0xd(%r14)
je 0xfed1
shll $0x6, %esi
orl $0x23, %esi
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0xe291
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 0xd3d7
// File: /workspace/github_c_makefile_star2_O3/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, %r12d
movl %ecx, %r15d
movl %edx, 0x4(%rsp)
movl %esi, %r14d
movq %rdi, %rbp
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 0xff6c
movq %rbp, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0xd49c
testl %r12d, %r12d
je 0xffaf
movl %r14d, %esi
shll $0x6, %esi
orl $0x7fff8020, %esi       # imm = 0x7FFF8020
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0xe291
jmp 0xffb7
movq %rbx, %rdi
callq 0xd417
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 0x30(%rbp), %rsi
movb 0x4a(%rsi), %dil
addb %r15b, %dil
movb %dil, 0x4a(%rsi)
testl %r15d, %r15d
je 0x10022
movl 0x30(%rsi), %eax
movq (%rsi), %rcx
movq 0x30(%rcx), %rcx
movslq %r15d, %rdx
negq %rdx
movzbl %dil, %edi
leaq (%rsi,%rdi,2), %rsi
addq $0xc4, %rsi
movzwl (%rsi,%rdx,2), %edi
shll $0x4, %edi
movl %eax, 0x8(%rcx,%rdi)
incq %rdx
jne 0x10012
movq %rbx, %rdi
movl %r15d, %esi
callq 0xe8d1
addl %r15d, 0x3c(%rbx)
movq %rbp, %rdi
callq 0xd247
movq %rbx, %rdi
callq 0xfe67
movl 0x30(%rbx), %eax
movl %eax, 0x34(%rbx)
leaq 0x38(%rbx), %rsi
movq %rbx, %rdi
movl %r13d, %edx
callq 0xd3d7
shll $0x6, %r14d
testl %r12d, %r12d
je 0x1008d
orl $0x7fff801f, %r14d      # imm = 0x7FFF801F
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe291
movq (%rbx), %rcx
movslq 0x30(%rbx), %rdx
movq 0x28(%rcx), %rcx
movl 0x4(%rsp), %esi
movl %esi, -0x4(%rcx,%rdx,4)
jmp 0x100c5
shll $0xe, %r15d
orl %r15d, %r14d
orl $0x21, %r14d
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe291
movq (%rbx), %rax
movslq 0x30(%rbx), %rcx
movq 0x28(%rax), %rax
movl 0x4(%rsp), %edx
movl %edx, -0x4(%rax,%rcx,4)
movq %rbx, %rdi
callq 0xd417
incl %r13d
movq %rbx, %rdi
movl %eax, %esi
movl %r13d, %edx
callq 0xfe40
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %rbx
subl %edx, %ebp
movl (%rcx), %eax
leal -0xd(%rax), %edx
cmpl $0x2, %edx
jae 0x10129
testl %ebp, %ebp
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmovnsl %ebp, %r14d
leal 0x1(%r14), %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xf56f
testl %ebp, %ebp
jle 0x1015e
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe8d1
addl %r14d, 0x3c(%rbx)
jmp 0x1015e
testl %eax, %eax
je 0x10138
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xe1f0
testl %ebp, %ebp
jle 0x1015e
movl 0x3c(%rbx), %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe8d1
addl %ebp, 0x3c(%rbx)
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xe646
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1022a
movq %rsi, %r15
leaq 0x5256(%rip), %rcx      # 0x153dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0xc, (%r14)
jne 0x101aa
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x101aa
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x101aa
decl 0x3c(%rbx)
movl 0x8(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe0ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0xde0f
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x7, %esi
jmp 0x1021b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe900
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 0x1021b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xde0f
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 0xe291
cmpl $0xc, (%r14)
jne 0x10245
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x10245
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x10245
decl 0x3c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9d4e
cmpl $0x3, 0x8(%rax)
je 0x104b0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x7756
testq %rax, %rax
je 0x104b9
movsd (%rax), %xmm0
addq $0x18, %rsp
retq
xorps %xmm0, %xmm0
jmp 0x104b4
// File: /workspace/github_c_makefile_star2_O3/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 0x104ea
cmpl $0x7, %ecx
je 0x104dc
xorl %ebp, %ebp
cmpl $0x6, %ecx
jne 0x1053e
movq -0x20(%rax), %rcx
movq -0x10(%rax), %rdx
movq %rdx, 0x18(%rcx)
jmp 0x10500
movq -0x20(%rax), %rcx
movq -0x10(%rax), %rdx
movq %rdx, 0x78(%rcx)
movl $0x5, 0x80(%rcx)
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rsi
movl $0x1, %ebp
testb $0x3, 0x9(%rsi)
je 0x1053e
movq -0x20(%rax), %rax
movb 0x9(%rax), %cl
testb $0x4, %cl
je 0x1053e
movq 0x20(%rbx), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x10530
callq 0x46ab
jmp 0x1053e
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_O3/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 0x4f3a(%rip), %rcx      # 0x15498
cmovbq %rdx, %rcx
movslq 0x8(%rcx), %rdx
cmpq $0x7, %rdx
je 0x10571
cmpl $0x5, %edx
jne 0x1057a
movq (%rcx), %rcx
addq $0x10, %rcx
jmp 0x10589
movq 0x20(%rdi), %rcx
leaq (%rcx,%rdx,8), %rcx
addq $0xe0, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x105a6
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_O3/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 0x9d4e
addq $0x10, %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jae 0x105ce
movq (%rax), %rcx
movq %rcx, -0x10(%rax)
movl 0x8(%rax), %ecx
movl %ecx, -0x8(%rax)
jmp 0x105b2
addq $-0x10, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9d4e
movq %rax, %rbx
movl 0x8(%rax), %ecx
xorl %eax, %eax
addl $-0x3, %ecx
cmpl $0x4, %ecx
ja 0x10633
leaq 0x4df1(%rip), %rdx      # 0x153ec
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51cc
testl %eax, %eax
je 0x10631
movq (%rbx), %rax
movq 0x10(%rax), %rax
jmp 0x10633
movq (%rbx), %rdi
callq 0x75c6
cltq
jmp 0x10633
movq (%rbx), %rax
movq 0x20(%rax), %rax
jmp 0x10633
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_checkstack
static int lua_checkstack(lua_State*L,int size){
int res=1;
if(size>8000||(L->top-L->base+size)>8000)
res=0;
else if(size>0){
luaD_checkstack(L,size);
if(L->ci->top<L->top+size)
L->ci->top=L->top+size;
}
return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpl $0x1f40, %esi           # imm = 0x1F40
jg 0x106b7
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, %rcx
subq 0x18(%rdi), %rcx
sarq $0x4, %rcx
movslq %esi, %r15
addq %r15, %rcx
cmpq $0x1f40, %rcx           # imm = 0x1F40
jg 0x106b7
movl $0x1, %ebx
testl %esi, %esi
jle 0x106b7
movq 0x38(%r14), %rcx
subq %rax, %rcx
movl %esi, %edx
shll $0x4, %edx
cmpq %rdx, %rcx
jg 0x106a2
movl 0x58(%r14), %ecx
leal (%rcx,%rsi), %edx
leal (%rcx,%rcx), %eax
cmpl %esi, %ecx
cmovll %edx, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x50e7
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
shlq $0x4, %r15
addq %rax, %r15
cmpq %r15, 0x10(%rcx)
jae 0x106b7
movq %r15, 0x10(%rcx)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_rawgeti
static void lua_rawgeti(lua_State*L,int idx,int n){
StkId o;
o=index2adr(L,idx);
luai_apicheck(L,ttistable(o));
setobj(L,L->top,luaH_getnum(hvalue(o),n));
api_incr_top(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
callq 0x9d4e
movq (%rax), %rdi
movl %ebx, %esi
callq 0x7984
movq 0x10(%r14), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_newuserdata
static void*lua_newuserdata(lua_State*L,size_t size){
Udata*u;
luaC_checkGC(L);
u=luaS_newudata(L,size,getcurrenv(L));
setuvalue(L,L->top,u);
api_incr_top(L);
return u+1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x10715
movq %rbx, %rdi
callq 0x6bbf
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x1072c
movq 0x8(%rax), %rax
movq (%rax), %rax
addq $0x18, %rax
jmp 0x10730
leaq 0x78(%rbx), %rax
movq (%rax), %r15
leaq 0x28(%r14), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x43d1
movq 0x20(%rbx), %rcx
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0x7, 0x8(%rax)
movq %r14, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq %rax, (%rcx)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x7, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
addq $0x28, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tconcat
static int tconcat(lua_State*L){
luaL_Buffer b;
size_t lsep;
int i,last;
const char*sep=luaL_optlstring(L,2,"",&lsep);
luaL_checktype(L,1,5);
i=luaL_optint(L,3,1);
last=luaL_opt(L,luaL_checkint,4,luaL_getn(L,1));
luaL_buffinit(L,&b);
for(;i<last;i++){
addfield(L,&b,i);
luaL_addlstring(&b,sep,lsep);
}
if(i==last)
addfield(L,&b,i);
luaL_pushresult(&b);
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %rbx
leaq 0x5169(%rip), %rdx      # 0x15923
movq %rsp, %rcx
movl $0x2, %esi
callq 0xaa03
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
movl $0x1, %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0xb093
movq %rax, %r15
movq 0x18(%rbx), %rax
leaq 0x30(%rax), %rcx
cmpq 0x10(%rbx), %rcx
setae %dl
leaq 0x4c91(%rip), %rsi      # 0x15498
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0x10826
cmpl $0x0, 0x38(%rax)
jle 0x10826
movq %rbx, %rdi
movl $0x4, %esi
callq 0xb0cc
jmp 0x10833
movq %rbx, %rdi
movl $0x1, %esi
callq 0x105d8
movq %rax, %r12
leaq 0x20(%rsp), %rax
movq %rbx, -0x8(%rax)
movq %rax, -0x18(%rax)
movl $0x0, -0x10(%rax)
cmpl %r12d, %r15d
jge 0x1087b
leaq 0x8(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x10bf8
movq (%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x10c63
incl %r15d
cmpl %r15d, %r12d
jne 0x10854
jmp 0x1087d
jne 0x1088d
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0x10bf8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10d41
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0xaedf
movl $0x1, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tinsert
static int tinsert(lua_State*L){
int e=aux_getn(L,1)+1;
int pos;
switch(lua_gettop(L)){
case 2:{
pos=e;
break;
}
case 3:{
int i;
pos=luaL_checkint(L,2);
if(pos>e)e=pos;
for(i=e;i>pos;i--){
lua_rawgeti(L,1,i-1);
lua_rawseti(L,1,i);
}
break;
}
default:{
return luaL_error(L,"wrong number of arguments to "LUA_QL("insert"));
}
}
luaL_setn(L,1,e);
lua_rawseti(L,1,pos);
return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x105d8
movq %rax, %r14
movq 0x10(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x4, %rax
cmpl $0x2, %eax
je 0x10941
cmpl $0x3, %eax
jne 0x10964
movq %rbx, %rdi
movl $0x2, %esi
callq 0xb0cc
movq %rax, %r15
cmpl %r15d, %r14d
jl 0x10947
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x106bf
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x3930
leal -0x1(%r14), %eax
cmpl %r15d, %r14d
movl %eax, %r14d
jg 0x10910
jmp 0x10947
incl %r14d
movl %r14d, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x3930
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x55d5(%rip), %rsi      # 0x15f40
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tremove
static int tremove(lua_State*L){
int e=aux_getn(L,1);
int pos=luaL_optint(L,2,e);
if(!(1<=pos&&pos<=e))
return 0;
luaL_setn(L,1,e-1);
lua_rawgeti(L,1,pos);
for(;pos<e;pos++){
lua_rawgeti(L,1,pos+1);
lua_rawseti(L,1,pos);
}
lua_pushnil(L);
lua_rawseti(L,1,e);
return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x105d8
movq %rax, %r14
movslq %r14d, %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0xb093
movq %rax, %r15
testl %r15d, %r15d
setle %al
cmpl %r12d, %r15d
setg %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x10a30
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x106bf
cmpl %r14d, %r15d
jge 0x10a0d
leal 0x1(%r15), %r12d
movq %rbx, %rdi
movl $0x1, %esi
movl %r12d, %edx
callq 0x106bf
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x3930
movl %r12d, %r15d
cmpl %r12d, %r14d
jne 0x109e1
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x3930
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: sort
static int sort(lua_State*L){
int n=aux_getn(L,1);
luaL_checkstack(L,40,"");
if(!lua_isnoneornil(L,2))
luaL_checktype(L,2,6);
lua_settop(L,2);
auxsort(L,1,n);
return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x105d8
movq %rax, %r14
leaq 0x4ebb(%rip), %rdx      # 0x15923
movq %rbx, %rdi
movl $0x28, %esi
callq 0x10e19
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
leaq 0x10(%rax), %rdx
cmpq %rcx, %rdx
setae %sil
leaq 0x4a09(%rip), %rdi      # 0x15498
cmpq %rdi, %rdx
sete %dl
orb %sil, %dl
jne 0x10aba
cmpl $0x0, 0x18(%rax)
jle 0x10aba
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x1043a
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
addq $0x20, %rax
cmpq %rax, %rcx
jae 0x10bda
leaq 0x10(%rcx), %rsi
cmpq %rsi, %rax
cmovaq %rax, %rsi
movq %rcx, %rdx
notq %rdx
addq %rsi, %rdx
movq %rdx, %xmm0
shrq $0x4, %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
addq $0x38, %rcx
xorl %esi, %esi
movdqa 0x450c(%rip), %xmm1     # 0x15010
movdqa 0x4514(%rip), %xmm2     # 0x15020
movdqa 0x451c(%rip), %xmm3     # 0x15030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x10b66
movl $0x0, -0x30(%rcx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x10b7c
movl $0x0, -0x20(%rcx)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0x10bb8
movl $0x0, -0x10(%rcx)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x10bc9
movl $0x0, (%rcx)
addq $0x4, %rsi
addq $0x40, %rcx
cmpq %rsi, %rdx
jne 0x10b1c
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x10e48
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: addfield
static void addfield(lua_State*L,luaL_Buffer*b,int i){
lua_rawgeti(L,1,i);
if(!lua_isstring(L,-1))
luaL_error(L,"invalid value (%s) at index %d in table for "
LUA_QL("concat"),luaL_typename(L,-1),i);
luaL_addvalue(b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %esi
callq 0x106bf
movq 0x10(%r14), %rax
leaq -0x10(%rax), %rcx
leaq 0x4e40(%rip), %rdx      # 0x15a5e
leaq 0x4873(%rip), %rsi      # 0x15498
cmpq %rsi, %rcx
je 0x10c50
movslq -0x8(%rax), %rax
leal -0x5(%rax), %ecx
cmpl $-0x3, %ecx
jbe 0x10c40
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10cbf
cmpl $-0x1, %eax
je 0x10c50
leaq 0xac14(%rip), %rcx      # 0x1b860
movq (%rcx,%rax,8), %rdx
leaq 0x52b4(%rip), %rsi      # 0x15f0b
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_addvalue
static void luaL_addvalue(luaL_Buffer*B){
lua_State*L=B->L;
size_t vl;
const char*s=lua_tolstring(L,-1,&vl);
if(vl<=bufffree(B)){
memcpy(B->p,s,vl);
B->p+=vl;
lua_pop(L,1);
}
else{
if(emptybuffer(B))
lua_insert(L,-2);
B->lvl++;
adjuststack(B);
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x3d8d
movq (%r15), %rdx
movq (%rbx), %rdi
movq %rbx, %rcx
subq %rdi, %rcx
addq $0x2018, %rcx           # imm = 0x2018
cmpq %rcx, %rdx
jbe 0x10d22
movq %rbx, %rdi
callq 0x10d41
testl %eax, %eax
je 0x10d15
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xb16b
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0x10d77
jmp 0x10d37
movq %rax, %rsi
callq 0x31b0
movq 0x8(%rsp), %rax
addq %rax, (%rbx)
addq $-0x10, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: emptybuffer
static int emptybuffer(luaL_Buffer*B){
size_t l=bufflen(B);
if(l==0)return 0;
else{
lua_pushlstring(B->L,B->buffer,l);
B->p=B->buffer;
B->lvl++;
return 1;
}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rdx
leaq 0x18(%rdi), %r14
subq %r14, %rdx
je 0x10d6d
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %r14, %rsi
callq 0x94a5
movq %r14, (%rbx)
incl 0x8(%rbx)
movl $0x1, %eax
jmp 0x10d6f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: adjuststack
static void adjuststack(luaL_Buffer*B){
if(B->lvl>1){
lua_State*L=B->L;
int toget=1;
size_t toplen=lua_strlen(L,-1);
do{
size_t l=lua_strlen(L,-(toget+1));
if(B->lvl-toget+1>=(20/2)||toplen>l){
toplen+=l;
toget++;
}
else break;
}while(toget<B->lvl);
lua_concat(L,toget);
B->lvl=B->lvl-toget+1;
}
}

// Assembly:
cmpl $0x2, 0x8(%rdi)
jl 0x10e18
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x105d8
movq %rax, %r15
xorl %r13d, %r13d
movl %ebp, %r12d
leal -0x1(%r12), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x105d8
movl 0x8(%rbx), %edx
addl %edx, %r12d
cmpl $0x9, %r12d
setge %sil
cmpq %rax, %r15
seta %cl
orb %sil, %cl
leal 0x1(%r13), %r12d
cmpb $0x1, %cl
jne 0x10dec
addl $0x2, %r13d
addq %rax, %r15
cmpl %edx, %r13d
movl %r12d, %r13d
jl 0x10dab
negl %ebp
testb %cl, %cl
cmovnel %ebp, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0xaedf
movl 0x8(%rbx), %eax
subl %r12d, %eax
incl %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: sort_comp
static int sort_comp(lua_State*L,int a,int b){
if(!lua_isnil(L,2)){
int res;
lua_pushvalue(L,2);
lua_pushvalue(L,a-1);
lua_pushvalue(L,b-2);
lua_call(L,2,1);
res=lua_toboolean(L,-1);
lua_pop(L,1);
return res;
}
else
return lua_lessthan(L,a,b);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
addq $0x10, %rcx
cmpq %rax, %rcx
leaq 0x42d7(%rip), %rdx      # 0x15498
cmovaeq %rdx, %rcx
cmpq %rdx, %rcx
je 0x111d4
cmpl $0x0, 0x8(%rcx)
je 0x1126b
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
decl %esi
movq %rbx, %rdi
callq 0x9d4e
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9d4e
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x20, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x53b2
movq 0x10(%rbx), %rcx
movl -0x8(%rcx), %eax
testl %eax, %eax
je 0x1125e
cmpl $0x1, %eax
jne 0x11259
xorl %eax, %eax
cmpl $0x0, -0x10(%rcx)
setne %al
jmp 0x1125e
movl $0x1, %eax
addq $-0x10, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x9d4e
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9d4e
movq %rax, %rdx
leaq 0x420e(%rip), %rax      # 0x15498
cmpq %rax, %r14
sete %cl
cmpq %rax, %rdx
sete %sil
xorl %eax, %eax
orb %cl, %sil
jne 0x11266
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x76e5
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_fclose
static int io_fclose(lua_State*L){
FILE**p=tofilep(L);
int ok=(fclose(*p)==0);
*p=NULL;
return pushresult(L,ok,NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1168b
movq %rax, %r14
movq (%rax), %rdi
callq 0x30d0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq $0x0, (%r14)
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11765
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_replace
static void lua_replace(lua_State*L,int idx){
StkId o;
if(idx==(-10001)&&L->ci==L->base_ci)
luaG_runerror(L,"no calling environment");
api_checknelems(L,1);
o=index2adr(L,idx);
api_checkvalidindex(L,o);
if(idx==(-10001)){
Closure*func=curr_func(L);
luai_apicheck(L,ttistable(L->top-1));
func->c.env=hvalue(L->top-1);
luaC_barrier(L,func,L->top-1);
}
else{
setobj(L,o,L->top-1);
if(idx<(-10002))
luaC_barrier(L,curr_func(L),L->top-1);
}
L->top--;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
jne 0x11376
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x113eb
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x9d4e
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rbx), %rcx
cmpl $0x4, -0x8(%rcx)
jl 0x113df
movq -0x10(%rcx), %rsi
testb $0x3, 0x9(%rsi)
jne 0x113b8
jmp 0x113df
movl %esi, %ebp
movq %rbx, %rdi
callq 0x9d4e
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, (%rax)
movl -0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
cmpl $0xffffd8ed, %ebp       # imm = 0xFFFFD8ED
jg 0x113df
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x113df
movq -0x10(%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0x113df
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movb 0x9(%rax), %cl
testb $0x4, %cl
je 0x113df
movq 0x20(%rbx), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x113d1
callq 0x46ab
jmp 0x113df
andb $-0x8, %cl
movb 0x20(%rdi), %dl
andb $0x3, %dl
orb %cl, %dl
movb %dl, 0x9(%rax)
addq $-0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4c42(%rip), %rsi      # 0x16034
movq %rbx, %rdi
xorl %eax, %eax
callq 0x47e0
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: createstdfile
static void createstdfile(lua_State*L,FILE*f,int k,const char*fname){
*newfile(L)=f;
if(k>0){
lua_pushvalue(L,-1);
lua_rawseti(L,(-10001),k);
}
lua_pushvalue(L,-2);
lua_setfenv(L,-2);
lua_setfield(L,-3,fname);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0x122dc
movq %r15, (%rax)
testl %ebp, %ebp
jle 0x1146b
movq 0x10(%r14), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl %ebp, %edx
callq 0x3930
movq 0x10(%r14), %rax
movq -0x20(%rax), %rcx
movq %rcx, (%rax)
movl -0x18(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
callq 0x104be
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x39af
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_getfield
static void lua_getfield(lua_State*L,int idx,const char*k){
StkId t;
TValue key;
t=index2adr(L,idx);
api_checkvalidindex(L,t);
setsvalue(L,&key,luaS_new(L,k));
luaV_gettable(L,t,&key,L->top);
api_incr_top(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
callq 0x9d4e
movq %rax, %r15
movq %rbx, %rdi
callq 0x30e0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4265
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x4, 0x8(%rdx)
movq 0x10(%r14), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7194
addq $0x10, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_pclose
static int io_pclose(lua_State*L){
FILE**p=tofilep(L);
int ok=lua_pclose(L,*p);
*p=NULL;
return pushresult(L,ok,NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1168b
movq $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0x11765
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_close
static int io_close(lua_State*L){
if(lua_isnone(L,1))
lua_rawgeti(L,(-10001),2);
tofile(L);
return aux_close(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq 0x3f71(%rip), %rcx      # 0x15498
cmpq %rcx, %rax
je 0x11538
cmpq 0x10(%rbx), %rax
jae 0x11538
cmpl $-0x1, 0x8(%rax)
jne 0x1154a
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x2, %edx
callq 0x106bf
movq %rbx, %rdi
callq 0x115ed
movq %rbx, %rdi
popq %rbx
jmp 0x11611
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_gc
static int io_gc(lua_State*L){
FILE*f=*tofilep(L);
if(f!=NULL)
aux_close(L);
return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1168b
cmpq $0x0, (%rax)
je 0x115e9
movq %rbx, %rdi
callq 0x11611
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tofile
static FILE*tofile(lua_State*L){
FILE**f=tofilep(L);
if(*f==NULL)
luaL_error(L,"attempt to use a closed file");
return*f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1168b
movq (%rax), %rax
testq %rax, %rax
je 0x11600
popq %rbx
retq
leaq 0x49bc(%rip), %rsi      # 0x15fc3
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_checkudata
static void*luaL_checkudata(lua_State*L,int ud,const char*tname){
void*p=lua_touserdata(L,ud);
if(p!=NULL){
if(lua_getmetatable(L,ud)){
lua_getfield(L,(-10000),tname);
if(lua_rawequal(L,-1,-2)){
lua_pop(L,2);
return p;
}
}
}
luaL_typerror(L,ud,tname);
return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
leaq 0x3df7(%rip), %rax      # 0x15498
cmovbq %rcx, %rax
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x116bb
cmpl $0x7, %ecx
jne 0x11709
movq (%rax), %r14
addq $0x28, %r14
jmp 0x116c3
movq (%rax), %r14
testq %r14, %r14
je 0x11709
movq %rbx, %rdi
callq 0x1054c
testl %eax, %eax
je 0x11709
leaq 0x48db(%rip), %rdx      # 0x15fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x114a3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x1171d
testl %eax, %eax
je 0x11709
addq $-0x20, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x48a1(%rip), %rdx      # 0x15fb1
movq %rbx, %rdi
movl $0x1, %esi
callq 0xb038
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_rawequal
static int lua_rawequal(lua_State*L,int index1,int index2){
StkId o1=index2adr(L,index1);
StkId o2=index2adr(L,index2);
return(o1==(&luaO_nilobject_)||o2==(&luaO_nilobject_))?0
:luaO_rawequalObj(o1,o2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %r14
callq 0x9d4e
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x9d4e
leaq 0x3d59(%rip), %rcx      # 0x15498
cmpq %rcx, %rbx
sete %dl
cmpq %rcx, %rax
sete %cl
orb %dl, %cl
je 0x11756
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ab2
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: pushresult
static int pushresult(lua_State*L,int i,const char*filename){
int en=errno;
if(i){
lua_pushboolean(L,1);
return 1;
}
else{
lua_pushnil(L);
if(filename)
lua_pushfstring(L,"%s: %s",filename,strerror(en));
else
lua_pushfstring(L,"%s",strerror(en));
lua_pushinteger(L,en);
return 3;
}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3050
movq 0x10(%rbx), %rcx
testl %ebp, %ebp
je 0x1178b
movl $0x1, (%rcx)
movl $0x1, %eax
jmp 0x117e6
movl (%rax), %ebp
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
movq %rcx, 0x10(%rbx)
movl %ebp, %edi
callq 0x32c0
testq %r14, %r14
je 0x117c1
leaq 0x4b66(%rip), %rsi      # 0x16315
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xaf5c
jmp 0x117d5
leaq 0x3ea7(%rip), %rsi      # 0x1566f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xaf5c
movq 0x10(%rbx), %rcx
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rcx)
movl $0x3, %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: read_line
static int read_line(lua_State*L,FILE*f){
luaL_Buffer b;
luaL_buffinit(L,&b);
for(;;){
size_t l;
char*p=luaL_prepbuffer(&b);
if(fgets(p,BUFSIZ,f)==NULL){
luaL_pushresult(&b);
return(lua_objlen(L,-1)>0);
}
l=strlen(p);
if(l==0||p[l-1]!='\n')
luaL_addsize(&b,l);
else{
luaL_addsize(&b,l-1);
luaL_pushresult(&b);
return 1;
}
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %rdi, -0x8(%r15)
movq %r15, -0x18(%r15)
movl $0x0, -0x10(%r15)
movq %rsp, %r12
movq %r12, %rdi
callq 0x10d41
testl %eax, %eax
je 0x11ac2
movq %r12, %rdi
callq 0x10d77
movq %r15, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdx
callq 0x3150
testq %rax, %rax
je 0x11af1
movq %r15, %rdi
callq 0x30e0
testq %rax, %rax
je 0x11aeb
cmpb $0xa, 0x17(%rsp,%rax)
je 0x11b2b
addq %rax, (%rsp)
jmp 0x11aae
movq %rsp, %r14
movq %r14, %rdi
callq 0x10d41
movq 0x10(%r14), %rdi
movl 0x8(%r14), %esi
callq 0xaedf
movl $0x1, 0x8(%r14)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x105d8
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x11b4d
decq %rax
movq %rsp, %rbx
addq %rax, (%rbx)
movq %rbx, %rdi
callq 0x10d41
movq 0x10(%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0xaedf
movl $0x1, %eax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: read_chars
static int read_chars(lua_State*L,FILE*f,size_t n){
size_t rlen;
size_t nr;
luaL_Buffer b;
luaL_buffinit(L,&b);
rlen=BUFSIZ;
do{
char*p=luaL_prepbuffer(&b);
if(rlen>n)rlen=n;
nr=fread(p,sizeof(char),rlen,f);
luaL_addsize(&b,nr);
n-=nr;
}while(n>0&&nr==rlen);
luaL_pushresult(&b);
return(n==0||lua_objlen(L,-1)>0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %rdi, -0x8(%r12)
movq %r12, -0x18(%r12)
movl $0x0, -0x10(%r12)
movl $0x2000, %r13d          # imm = 0x2000
movq %rsp, %rbp
movq %rbp, %rdi
callq 0x10d41
testl %eax, %eax
je 0x11db2
movq %rbp, %rdi
callq 0x10d77
cmpq %r14, %r13
cmovaeq %r14, %r13
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x30a0
addq %rax, (%rsp)
subq %rax, %r14
cmpq %r13, %rax
jne 0x11ddd
testq %r14, %r14
jne 0x11d9e
movq %rsp, %r15
movq %r15, %rdi
callq 0x10d41
movq 0x10(%r15), %rdi
movl 0x8(%r15), %esi
callq 0xaedf
movl $0x1, 0x8(%r15)
testq %r14, %r14
je 0x11e1c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x105d8
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x11e21
movl $0x1, %eax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: g_write
static int g_write(lua_State*L,FILE*f,int arg){
int nargs=lua_gettop(L)-1;
int status=1;
for(;nargs--;arg++){
if(lua_type(L,arg)==3){
status=status&&
fprintf(f,"%.14g",lua_tonumber(L,arg))>0;
}
else{
size_t l;
const char*s=luaL_checklstring(L,arg,&l);
status=status&&(fwrite(s,sizeof(char),l,f)==l);
}
}
return pushresult(L,status,NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r12
subq 0x18(%rdi), %r12
shrq $0x4, %r12
decl %r12d
je 0x11ee7
movl %edx, %ebp
movq %rsi, %r14
movl $0x1, %r13d
leaq 0x3630(%rip), %r15      # 0x15498
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9d4e
cmpq %r15, %rax
je 0x11ea8
cmpl $0x3, 0x8(%rax)
jne 0x11ea8
testl %r13d, %r13d
je 0x11edb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1048f
movq %r14, %rdi
leaq 0x3813(%rip), %rsi      # 0x156a9
movb $0x1, %al
callq 0x3180
xorl %r13d, %r13d
testl %eax, %eax
setg %r13b
jmp 0x11ede
movq %rbx, %rdi
movl %ebp, %esi
movq %rsp, %rdx
callq 0xb00c
testl %r13d, %r13d
je 0x11edb
movq (%rsp), %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rcx
callq 0x32b0
xorl %r13d, %r13d
cmpq (%rsp), %rax
sete %r13b
jmp 0x11ede
xorl %r13d, %r13d
incl %ebp
decl %r12d
jne 0x11e68
jmp 0x11eed
movl $0x1, %r13d
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x11765
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_lines
static int io_lines(lua_State*L){
if(lua_isnoneornil(L,1)){
lua_rawgeti(L,(-10001),1);
return f_lines(L);
}
else{
const char*filename=luaL_checkstring(L,1);
FILE**pf=newfile(L);
*pf=fopen(filename,"r");
if(*pf==NULL)
fileerror(L,1,filename);
aux_lines(L,lua_gettop(L),1);
return 1;
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq 0x353a(%rip), %rcx      # 0x15498
cmpq %rcx, %rax
je 0x11fb9
cmpq 0x10(%rbx), %rax
jae 0x11fb9
cmpl $0x0, 0x8(%rax)
jle 0x11fb9
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xb00c
movq %rax, %r14
movq %rbx, %rdi
callq 0x122dc
movq %rax, %r15
leaq 0x429c(%rip), %rsi      # 0x1622f
movq %r14, %rdi
callq 0x3250
movq %rax, (%r15)
testq %rax, %rax
je 0x11fed
movq 0x10(%rbx), %rsi
subq 0x18(%rbx), %rsi
shrq $0x4, %rsi
movq %rbx, %rdi
movl $0x1, %edx
jmp 0x11fdd
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x1, %edx
callq 0x106bf
movq %rbx, %rdi
callq 0x115ed
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x117f3
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12323
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_open
static int io_open(lua_State*L){
const char*filename=luaL_checkstring(L,1);
const char*mode=luaL_optstring(L,2,"r");
FILE**pf=newfile(L);
*pf=fopen(filename,mode);
return(*pf==NULL)?pushresult(L,0,filename):1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0xb00c
movq %rax, %r14
leaq 0x4216(%rip), %rdx      # 0x1622f
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0xaa03
movq %rax, %r15
movq %rbx, %rdi
callq 0x122dc
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, (%r12)
testq %rax, %rax
je 0x1205b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11765