LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl 0x18(%rsp), %eax
subl $0x1, %eax
movl $0x32, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x10(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x1807a
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x18082
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x1ff, 0x10(%rsp)      # imm = 0x1FF
jg 0x180b2
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0xc(%rsp), %ecx
movl 0x10(%rsp), %r8d
movl $0x22, %esi
callq 0x164d0
jmp 0x180e6
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x22, %esi
xorl %r8d, %r8d
callq 0x164d0
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %edx
callq 0x16660
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x3c(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, 0x60(%rax)
jne 0x18146
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
leaq 0xac84(%rip), %rsi      # 0x22dbd
movb $0x0, %al
callq 0x5fc0
movq %rax, (%rsp)
jmp 0x18175
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x60(%rax), %edx
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %r8
leaq 0xac75(%rip), %rsi      # 0x22ddf
movb $0x0, %al
callq 0x5fc0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x138d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x122d0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x153c0
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x17550
movq 0x10(%rsp), %rdi
movl $0x5d, %esi
callq 0x15390
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x11d, %esi            # imm = 0x11D
callq 0x123e0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x122d0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x8(%rsp), %rax
cmpl $0xd, (%rax)
jne 0x182e8
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0xff803fff, %edx       # imm = 0xFF803FFF
movl 0x4(%rsp), %eax
addl $0x1, %eax
shll $0xe, %eax
andl $0x7fc000, %eax         # imm = 0x7FC000
orl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x18396
movq 0x8(%rsp), %rax
cmpl $0xe, (%rax)
jne 0x18394
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl 0x4(%rsp), %eax
addl $0x1, %eax
shll $0x17, %eax
andl $0xff800000, %eax       # imm = 0xFF800000
orl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
movq 0x10(%rsp), %rax
movl 0x3c(%rax), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x17170
jmp 0x18396
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl 0x4a(%rax), %eax
addl -0xc(%rsp), %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movb %cl, 0x4a(%rax)
cmpl $0x0, -0xc(%rsp)
je 0x184ad
movq -0x18(%rsp), %rax
movl 0x30(%rax), %ecx
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x18(%rsp), %rdx
movq -0x18(%rsp), %rsi
movzbl 0x4a(%rsi), %esi
subl -0xc(%rsp), %esi
movslq %esi, %rsi
movzwl 0xc4(%rdx,%rsi,2), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1845e
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: parlist
static void parlist(LexState*ls){
FuncState*fs=ls->fs;
Proto*f=fs->f;
int nparams=0;
f->is_vararg=0;
if(ls->t.token!=')'){
do{
switch(ls->t.token){
case TK_NAME:{
new_localvar(ls,str_checkname(ls),nparams++);
break;
}
case TK_DOTS:{
luaX_next(ls);
f->is_vararg|=2;
break;
}
default:luaX_syntaxerror(ls,"<name> or "LUA_QL("...")" expected");
}
}while(!f->is_vararg&&testnext(ls,','));
}
adjustlocalvars(ls,nparams);
f->numparams=cast_byte(fs->nactvar-(f->is_vararg&1));
luaK_reserveregs(fs,fs->nactvar);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movb $0x0, 0x72(%rax)
movq 0x30(%rsp), %rax
cmpl $0x29, 0x10(%rax)
je 0x185ae
jmp 0x184f6
movq 0x30(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x18(%rsp)
subl $0x117, %eax            # imm = 0x117
je 0x18548
jmp 0x1850b
movl 0x18(%rsp), %eax
subl $0x11d, %eax            # imm = 0x11D
jne 0x18563
jmp 0x18518
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x18240
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movl 0x1c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x183a0
jmp 0x18574
movq 0x30(%rsp), %rdi
callq 0x122d0
movq 0x20(%rsp), %rax
movzbl 0x72(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x72(%rax)
jmp 0x18574
movq 0x30(%rsp), %rdi
leaq 0xa8b6(%rip), %rsi      # 0x22e25
callq 0x14360
jmp 0x18576
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x72(%rcx)
movb %al, 0xf(%rsp)
jne 0x185a0
movq 0x30(%rsp), %rdi
movl $0x2c, %esi
callq 0x147e0
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x184f6
jmp 0x185ae
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x18430
movq 0x28(%rsp), %rax
movzbl 0x4a(%rax), %eax
movq 0x20(%rsp), %rcx
movzbl 0x72(%rcx), %ecx
andl $0x1, %ecx
subl %ecx, %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, 0x71(%rax)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movzbl 0x4a(%rax), %esi
callq 0x17170
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: pushclosure
static void pushclosure(LexState*ls,FuncState*func,expdesc*v){
FuncState*fs=ls->fs;
Proto*f=fs->f;
int oldsize=f->sizep;
int i;
luaM_growvector(ls->L,f->p,fs->np,f->sizep,Proto*,
((1<<(9+9))-1),"constant table overflow");
while(oldsize<f->sizep)f->p[oldsize++]=NULL;
f->p[fs->np++]=func->f;
luaC_objbarrier(ls->L,f,func->f);
init_exp(v,VRELOCABLE,luaK_codeABx(fs,OP_CLOSURE,0,fs->np-1));
for(i=0;i<func->f->nups;i++){
OpCode o=(func->upvalues[i].k==VLOCAL)?OP_MOVE:OP_GETUPVAL;
luaK_codeABC(fs,o,0,func->upvalues[i].info,0);
}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x58(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movl 0x44(%rax), %eax
addl $0x1, %eax
movq 0x20(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jle 0x1868d
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x20(%rsp), %rdx
addq $0x58, %rdx
movl $0x8, %ecx
movl $0x3ffff, %r8d          # imm = 0x3FFFF
leaq 0xa6c4(%rip), %r9       # 0x22d40
callq 0x167b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x1868f
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jge 0x186c0
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1c(%rsp)
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x1868f
movq 0x38(%rsp), %rax
movq (%rax), %rdx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rsp), %rsi
movl 0x44(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x44(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x18728
movq 0x20(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x18728
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rax
movq (%rax), %rdx
callq 0x5150
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x44(%rax), %ecx
subl $0x1, %ecx
movl $0x24, %esi
xorl %edx, %edx
callq 0x16530
movq 0x8(%rsp), %rdi
movl %eax, %edx
movl $0xb, %esi
callq 0x17740
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x70(%rcx), %ecx
cmpl %ecx, %eax
jge 0x187cb
movq 0x38(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl 0x4b(%rax,%rcx,2), %edx
movl $0x4, %eax
xorl %ecx, %ecx
cmpl $0x6, %edx
cmovel %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x38(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl 0x4c(%rax,%rcx,2), %ecx
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x164d0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x18767
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: registerlocalvar
static int registerlocalvar(LexState*ls,TString*varname){
FuncState*fs=ls->fs;
Proto*f=fs->f;
int oldsize=f->sizelocvars;
luaM_growvector(ls->L,f->locvars,fs->nlocvars,f->sizelocvars,
LocVar,SHRT_MAX,"too many local variables");
while(oldsize<f->sizelocvars)f->locvars[oldsize++].varname=NULL;
f->locvars[fs->nlocvars].varname=varname;
luaC_objbarrier(ls->L,f,varname);
return fs->nlocvars++;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x5c(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movswl 0x48(%rax), %eax
addl $0x1, %eax
movq 0x8(%rsp), %rcx
cmpl 0x5c(%rcx), %eax
jle 0x18859
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x8(%rsp), %rdx
addq $0x5c, %rdx
movl $0x10, %ecx
movl $0x7fff, %r8d           # imm = 0x7FFF
leaq 0xa5c4(%rip), %r9       # 0x22e0c
callq 0x167b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x1885b
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x5c(%rcx), %eax
jge 0x18892
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
jmp 0x1885b
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdx
movswq 0x48(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x188ee
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x188ee
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x5150
movq 0x10(%rsp), %rcx
movw 0x48(%rcx), %ax
movw %ax, %dx
addw $0x1, %dx
movw %dx, 0x48(%rcx)
cwtl
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: prefixexp
static void prefixexp(LexState*ls,expdesc*v){
switch(ls->t.token){
case'(':{
int line=ls->linenumber;
luaX_next(ls);
expr(ls,v);
check_match(ls,')','(',line);
luaK_dischargevars(ls->fs,v);
return;
}
case TK_NAME:{
singlevar(ls,v);
return;
}
default:{
luaX_syntaxerror(ls,"unexpected symbol");
return;
}
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, (%rsp)
subl $0x28, %eax
je 0x1893c
jmp 0x18930
movl (%rsp), %eax
subl $0x11d, %eax            # imm = 0x11D
je 0x1898e
jmp 0x1899f
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x122d0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x153c0
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %ecx
movl $0x29, %esi
movl $0x28, %edx
callq 0x14a60
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x161b0
jmp 0x189b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18cf0
jmp 0x189b0
movq 0x10(%rsp), %rdi
leaq 0xa493(%rip), %rsi      # 0x22e3e
callq 0x14360
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x15ef0
movq 0x30(%rsp), %rdi
callq 0x122d0
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x181a0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x18a20
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_self
static void luaK_self(FuncState*fs,expdesc*e,expdesc*key){
int func;
luaK_exp2anyreg(fs,e);
freeexp(fs,e);
func=fs->freereg;
luaK_reserveregs(fs,2);
luaK_codeABC(fs,OP_SELF,func,e->u.s.info,luaK_exp2RK(fs,key));
freeexp(fs,key);
e->u.s.info=func;
e->k=VNONRELOC;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x15ef0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x17140
movq 0x30(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x17170
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17410
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movl 0x18(%rsp), %ecx
movl %eax, %r8d
movl $0xb, %esi
callq 0x164d0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17140
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl $0xc, (%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: funcargs
static void funcargs(LexState*ls,expdesc*f){
FuncState*fs=ls->fs;
expdesc args;
int base,nparams;
int line=ls->linenumber;
switch(ls->t.token){
case'(':{
if(line!=ls->lastline)
luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
luaX_next(ls);
if(ls->t.token==')')
args.k=VVOID;
else{
explist1(ls,&args);
luaK_setmultret(fs,&args);
}
check_match(ls,')','(',line);
break;
}
case'{':{
constructor(ls,&args);
break;
}
case TK_STRING:{
codestring(ls,&args,ls->t.seminfo.ts);
luaX_next(ls);
break;
}
default:{
luaX_syntaxerror(ls,"function arguments expected");
return;
}
}
base=f->u.s.info;
if(hasmultret(args.k))
nparams=(-1);
else{
if(args.k!=VVOID)
luaK_exp2nextreg(fs,&args);
nparams=fs->freereg-(base+1);
}
init_exp(f,VCALL,luaK_codeABC(fs,OP_CALL,base,nparams+1,2));
luaK_fixline(fs,line);
fs->freereg=base+1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x8(%rsp)
subl $0x28, %eax
je 0x18b7e
jmp 0x18b5b
movl 0x8(%rsp), %eax
subl $0x7b, %eax
je 0x18bf9
jmp 0x18b6a
movl 0x8(%rsp), %eax
subl $0x11e, %eax            # imm = 0x11E
je 0x18c0a
jmp 0x18c2e
movl 0xc(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x18b9d
movq 0x40(%rsp), %rdi
leaq 0xa2c1(%rip), %rsi      # 0x22e59
callq 0x14360
movq 0x40(%rsp), %rdi
callq 0x122d0
movq 0x40(%rsp), %rax
cmpl $0x29, 0x10(%rax)
jne 0x18bbc
movl $0x0, 0x18(%rsp)
jmp 0x18bdf
movq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x19130
movq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x18280
movq 0x40(%rsp), %rdi
movl 0xc(%rsp), %ecx
movl $0x29, %esi
movl $0x28, %edx
callq 0x14a60
jmp 0x18c44
movq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x177d0
jmp 0x18c44
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x18(%rsp), %rsi
callq 0x17780
movq 0x40(%rsp), %rdi
callq 0x122d0
jmp 0x18c44
movq 0x40(%rsp), %rdi
leaq 0xa250(%rip), %rsi      # 0x22e8a
callq 0x14360
jmp 0x18ce9
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0xd, 0x18(%rsp)
je 0x18c5e
cmpl $0xe, 0x18(%rsp)
jne 0x18c68
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
jmp 0x18c93
cmpl $0x0, 0x18(%rsp)
je 0x18c7e
movq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x16470
movq 0x30(%rsp), %rax
movl 0x3c(%rax), %eax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movl %eax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
addl $0x1, %ecx
movl $0x1c, %esi
movl $0x2, %r8d
callq 0x164d0
movq (%rsp), %rdi
movl %eax, %edx
movl $0xd, %esi
callq 0x17740
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x191b0
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x3c(%rax)
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x18240
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl $0x1, %ecx
callq 0x18d60
cmpl $0x8, %eax
jne 0x18d52
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x17c90
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x18da0
movq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0xff, %edx
callq 0x17740
movl $0x8, 0x24(%rsp)
jmp 0x18e42
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x18e50
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jl 0x18de8
movq 0x8(%rsp), %rdi
movl (%rsp), %edx
movl $0x6, %esi
callq 0x17740
cmpl $0x0, 0x4(%rsp)
jne 0x18dde
movq 0x18(%rsp), %rdi
movl (%rsp), %esi
callq 0x18ed0
movl $0x6, 0x24(%rsp)
jmp 0x18e42
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x18d60
cmpl $0x8, %eax
jne 0x18e11
movl $0x8, 0x24(%rsp)
jmp 0x18e42
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x18f40
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x7, (%rax)
movl $0x7, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: searchvar
static int searchvar(FuncState*fs,TString*n){
int i;
for(i=fs->nactvar-1;i>=0;i--){
if(n==getlocvar(fs,i).varname)
return i;
}
return-1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movzbl 0x4a(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
jl 0x18eb9
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq 0x30(%rcx), %rcx
movq -0x10(%rsp), %rdx
movslq -0x1c(%rsp), %rsi
movzwl 0xc4(%rdx,%rsi,2), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x18eaa
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x18ec1
jmp 0x18eac
movl -0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x18e6a
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: indexupvalue
static int indexupvalue(FuncState*fs,TString*name,expdesc*v){
int i;
Proto*f=fs->f;
int oldsize=f->sizeupvalues;
for(i=0;i<f->nups;i++){
if(fs->upvalues[i].k==v->k&&fs->upvalues[i].info==v->u.s.info){
return i;
}
}
luaY_checklimit(fs,f->nups+1,60,"upvalues");
luaM_growvector(fs->L,f->upvalues,f->nups,f->sizeupvalues,
TString*,(INT_MAX-2),"");
while(oldsize<f->sizeupvalues)f->upvalues[oldsize++]=NULL;
f->upvalues[f->nups]=name;
luaC_objbarrier(fs->L,f,name);
fs->upvalues[f->nups].k=cast_byte(v->k);
fs->upvalues[f->nups].info=cast_byte(v->u.s.info);
return f->nups++;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x48(%rax), %eax
movl %eax, 0x4(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
movzbl 0x70(%rcx), %ecx
cmpl %ecx, %eax
jge 0x18fd2
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl 0x4b(%rax,%rcx,2), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x18fc3
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl 0x4c(%rax,%rcx,2), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x18fc3
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x19123
jmp 0x18fc5
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x18f74
movq 0x8(%rsp), %rax
movzbl 0x70(%rax), %eax
addl $0x1, %eax
cmpl $0x3c, %eax
jle 0x18ff9
movq 0x28(%rsp), %rdi
movl $0x3c, %esi
leaq 0x9e5c(%rip), %rdx      # 0x22e50
callq 0x18100
movq 0x8(%rsp), %rax
movzbl 0x70(%rax), %eax
addl $0x1, %eax
movq 0x8(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jle 0x1904d
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rdx
addq $0x48, %rdx
movl $0x8, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
leaq 0x9a9a(%rip), %r9       # 0x22ad6
callq 0x167b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
jmp 0x1904f
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jge 0x19080
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x1904f
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
movzbl 0x70(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x190d5
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x190d5
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x5150
movq 0x18(%rsp), %rax
movl (%rax), %eax
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl 0x70(%rcx), %ecx
movb %dl, 0x4b(%rax,%rcx,2)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl 0x70(%rcx), %ecx
movb %dl, 0x4c(%rax,%rcx,2)
movq 0x8(%rsp), %rcx
movb 0x70(%rcx), %al
movb %al, %dl
addb $0x1, %dl
movb %dl, 0x70(%rcx)
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x153c0
movq 0x10(%rsp), %rdi
movl $0x2c, %esi
callq 0x147e0
cmpl $0x0, %eax
je 0x19198
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x16470
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x153c0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x19155
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_goiffalse
static void luaK_goiffalse(FuncState*fs,expdesc*e){
int pc;
luaK_dischargevars(fs,e);
switch(e->k){
case VNIL:case VFALSE:{
pc=(-1);
break;
}
case VJMP:{
pc=e->u.s.info;
break;
}
default:{
pc=jumponcond(fs,e,1);
break;
}
}
luaK_concat(fs,&e->t,pc);
luaK_patchtohere(fs,e->f);
e->f=(-1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x161b0
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
subl $0x1, %eax
je 0x19222
jmp 0x1920e
movl (%rsp), %eax
subl $0x3, %eax
je 0x19222
jmp 0x19218
movl (%rsp), %eax
subl $0xa, %eax
je 0x1922c
jmp 0x1923a
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x19252
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x19252
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19290
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movl 0x4(%rsp), %edx
callq 0x15220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x14(%rax), %esi
callq 0x15300
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xb, (%rax)
jne 0x1931b
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
shrl $0x0, %eax
andl $0x3f, %eax
cmpl $0x13, %eax
jne 0x19319
movq 0x18(%rsp), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %edx
shrl $0x17, %edx
andl $0x1ff, %edx            # imm = 0x1FF
cmpl $0x0, 0xc(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %r8d
movl $0x1a, %esi
xorl %ecx, %ecx
callq 0x19370
movl %eax, 0x24(%rsp)
jmp 0x1935e
jmp 0x1931b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x176b0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x17140
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rsp), %r8d
movl $0x1b, %esi
movl $0xff, %edx
callq 0x19370
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17410
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17410
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17140
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17140
cmpl $0x0, 0x28(%rsp)
jne 0x1944d
cmpl $0x17, 0x2c(%rsp)
je 0x1944d
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0x1, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
callq 0x19370
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl $0xa, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: enterblock
static void enterblock(FuncState*fs,BlockCnt*bl,lu_byte isbreakable){
bl->breaklist=(-1);
bl->isbreakable=isbreakable;
bl->nactvar=fs->nactvar;
bl->upval=0;
bl->previous=fs->bl;
fs->bl=bl;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movb -0x11(%rsp), %cl
movq -0x10(%rsp), %rax
movb %cl, 0xe(%rax)
movq -0x8(%rsp), %rax
movb 0x4a(%rax), %cl
movq -0x10(%rsp), %rax
movb %cl, 0xc(%rax)
movq -0x10(%rsp), %rax
movb $0x0, 0xd(%rax)
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x30(%rcx), %eax
jne 0x1952f
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x15300
jmp 0x1954b
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movl 0x8(%rsp), %r8d
movl $0xff, %ecx
callq 0x168d0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rax
movzbl 0xc(%rax), %esi
callq 0x195e0
movq 0x8(%rsp), %rax
cmpb $0x0, 0xd(%rax)
je 0x195b8
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movzbl 0xc(%rax), %edx
movl $0x23, %esi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x164d0
movq 0x10(%rsp), %rax
movzbl 0x4a(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x3c(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x15300
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: fornum
static void fornum(LexState*ls,TString*varname,int line){
FuncState*fs=ls->fs;
int base=fs->freereg;
new_localvarliteral(ls,"(for index)",0);
new_localvarliteral(ls,"(for limit)",1);
new_localvarliteral(ls,"(for step)",2);
new_localvar(ls,varname,3);
checknext(ls,'=');
exp1(ls);
checknext(ls,',');
exp1(ls);
if(testnext(ls,','))
exp1(ls);
else{
luaK_codeABx(fs,OP_LOADK,fs->freereg,luaK_numberK(fs,1));
luaK_reserveregs(fs,1);
}
forbody(ls,base,line,1,1);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x9800(%rip), %rsi      # 0x22ef2
movl $0xb, %edx
callq 0x142a0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x183a0
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x97dd(%rip), %rsi      # 0x22efe
movl $0xb, %edx
callq 0x142a0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x183a0
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x97b7(%rip), %rsi      # 0x22f0a
movl $0xa, %edx
callq 0x142a0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x183a0
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl $0x3, %edx
callq 0x183a0
movq 0x50(%rsp), %rdi
movl $0x3d, %esi
callq 0x15390
movq 0x50(%rsp), %rdi
callq 0x19a10
movq 0x50(%rsp), %rdi
movl $0x2c, %esi
callq 0x15390
movq 0x50(%rsp), %rdi
callq 0x19a10
movq 0x50(%rsp), %rdi
movl $0x2c, %esi
callq 0x147e0
cmpl $0x0, %eax
je 0x197d5
movq 0x50(%rsp), %rdi
callq 0x19a10
jmp 0x19821
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movsd 0x8f88(%rip), %xmm0     # 0x22780
callq 0x16f20
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movl %eax, %ecx
movl $0x1, %esi
callq 0x16530
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x17170
movq 0x50(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0x44(%rsp), %edx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x19a50
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: forlist
static void forlist(LexState*ls,TString*indexname){
FuncState*fs=ls->fs;
expdesc e;
int nvars=0;
int line;
int base=fs->freereg;
new_localvarliteral(ls,"(for generator)",nvars++);
new_localvarliteral(ls,"(for state)",nvars++);
new_localvarliteral(ls,"(for control)",nvars++);
new_localvar(ls,indexname,nvars++);
while(testnext(ls,','))
new_localvar(ls,str_checkname(ls),nvars++);
checknext(ls,TK_IN);
line=ls->linenumber;
adjust_assign(ls,3,explist1(ls,&e),&e);
luaK_checkstack(fs,3);
forbody(ls,base,line,nvars-3,0);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x50(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x967f(%rip), %rsi      # 0x22f15
movl $0xf, %edx
callq 0x142a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movl 0x34(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
callq 0x183a0
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x9655(%rip), %rsi      # 0x22f25
movl $0xb, %edx
callq 0x142a0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movl 0x34(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
callq 0x183a0
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x9627(%rip), %rsi      # 0x22f31
movl $0xd, %edx
callq 0x142a0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movl 0x34(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
callq 0x183a0
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x34(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
callq 0x183a0
movq 0x60(%rsp), %rdi
movl $0x2c, %esi
callq 0x147e0
cmpl $0x0, %eax
je 0x1998e
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x18240
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x34(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
callq 0x183a0
jmp 0x1994a
movq 0x60(%rsp), %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x15390
movq 0x60(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x19130
movq (%rsp), %rdi
movl %eax, %edx
movl $0x3, %esi
leaq 0x38(%rsp), %rcx
callq 0x19bc0
movq 0x50(%rsp), %rdi
movl $0x3, %esi
callq 0x171a0
movq 0x60(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x30(%rsp), %edx
movl 0x34(%rsp), %ecx
subl $0x3, %ecx
xorl %r8d, %r8d
callq 0x19a50
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: exp1
static int exp1(LexState*ls){
expdesc e;
int k;
expr(ls,&e);
k=e.k;
luaK_exp2nextreg(ls->fs,&e);
return k;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x153c0
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x16470
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movl %r8d, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movl $0x3, %esi
callq 0x18430
movq 0x50(%rsp), %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x15390
cmpl $0x0, 0x40(%rsp)
je 0x19abb
movq 0x28(%rsp), %rdi
movl 0x4c(%rsp), %edx
movl $0x20, %esi
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x16530
movl %eax, 0x1c(%rsp)
jmp 0x19ac9
movq 0x28(%rsp), %rdi
callq 0x152a0
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0x19490
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x18430
movq 0x28(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x17170
movq 0x50(%rsp), %rdi
callq 0x14a10
movq 0x28(%rsp), %rdi
callq 0x19550
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15300
cmpl $0x0, 0x40(%rsp)
je 0x19b45
movq 0x28(%rsp), %rdi
movl 0x4c(%rsp), %edx
movl $0x1f, %esi
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x16530
movl %eax, 0x18(%rsp)
jmp 0x19b63
movq 0x28(%rsp), %rdi
movl 0x4c(%rsp), %edx
movl 0x44(%rsp), %r8d
movl $0x21, %esi
xorl %ecx, %ecx
callq 0x164d0
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x191b0
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x40(%rsp)
je 0x19b94
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x19ba2
movq 0x28(%rsp), %rdi
callq 0x152a0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x24(%rsp), %edx
addl $0x1, %edx
callq 0x19500
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
subl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xd, (%rax)
je 0x19c04
movq 0x10(%rsp), %rax
cmpl $0xe, (%rax)
jne 0x19c4b
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x19c1e
movl $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x18280
cmpl $0x1, 0x4(%rsp)
jle 0x19c49
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
subl $0x1, %esi
callq 0x17170
jmp 0x19c97
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0x19c64
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x16470
cmpl $0x0, 0x4(%rsp)
jle 0x19c95
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x17170
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x16df0
jmp 0x19c97
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: funcname
static int funcname(LexState*ls,expdesc*v){
int needself=0;
singlevar(ls,v);
while(ls->t.token=='.')
field(ls,v);
if(ls->t.token==':'){
needself=1;
field(ls,v);
}
return needself;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18cf0
movq 0x10(%rsp), %rax
cmpl $0x2e, 0x10(%rax)
jne 0x19ce1
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x189c0
jmp 0x19cc5
movq 0x10(%rsp), %rax
cmpl $0x3a, 0x10(%rax)
jne 0x19d03
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x189c0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
addl $-0x6, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x3, %eax
ja 0x19e19
movq 0x8(%rsp), %rax
leaq 0x8633(%rip), %rcx      # 0x2237c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17140
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %edx
callq 0x162e0
jmp 0x19e2a
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x15ef0
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %edx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x8, %esi
xorl %r8d, %r8d
callq 0x164d0
jmp 0x19e1b
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x15ef0
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x18(%rsp), %edx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x7, %esi
callq 0x16530
jmp 0x19e1b
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17410
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x28(%rsp), %rax
movl 0xc(%rax), %ecx
movl 0x14(%rsp), %r8d
movl $0x9, %esi
callq 0x164d0
jmp 0x19e1b
jmp 0x19e1b
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17140
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: assignment
static void assignment(LexState*ls,struct LHS_assign*lh,int nvars){
expdesc e;
check_condition(ls,VLOCAL<=lh->v.k&&lh->v.k<=VINDEXED,
"syntax error");
if(testnext(ls,',')){
struct LHS_assign nv;
nv.prev=lh;
primaryexp(ls,&nv.v);
if(nv.v.k==VLOCAL)
check_conflict(ls,lh,&nv.v);
luaY_checklimit(ls->fs,nvars,200-ls->L->nCcalls,
"variables in assignment");
assignment(ls,&nv,nvars+1);
}
else{
int nexps;
checknext(ls,'=');
nexps=explist1(ls,&e);
if(nexps!=nvars){
adjust_assign(ls,nvars,nexps,&e);
if(nexps>nvars)
ls->fs->freereg-=nexps-nvars;
}
else{
luaK_setoneret(ls->fs,&e);
luaK_storevar(ls->fs,&lh->v,&e);
return;
}
}
init_exp(&e,VNONRELOC,ls->fs->freereg-1);
luaK_storevar(ls->fs,&lh->v,&e);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x48(%rsp), %rcx
movl $0x6, %eax
cmpl 0x8(%rcx), %eax
ja 0x19e9c
movq 0x48(%rsp), %rax
cmpl $0x9, 0x8(%rax)
jbe 0x19ead
movq 0x50(%rsp), %rdi
leaq 0x90a8(%rip), %rsi      # 0x22f50
callq 0x14360
movq 0x50(%rsp), %rdi
movl $0x2c, %esi
callq 0x147e0
cmpl $0x0, %eax
je 0x19f61
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x17b50
cmpl $0x6, 0x10(%rsp)
jne 0x19f01
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
addq $0x8, %rdx
callq 0x1a040
movl 0x44(%rsp), %eax
movq 0x50(%rsp), %rcx
movq 0x38(%rcx), %rcx
movzwl 0x60(%rcx), %edx
movl $0xc8, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jle 0x19f46
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x50(%rsp), %rax
movq 0x38(%rax), %rax
movzwl 0x60(%rax), %eax
movl $0xc8, %esi
subl %eax, %esi
leaq 0x901c(%rip), %rdx      # 0x22f5d
callq 0x18100
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %edx
addl $0x1, %edx
leaq 0x8(%rsp), %rsi
callq 0x19e70
jmp 0x19ffc
movq 0x50(%rsp), %rdi
movl $0x3d, %esi
callq 0x15390
movq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x19130
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x44(%rsp), %eax
je 0x19fc9
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %esi
movl 0x4(%rsp), %edx
leaq 0x28(%rsp), %rcx
callq 0x19bc0
movl 0x4(%rsp), %eax
cmpl 0x44(%rsp), %eax
jle 0x19fc7
movl 0x4(%rsp), %edx
subl 0x44(%rsp), %edx
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x3c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x19ffa
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x28(%rsp), %rsi
callq 0x165c0
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdx
callq 0x19d10
jmp 0x1a036
jmp 0x19ffc
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x3c(%rax), %edx
subl $0x1, %edx
leaq 0x28(%rsp), %rdi
movl $0xc, %esi
callq 0x17740
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdx
callq 0x19d10
addq $0x58, %rsp
retq
nopl (%rax,%rax)