LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaZ_fill
static int luaZ_fill(ZIO*z){
size_t size;
lua_State*L=z->L;
const char*buff;
buff=z->reader(L,z->data,&size);
if(buff==NULL||size==0)return(-1);
z->n=size-1;
z->p=buff;
return char2int(*(z->p++));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rsi
leaq 0x10(%rsp), %rdx
callq *%rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x127d8
cmpq $0x0, 0x10(%rsp)
jne 0x127e2
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1281b
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaF_newproto
static Proto*luaF_newproto(lua_State*L){
Proto*f=luaM_new(L,Proto);
luaC_link(L,obj2gco(f),(8+1));
f->k=NULL;
f->sizek=0;
f->p=NULL;
f->sizep=0;
f->code=NULL;
f->sizecode=0;
f->sizelineinfo=0;
f->sizeupvalues=0;
f->nups=0;
f->upvalues=NULL;
f->numparams=0;
f->is_vararg=0;
f->maxstacksize=0;
f->lineinfo=NULL;
f->sizelocvars=0;
f->locvars=NULL;
f->linedefined=0;
f->lastlinedefined=0;
f->source=NULL;
return f;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x78, %ecx
movq %rdx, %rsi
callq 0x4b30
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x9, %edx
callq 0xd320
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x4c(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x54(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x70(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x71(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x72(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x73(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x5c(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x64(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: inclinenumber
static void inclinenumber(LexState*ls){
int old=ls->current;
next(ls);
if(currIsNewline(ls)&&ls->current!=old)
next(ls);
if(++ls->linenumber>=(INT_MAX-2))
luaX_syntaxerror(ls,"chunk has too many lines");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x133c1
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x133d3
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12790
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
cmpl $0xa, (%rax)
je 0x133f2
movq 0x10(%rsp), %rax
cmpl $0xd, (%rax)
jne 0x13459
movq 0x10(%rsp), %rax
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
je 0x13459
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1343c
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x1344e
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12790
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jl 0x1347f
movq 0x10(%rsp), %rdi
leaq 0xf7ba(%rip), %rsi      # 0x22c34
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: skip_sep
static int skip_sep(LexState*ls){
int count=0;
int s=ls->current;
save_and_next(ls);
while(ls->current=='='){
save_and_next(ls);
count++;
}
return(ls->current==s)?count:(-count)-1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0x13ef0
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x134fa
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x1350c
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12790
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
cmpl $0x3d, (%rax)
jne 0x1359c
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0x13ef0
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1356f
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x13581
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12790
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x13517
movq 0x20(%rsp), %rax
movl (%rax), %eax
cmpl 0x18(%rsp), %eax
jne 0x135b3
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x135c0
xorl %eax, %eax
subl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaX_lexerror
static void luaX_lexerror(LexState*ls,const char*msg,int token){
char buff[80];
luaO_chunkid(buff,getstr(ls->source),80);
msg=luaO_pushfstring(ls->L,"%s:%d: %s",buff,ls->linenumber,msg);
if(token)
luaO_pushfstring(ls->L,"%s near "LUA_QL("%s"),msg,txtToken(ls,token));
luaD_throw(ls->L,3);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x50(%rax), %rsi
addq $0x18, %rsi
movl $0x50, %edx
callq 0x5de0
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x10(%rsp), %rdx
movq 0x70(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x68(%rsp), %r8
leaq 0xeed8(%rip), %rsi      # 0x227f8
movb $0x0, %al
callq 0x5fc0
movq %rax, 0x68(%rsp)
cmpl $0x0, 0x64(%rsp)
je 0x13972
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x14390
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0xf311(%rip), %rsi      # 0x22c7c
movb $0x0, %al
callq 0x5fc0
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
movl $0x3, %esi
callq 0x4bc0
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: save
static void save(LexState*ls,int c){
Mbuffer*b=ls->buff;
if(b->n+1>b->buffsize){
size_t newsize;
if(b->buffsize>=((size_t)(~(size_t)0)-2)/2)
luaX_lexerror(ls,"lexical element too long",0);
newsize=b->buffsize*2;
luaZ_resizebuffer(ls->L,b,newsize);
}
b->buffer[b->n++]=cast(char,c);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x13fcd
movq 0x10(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jb 0x13f4f
movq 0x20(%rsp), %rdi
leaq 0xed79(%rip), %rsi      # 0x22cc1
xorl %edx, %edx
callq 0x138d0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
cmpq $-0x3, %rax
ja 0x13fa1
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
movq 0x8(%rsp), %rcx
shlq $0x0, %rcx
callq 0x4b30
movq %rax, (%rsp)
jmp 0x13fb3
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x5480
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x1c(%rsp), %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: check_next
static int check_next(LexState*ls,const char*set){
if(!strchr(set,ls->current))
return 0;
save_and_next(ls);
return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0x3100
cmpq $0x0, %rax
jne 0x1402f
movl $0x0, 0x24(%rsp)
jmp 0x140a2
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0x13ef0
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1407d
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x1408f
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12790
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 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: read_numeral
static void read_numeral(LexState*ls,SemInfo*seminfo){
do{
save_and_next(ls);
}while(isdigit(ls->current)||ls->current=='.');
if(check_next(ls,"Ee"))
check_next(ls,"+-");
while(isalnum(ls->current)||ls->current=='_')
save_and_next(ls);
save(ls,'\0');
buffreplace(ls,'.',ls->decpoint);
if(!luaO_str2d(luaZ_buffer(ls->buff),&seminfo->r))
luaX_lexerror(ls,"malformed number",TK_NUMBER);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0x13ef0
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1410c
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x1411e
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12790
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
callq 0x32d0
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x13(%rsp)
jne 0x1415d
movq 0x20(%rsp), %rax
cmpl $0x2e, (%rax)
sete %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x140be
movq 0x20(%rsp), %rdi
leaq 0xeb65(%rip), %rsi      # 0x22cda
callq 0x14000
cmpl $0x0, %eax
je 0x14190
movq 0x20(%rsp), %rdi
leaq 0xeb52(%rip), %rsi      # 0x22cdd
callq 0x14000
jmp 0x14192
callq 0x32d0
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x12(%rsp)
jne 0x141c3
movq 0x20(%rsp), %rax
cmpl $0x5f, (%rax)
sete %al
movb %al, 0x12(%rsp)
movb 0x12(%rsp), %al
testb $0x1, %al
jne 0x141cd
jmp 0x1423d
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0x13ef0
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1421b
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x1422d
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12790
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x14192
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x13ef0
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movl $0x2e, %esi
movsbl 0x58(%rax), %edx
callq 0x144a0
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xd210
cmpl $0x0, %eax
jne 0x14292
movq 0x20(%rsp), %rdi
leaq 0xea58(%rip), %rsi      # 0x22ce0
movl $0x11c, %edx            # imm = 0x11C
callq 0x138d0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaX_newstring
static TString*luaX_newstring(LexState*ls,const char*str,size_t l){
lua_State*L=ls->L;
TString*ts=luaS_newlstr(L,str,l);
TValue*o=luaH_setstr(L,ls->fs->h,ts);
if(ttisnil(o)){
setbvalue(o,1);
luaC_checkGC(L);
}
return ts;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x49c0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x14520
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1434c
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x1, (%rax)
movq (%rsp), %rax
movl $0x1, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x70(%rcx), %rax
jb 0x1434a
movq 0x18(%rsp), %rdi
callq 0xa270
jmp 0x1434c
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: txtToken
static const char*txtToken(LexState*ls,int token){
switch(token){
case TK_NAME:
case TK_STRING:
case TK_NUMBER:
save(ls,'\0');
return luaZ_buffer(ls->buff);
default:
return luaX_token2str(ls,token);
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $0xfffffee4, %eax       # imm = 0xFFFFFEE4
subl $0x2, %eax
ja 0x143cc
jmp 0x143ad
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x13ef0
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x143df
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x143f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaX_token2str
static const char*luaX_token2str(LexState*ls,int token){
if(token<257){
return(iscntrl(token))?luaO_pushfstring(ls->L,"char(%d)",token):
luaO_pushfstring(ls->L,"%c",token);
}
else
return luaX_tokens[token-257];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpl $0x101, 0x14(%rsp)      # imm = 0x101
jge 0x1446e
callq 0x32d0
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x14442
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movl 0x14(%rsp), %edx
leaq 0xe855(%rip), %rsi      # 0x22c89
movb $0x0, %al
callq 0x5fc0
movq %rax, 0x8(%rsp)
jmp 0x14462
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movl 0x14(%rsp), %edx
leaq 0xe83c(%rip), %rsi      # 0x22c92
movb $0x0, %al
callq 0x5fc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1448a
movl 0x14(%rsp), %eax
subl $0x101, %eax            # imm = 0x101
movslq %eax, %rcx
leaq 0x144bf(%rip), %rax     # 0x28940
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: buffreplace
static void buffreplace(LexState*ls,char from,char to){
size_t n=luaZ_bufflen(ls->buff);
char*p=luaZ_buffer(ls->buff);
while(n--)
if(p[n]==from)p[n]=to;
}

// Assembly:
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rsp)
movb %cl, -0x9(%rsp)
movb %al, -0xa(%rsp)
movq -0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rsp)
cmpq $0x0, %rax
je 0x14516
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rsp), %ecx
cmpl %ecx, %eax
jne 0x14514
movb -0xa(%rsp), %dl
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x144d5
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaH_setstr
static TValue*luaH_setstr(lua_State*L,Table*t,TString*key){
const TValue*p=luaH_getstr(t,key);
if(p!=(&luaO_nilobject_))
return cast(TValue*,p);
else{
TValue k;
setsvalue(L,&k,key);
return newkey(L,t,&k);
}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x6c40
movq %rax, 0x20(%rsp)
leaq 0xe08a(%rip), %rax      # 0x225d8
cmpq %rax, 0x20(%rsp)
je 0x14561
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1459d
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x4, 0x8(%rax)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xc120
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: block_follow
static int block_follow(int token){
switch(token){
case TK_ELSE:case TK_ELSEIF:case TK_END:
case TK_UNTIL:case TK_EOS:
return 1;
default:return 0;
}
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
addl $0xfffffefc, %eax       # imm = 0xFFFFFEFC
subl $0x3, %eax
jb 0x14622
jmp 0x14608
movl -0xc(%rsp), %eax
subl $0x114, %eax            # imm = 0x114
je 0x14622
jmp 0x14615
movl -0xc(%rsp), %eax
subl $0x11f, %eax            # imm = 0x11F
jne 0x1462c
jmp 0x14622
movl $0x1, -0x4(%rsp)
jmp 0x14634
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: statement
static int statement(LexState*ls){
int line=ls->linenumber;
switch(ls->t.token){
case TK_IF:{
ifstat(ls,line);
return 0;
}
case TK_WHILE:{
whilestat(ls,line);
return 0;
}
case TK_DO:{
luaX_next(ls);
block(ls);
check_match(ls,TK_END,TK_DO,line);
return 0;
}
case TK_FOR:{
forstat(ls,line);
return 0;
}
case TK_REPEAT:{
repeatstat(ls,line);
return 0;
}
case TK_FUNCTION:{
funcstat(ls,line);
return 0;
}
case TK_LOCAL:{
luaX_next(ls);
if(testnext(ls,TK_FUNCTION))
localfunc(ls);
else
localstat(ls);
return 0;
}
case TK_RETURN:{
retstat(ls);
return 1;
}
case TK_BREAK:{
luaX_next(ls);
breakstat(ls);
return 1;
}
default:{
exprstat(ls);
return 0;
}
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
addl $0xfffffefe, %eax       # imm = 0xFFFFFEFE
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x13, %eax
ja 0x147b7
movq 0x8(%rsp), %rax
leaq 0xdb8e(%rip), %rcx      # 0x2220c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x14820
movl $0x0, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x14940
movl $0x0, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
callq 0x122d0
movq 0x18(%rsp), %rdi
callq 0x14a10
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x103, %edx            # imm = 0x103
callq 0x14a60
movl $0x0, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x14b20
movl $0x0, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x14c00
movl $0x0, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x14d10
movl $0x0, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
callq 0x122d0
movq 0x18(%rsp), %rdi
movl $0x109, %esi            # imm = 0x109
callq 0x147e0
cmpl $0x0, %eax
je 0x14771
movq 0x18(%rsp), %rdi
callq 0x14d80
jmp 0x1477b
movq 0x18(%rsp), %rdi
callq 0x14e60
movl $0x0, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
callq 0x14f20
movl $0x1, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
callq 0x122d0
movq 0x18(%rsp), %rdi
callq 0x15050
movl $0x1, 0x24(%rsp)
jmp 0x147c9
movq 0x18(%rsp), %rdi
callq 0x15140
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: testnext
static int testnext(LexState*ls,int c){
if(ls->t.token==c){
luaX_next(ls);
return 1;
}
else return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
cmpl 0x4(%rsp), %eax
jne 0x1480f
movq 0x8(%rsp), %rdi
callq 0x122d0
movl $0x1, 0x14(%rsp)
jmp 0x14817
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: ifstat
static void ifstat(LexState*ls,int line){
FuncState*fs=ls->fs;
int flist;
int escapelist=(-1);
flist=test_then_block(ls);
while(ls->t.token==TK_ELSEIF){
luaK_concat(fs,&escapelist,luaK_jump(fs));
luaK_patchtohere(fs,flist);
flist=test_then_block(ls);
}
if(ls->t.token==TK_ELSE){
luaK_concat(fs,&escapelist,luaK_jump(fs));
luaK_patchtohere(fs,flist);
luaX_next(ls);
block(ls);
}
else
luaK_concat(fs,&escapelist,flist);
luaK_patchtohere(fs,escapelist);
check_match(ls,TK_END,TK_IF,line);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rdi
callq 0x151d0
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x105, 0x10(%rax)      # imm = 0x105
jne 0x148a2
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x152a0
movq 0x10(%rsp), %rdi
movl %eax, %edx
leaq 0x18(%rsp), %rsi
callq 0x15220
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x15300
movq 0x30(%rsp), %rdi
callq 0x151d0
movl %eax, 0x1c(%rsp)
jmp 0x14851
movq 0x30(%rsp), %rax
cmpl $0x104, 0x10(%rax)      # imm = 0x104
jne 0x148f9
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x152a0
movq 0x8(%rsp), %rdi
movl %eax, %edx
leaq 0x18(%rsp), %rsi
callq 0x15220
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x15300
movq 0x30(%rsp), %rdi
callq 0x122d0
movq 0x30(%rsp), %rdi
callq 0x14a10
jmp 0x1490c
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
leaq 0x18(%rsp), %rsi
callq 0x15220
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x15300
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x10a, %edx            # imm = 0x10A
callq 0x14a60
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: whilestat
static void whilestat(LexState*ls,int line){
FuncState*fs=ls->fs;
int whileinit;
int condexit;
BlockCnt bl;
luaX_next(ls);
whileinit=luaK_getlabel(fs);
condexit=cond(ls);
enterblock(fs,&bl,1);
checknext(ls,TK_DO);
block(ls);
luaK_patchlist(fs,luaK_jump(fs),whileinit);
check_match(ls,TK_END,TK_WHILE,line);
leaveblock(fs);
luaK_patchtohere(fs,condexit);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x122d0
movq 0x20(%rsp), %rdi
callq 0x16dd0
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
callq 0x15340
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19490
movq 0x30(%rsp), %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x15390
movq 0x30(%rsp), %rdi
callq 0x14a10
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x152a0
movq (%rsp), %rdi
movl %eax, %esi
movl 0x1c(%rsp), %edx
callq 0x19500
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x115, %edx            # imm = 0x115
callq 0x14a60
movq 0x20(%rsp), %rdi
callq 0x19550
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x15300
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: block
static void block(LexState*ls){
FuncState*fs=ls->fs;
BlockCnt bl;
enterblock(fs,&bl,0);
chunk(ls);
leaveblock(fs);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x19490
movq 0x20(%rsp), %rdi
callq 0x12340
movq 0x18(%rsp), %rdi
callq 0x19550
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: check_match
static void check_match(LexState*ls,int what,int who,int where){
if(!testnext(ls,what)){
if(where==ls->linenumber)
error_expected(ls,what);
else{
luaX_syntaxerror(ls,luaO_pushfstring(ls->L,
LUA_QL("%s")" expected (to close "LUA_QL("%s")" at line %d)",
luaX_token2str(ls,what),luaX_token2str(ls,who),where));
}
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x147e0
cmpl $0x0, %eax
jne 0x14b12
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x14aaa
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x19650
jmp 0x14b10
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x143f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x143f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movl 0x24(%rsp), %r8d
leaq 0xe3aa(%rip), %rsi      # 0x22ea6
movb $0x0, %al
callq 0x5fc0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x14360
jmp 0x14b12
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: repeatstat
static void repeatstat(LexState*ls,int line){
int condexit;
FuncState*fs=ls->fs;
int repeat_init=luaK_getlabel(fs);
BlockCnt bl1,bl2;
enterblock(fs,&bl1,1);
enterblock(fs,&bl2,0);
luaX_next(ls);
chunk(ls);
check_match(ls,TK_UNTIL,TK_REPEAT,line);
condexit=cond(ls);
if(!bl2.upval){
leaveblock(fs);
luaK_patchlist(ls->fs,condexit,repeat_init);
}
else{
breakstat(ls);
luaK_patchtohere(ls->fs,condexit);
leaveblock(fs);
luaK_patchlist(ls->fs,luaK_jump(fs),repeat_init);
}
leaveblock(fs);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x16dd0
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19490
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x19490
movq 0x40(%rsp), %rdi
callq 0x122d0
movq 0x40(%rsp), %rdi
callq 0x12340
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %ecx
movl $0x114, %esi            # imm = 0x114
movl $0x110, %edx            # imm = 0x110
callq 0x14a60
movq 0x40(%rsp), %rdi
callq 0x15340
movl %eax, 0x38(%rsp)
cmpb $0x0, 0x15(%rsp)
jne 0x14cb1
movq 0x30(%rsp), %rdi
callq 0x19550
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x38(%rsp), %esi
movl 0x2c(%rsp), %edx
callq 0x19500
jmp 0x14cfd
movq 0x40(%rsp), %rdi
callq 0x15050
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x38(%rsp), %esi
callq 0x15300
movq 0x30(%rsp), %rdi
callq 0x19550
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x152a0
movq (%rsp), %rdi
movl %eax, %esi
movl 0x2c(%rsp), %edx
callq 0x19500
movq 0x30(%rsp), %rdi
callq 0x19550
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: funcstat
static void funcstat(LexState*ls,int line){
int needself;
expdesc v,b;
luaX_next(ls);
needself=funcname(ls,&v);
body(ls,&b,needself,line);
luaK_storevar(ls->fs,&v,&b);
luaK_fixline(ls->fs,line);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x122d0
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x19ca0
movl %eax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movl 0x38(%rsp), %edx
movl 0x3c(%rsp), %ecx
leaq 0x8(%rsp), %rsi
callq 0x17a10
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x19d10
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x3c(%rsp), %esi
callq 0x191b0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: localfunc
static void localfunc(LexState*ls){
expdesc v,b;
FuncState*fs=ls->fs;
new_localvar(ls,str_checkname(ls),0);
init_exp(&v,VLOCAL,fs->freereg);
luaK_reserveregs(fs,1);
adjustlocalvars(ls,1);
body(ls,&b,0,ls->linenumber);
luaK_storevar(fs,&v,&b);
getlocvar(fs,fs->nactvar-1).startpc=fs->pc;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x18240
movq (%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x183a0
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %edx
leaq 0x28(%rsp), %rdi
movl $0x6, %esi
callq 0x17740
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x17170
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x18430
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x17a10
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x19d10
movq 0x8(%rsp), %rax
movl 0x30(%rax), %ecx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq 0x8(%rsp), %rdx
movq 0x8(%rsp), %rsi
movzbl 0x4a(%rsi), %esi
subl $0x1, %esi
movslq %esi, %rsi
movzwl 0xc4(%rdx,%rsi,2), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: localstat
static void localstat(LexState*ls){
int nvars=0;
int nexps;
expdesc e;
do{
new_localvar(ls,str_checkname(ls),nvars++);
}while(testnext(ls,','));
if(testnext(ls,'='))
nexps=explist1(ls,&e);
else{
e.k=VVOID;
nexps=0;
}
adjust_assign(ls,nvars,nexps,&e);
adjustlocalvars(ls,nvars);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x18240
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x2c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x183a0
movq 0x30(%rsp), %rdi
movl $0x2c, %esi
callq 0x147e0
cmpl $0x0, %eax
jne 0x14e71
movq 0x30(%rsp), %rdi
movl $0x3d, %esi
callq 0x147e0
cmpl $0x0, %eax
je 0x14edc
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x19130
movl %eax, 0x28(%rsp)
jmp 0x14eec
movl $0x0, 0x10(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
leaq 0x10(%rsp), %rcx
callq 0x19bc0
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x18430
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: retstat
static void retstat(LexState*ls){
FuncState*fs=ls->fs;
expdesc e;
int first,nret;
luaX_next(ls);
if(block_follow(ls->t.token)||ls->t.token==';')
first=nret=0;
else{
nret=explist1(ls,&e);
if(hasmultret(e.k)){
luaK_setmultret(fs,&e);
if(e.k==VCALL&&nret==1){
SET_OPCODE(getcode(fs,&e),OP_TAILCALL);
}
first=fs->nactvar;
nret=(-1);
}
else{
if(nret==1)
first=luaK_exp2anyreg(fs,&e);
else{
luaK_exp2nextreg(fs,&e);
first=fs->nactvar;
}
}
}
luaK_ret(fs,first,nret);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x122d0
movq 0x30(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x145f0
cmpl $0x0, %eax
jne 0x14f5e
movq 0x30(%rsp), %rax
cmpl $0x3b, 0x10(%rax)
jne 0x14f73
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
jmp 0x15037
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x19130
movl %eax, 0x8(%rsp)
cmpl $0xd, 0x10(%rsp)
je 0x14f94
cmpl $0xe, 0x10(%rsp)
jne 0x14ffb
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x18280
cmpl $0xd, 0x10(%rsp)
jne 0x14fe4
cmpl $0x1, 0x8(%rsp)
jne 0x14fe4
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %edx
andl $-0x40, %edx
orl $0x1d, %edx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x28(%rsp), %rax
movzbl 0x4a(%rax), %eax
movl %eax, 0xc(%rsp)
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
jmp 0x15035
cmpl $0x1, 0x8(%rsp)
jne 0x15017
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x15ef0
movl %eax, 0xc(%rsp)
jmp 0x15033
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x16470
movq 0x28(%rsp), %rax
movzbl 0x4a(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x15035
jmp 0x15037
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x19e30
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: breakstat
static void breakstat(LexState*ls){
FuncState*fs=ls->fs;
BlockCnt*bl=fs->bl;
int upval=0;
while(bl&&!bl->isbreakable){
upval|=bl->upval;
bl=bl->previous;
}
if(!bl)
luaX_syntaxerror(ls,"no loop to break");
if(upval)
luaK_codeABC(fs,OP_CLOSE,bl->nactvar,0,0);
luaK_concat(fs,&bl->breaklist,luaK_jump(fs));
}

// 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 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x20(%rsp)
movb %al, 0x1b(%rsp)
je 0x1509d
movq 0x20(%rsp), %rax
cmpb $0x0, 0xe(%rax)
setne %al
xorb $-0x1, %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
testb $0x1, %al
jne 0x150a7
jmp 0x150c7
movq 0x20(%rsp), %rax
movzbl 0xd(%rax), %eax
orl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1507d
cmpq $0x0, 0x20(%rsp)
jne 0x150e0
movq 0x30(%rsp), %rdi
leaq 0xde64(%rip), %rsi      # 0x22f3f
callq 0x14360
cmpl $0x0, 0x1c(%rsp)
je 0x15105
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movzbl 0xc(%rax), %edx
movl $0x23, %esi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x164d0
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x152a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
callq 0x15220
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: exprstat
static void exprstat(LexState*ls){
FuncState*fs=ls->fs;
struct LHS_assign v;
primaryexp(ls,&v.v);
if(v.v.k==VCALL)
SETARG_C(getcode(fs,&v.v),1);
else{
v.prev=NULL;
assignment(ls,&v,1);
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x17b50
cmpl $0xd, 0x10(%rsp)
jne 0x151a7
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %edx
andl $0xff803fff, %edx       # imm = 0xFF803FFF
orl $0x4000, %edx           # imm = 0x4000
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x151c4
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19e70
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: test_then_block
static int test_then_block(LexState*ls){
int condexit;
luaX_next(ls);
condexit=cond(ls);
checknext(ls,TK_THEN);
block(ls);
return condexit;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x122d0
movq 0x10(%rsp), %rdi
callq 0x15340
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x112, %esi            # imm = 0x112
callq 0x15390
movq 0x10(%rsp), %rdi
callq 0x14a10
movl 0xc(%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_concat
static void luaK_concat(FuncState*fs,int*l1,int l2){
if(l2==(-1))return;
else if(*l1==(-1))
*l1=l2;
else{
int list=*l1;
int next;
while((next=getjump(fs,list))!=(-1))
list=next;
fixjump(fs,list,l2);
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x1523b
jmp 0x15292
movq 0x18(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x15252
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x15290
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x16950
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x1527e
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x1525d
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x16a80
jmp 0x15292
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_jump
static int luaK_jump(FuncState*fs){
int jpc=fs->jpc;
int j;
fs->jpc=(-1);
j=luaK_codeAsBx(fs,OP_JMP,0,(-1));
luaK_concat(fs,&j,jpc);
return j;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdi
movl $0x16, %esi
xorl %edx, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x16530
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0x8(%rsp), %rsi
callq 0x15220
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: cond
static int cond(LexState*ls){
expdesc v;
expr(ls,&v);
if(v.k==VNIL)v.k=VFALSE;
luaK_goiftrue(ls->fs,&v);
return v.f;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x153c0
cmpl $0x1, 0x8(%rsp)
jne 0x15367
movl $0x3, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x153f0
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_goiftrue
static void luaK_goiftrue(FuncState*fs,expdesc*e){
int pc;
luaK_dischargevars(fs,e);
switch(e->k){
case VK:case VKNUM:case VTRUE:{
pc=(-1);
break;
}
case VJMP:{
invertjump(fs,e);
pc=e->u.s.info;
break;
}
default:{
pc=jumponcond(fs,e,0);
break;
}
}
luaK_concat(fs,&e->f,pc);
luaK_patchtohere(fs,e->t);
e->t=(-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 $0x2, %eax
je 0x15435
jmp 0x1541e
movl (%rsp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0x15435
jmp 0x1542b
movl (%rsp), %eax
subl $0xa, %eax
je 0x1543f
jmp 0x1545c
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x15471
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x17650
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x15471
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x19290
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x14, %rsi
movl 0x4(%rsp), %edx
callq 0x15220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x15300
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: subexpr
static BinOpr subexpr(LexState*ls,expdesc*v,unsigned int limit){
BinOpr op;
UnOpr uop;
enterlevel(ls);
uop=getunopr(ls->t.token);
if(uop!=OPR_NOUNOPR){
luaX_next(ls);
subexpr(ls,v,8);
luaK_prefix(ls->fs,uop,v);
}
else simpleexp(ls,v);
op=getbinopr(ls->t.token);
while(op!=OPR_NOBINOPR&&priority[op].left>limit){
expdesc v2;
BinOpr nextop;
luaX_next(ls);
luaK_infix(ls->fs,op,v);
nextop=subexpr(ls,&v2,priority[op].right);
luaK_posfix(ls->fs,op,v,&v2);
op=nextop;
}
leavelevel(ls);
return op;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rdi
callq 0x145b0
movq 0x40(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x15600
movl %eax, 0x2c(%rsp)
cmpl $0x3, 0x2c(%rsp)
je 0x1551b
movq 0x40(%rsp), %rdi
callq 0x122d0
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x8, %edx
callq 0x154b0
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x2c(%rsp), %esi
movq 0x38(%rsp), %rdx
callq 0x15660
jmp 0x1552a
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x15740
movq 0x40(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x15930
movl %eax, 0x30(%rsp)
xorl %eax, %eax
cmpl $0xf, 0x30(%rsp)
movb %al, 0xb(%rsp)
je 0x15564
movl 0x30(%rsp), %eax
movl %eax, %ecx
leaq 0xd1bb(%rip), %rax      # 0x22710
movzbl (%rax,%rcx,2), %eax
cmpl 0x34(%rsp), %eax
seta %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x1556e
jmp 0x155dd
movq 0x40(%rsp), %rdi
callq 0x122d0
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x30(%rsp), %esi
movq 0x38(%rsp), %rdx
callq 0x15ad0
movq 0x40(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, %ecx
leaq 0xd16f(%rip), %rax      # 0x22710
movzbl 0x1(%rax,%rcx,2), %edx
leaq 0x10(%rsp), %rsi
callq 0x154b0
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x30(%rsp), %esi
movq 0x38(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x15b70
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rsp)
jmp 0x1553b
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
movw 0x60(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x60(%rax)
movl 0x30(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getunopr
static UnOpr getunopr(int op){
switch(op){
case TK_NOT:return OPR_NOT;
case'-':return OPR_MINUS;
case'#':return OPR_LEN;
default:return OPR_NOUNOPR;
}
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
subl $0x23, %eax
je 0x1563f
jmp 0x15613
movl -0xc(%rsp), %eax
subl $0x2d, %eax
je 0x15635
jmp 0x1561e
movl -0xc(%rsp), %eax
subl $0x10e, %eax            # imm = 0x10E
jne 0x15649
jmp 0x1562b
movl $0x1, -0x4(%rsp)
jmp 0x15651
movl $0x0, -0x4(%rsp)
jmp 0x15651
movl $0x2, -0x4(%rsp)
jmp 0x15651
movl $0x3, -0x4(%rsp)
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: luaK_prefix
static void luaK_prefix(FuncState*fs,UnOpr op,expdesc*e){
expdesc e2;
e2.t=e2.f=(-1);e2.k=VKNUM;e2.u.nval=0;
switch(op){
case OPR_MINUS:{
if(!isnumeral(e))
luaK_exp2anyreg(fs,e);
codearith(fs,OP_UNM,e,&e2);
break;
}
case OPR_NOT:codenot(fs,e);break;
case OPR_LEN:{
luaK_exp2anyreg(fs,e);
codearith(fs,OP_LEN,e,&e2);
break;
}
default:;
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movl $0x5, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x156b7
jmp 0x156a1
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x156f0
jmp 0x156ac
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x15701
jmp 0x1572b
movq 0x20(%rsp), %rdi
callq 0x15eb0
cmpl $0x0, %eax
jne 0x156d5
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x15ef0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x12, %esi
leaq 0x8(%rsp), %rcx
callq 0x15f90
jmp 0x1572d
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x16090
jmp 0x1572d
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x15ef0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x14, %esi
leaq 0x8(%rsp), %rcx
callq 0x15f90
jmp 0x1572d
jmp 0x1572d
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: simpleexp
static void simpleexp(LexState*ls,expdesc*v){
switch(ls->t.token){
case TK_NUMBER:{
init_exp(v,VKNUM,0);
v->u.nval=ls->t.seminfo.r;
break;
}
case TK_STRING:{
codestring(ls,v,ls->t.seminfo.ts);
break;
}
case TK_NIL:{
init_exp(v,VNIL,0);
break;
}
case TK_TRUE:{
init_exp(v,VTRUE,0);
break;
}
case TK_FALSE:{
init_exp(v,VFALSE,0);
break;
}
case TK_DOTS:{
FuncState*fs=ls->fs;
check_condition(ls,fs->f->is_vararg,
"cannot use "LUA_QL("...")" outside a vararg function");
fs->f->is_vararg&=~4;
init_exp(v,VVARARG,luaK_codeABC(fs,OP_VARARG,0,1,0));
break;
}
case'{':{
constructor(ls,v);
return;
}
case TK_FUNCTION:{
luaX_next(ls);
body(ls,v,0,ls->linenumber);
return;
}
default:{
primaryexp(ls,v);
return;
}
}
luaX_next(ls);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x7b, %eax
je 0x158d4
jmp 0x15765
movl 0xc(%rsp), %eax
subl $0x107, %eax            # imm = 0x107
je 0x1584a
jmp 0x15776
movl 0xc(%rsp), %eax
subl $0x109, %eax            # imm = 0x109
je 0x158e5
jmp 0x15787
movl 0xc(%rsp), %eax
subl $0x10d, %eax            # imm = 0x10D
je 0x1581e
jmp 0x15798
movl 0xc(%rsp), %eax
subl $0x113, %eax            # imm = 0x113
je 0x15834
jmp 0x157a9
movl 0xc(%rsp), %eax
subl $0x117, %eax            # imm = 0x117
je 0x15860
jmp 0x157ba
movl 0xc(%rsp), %eax
subl $0x11c, %eax            # imm = 0x11C
je 0x157d7
jmp 0x157c7
movl 0xc(%rsp), %eax
subl $0x11e, %eax            # imm = 0x11E
je 0x15801
jmp 0x1590a
movq 0x18(%rsp), %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x17740
movq 0x20(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x1591b
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x17780
jmp 0x1591b
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x17740
jmp 0x1591b
movq 0x18(%rsp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x17740
jmp 0x1591b
movq 0x18(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x17740
jmp 0x1591b
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, 0x72(%rax)
jne 0x1588d
movq 0x20(%rsp), %rdi
leaq 0xd4f3(%rip), %rsi      # 0x22d7b
callq 0x14360
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x72(%rax), %ecx
andl $-0x5, %ecx
movb %cl, 0x72(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x25, %esi
xorl %r8d, %r8d
movl $0x1, %ecx
movl %r8d, %edx
callq 0x164d0
movq (%rsp), %rdi
movl %eax, %edx
movl $0xe, %esi
callq 0x17740
jmp 0x1591b
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x177d0
jmp 0x15925
movq 0x20(%rsp), %rdi
callq 0x122d0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
xorl %edx, %edx
callq 0x17a10
jmp 0x15925
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17b50
jmp 0x15925
movq 0x20(%rsp), %rdi
callq 0x122d0
addq $0x28, %rsp
retq
nopw (%rax,%rax)