LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: read_long_string
static void read_long_string(LexState*ls,SemInfo*seminfo,int sep){
int cont=0;
(void)(cont);
save_and_next(ls);
if(currIsNewline(ls))
inclinenumber(ls);
for(;;){
switch(ls->current){
case(-1):
luaX_lexerror(ls,(seminfo)?"unfinished long string":
"unfinished long comment",TK_EOS);
break;
case']':{
if(skip_sep(ls)==sep){
save_and_next(ls);
goto endloop;
}
break;
}
case'\n':
case'\r':{
save(ls,'\n');
inclinenumber(ls);
if(!seminfo)luaZ_resetbuffer(ls->buff);
break;
}
default:{
if(seminfo)save_and_next(ls);
else next(ls);
}
}
}endloop:
if(seminfo)
seminfo->ts=luaX_newstring(ls,luaZ_buffer(ls->buff)+(2+sep),
luaZ_bufflen(ls->buff)-2*(2+sep));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
callq 0xcf03
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xcd33
callq 0xc41c
jmp 0xcd42
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0xd, %eax
je 0xcd4f
cmpl $0xa, %eax
jne 0xcdbf
movq %r14, %rdi
callq 0xcc05
jmp 0xcdbf
cmpl $0xa, %esi
jne 0xcd86
movq %r14, %rdi
movl $0xa, %esi
callq 0xcf03
movq %r14, %rdi
callq 0xcc05
testq %rbx, %rbx
jne 0xcdbf
movq 0x48(%r14), %rax
movq $0x0, 0x8(%rax)
jmp 0xcdbf
cmpl $-0x1, %esi
je 0xce42
testq %rbx, %rbx
je 0xcd9c
movq %r14, %rdi
callq 0xcf03
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xcdad
callq 0xc41c
jmp 0xcdbc
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
movl (%r14), %esi
cmpl $0xc, %esi
jle 0xcd59
cmpl $0xd, %esi
je 0xcd5e
cmpl $0x5d, %esi
jne 0xcd8f
movq %r14, %rdi
callq 0xcc88
cmpl %r15d, %eax
jne 0xcdbf
movl (%r14), %esi
movq %r14, %rdi
callq 0xcf03
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xcdfa
callq 0xc41c
jmp 0xce09
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0xce3c
movq 0x48(%r14), %rax
movl %r15d, %ecx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rcx, %rsi
addq $0x2, %rsi
leal 0x4(,%r15,2), %eax
subq %rax, %rdx
movq %r14, %rdi
callq 0xd0f1
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
testq %rbx, %rbx
leaq 0x8c69(%rip), %rax      # 0x15ab5
leaq 0x8c4b(%rip), %rsi      # 0x15a9e
cmoveq %rax, %rsi
movq %r14, %rdi
movl $0x11f, %edx            # imm = 0x11F
callq 0xce64
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
addq $0x18, %rsi
movq %rsp, %r12
movl $0x50, %edx
movq %r12, %rdi
callq 0x4ca9
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x87ca(%rip), %rsi      # 0x15668
movq %r12, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x4d90
testl %r14d, %r14d
je 0xcef5
movq %rax, %r15
movq 0x38(%rbx), %r12
leal -0x11c(%r14), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0xced6
xorl %esi, %esi
callq 0xcf03
movq 0x48(%rbx), %rax
movq (%rax), %rcx
jmp 0xcee1
movl %r14d, %esi
callq 0xd1a0
movq %rax, %rcx
leaq 0x8be5(%rip), %rsi      # 0x15acd
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4d90
movq 0x38(%rbx), %rdi
movl $0x3, %esi
callq 0x441b
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x48(%rdi), %r15
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
leaq 0x1(%rcx), %rsi
cmpq %rdx, %rsi
jbe 0xcf52
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rax, %rdx
jae 0xcf62
leaq (%rdx,%rdx), %r14
movq 0x38(%rdi), %rdi
movq (%r15), %rsi
movq %r14, %rcx
callq 0x43d1
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq 0x8(%r15), %rcx
leaq 0x1(%rcx), %rsi
jmp 0xcf55
movq (%r15), %rax
movq %rsi, 0x8(%r15)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8ba9(%rip), %rsi      # 0x15b12
xorl %edx, %edx
callq 0xce64
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq %rsi, %rdi
movl %ebp, %esi
callq 0x30f0
testq %rax, %rax
je 0xcfa2
movq %rbx, %rdi
movl %ebp, %esi
callq 0xcf03
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xcfa6
callq 0xc41c
jmp 0xcfb5
xorl %eax, %eax
jmp 0xcfbc
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xcf03
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xcfef
callq 0xc41c
movl %eax, %ebp
jmp 0xcffe
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movl %ebp, (%rbx)
callq 0x32f0
cmpl $0x2e, %ebp
je 0xcfd2
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0xcfd2
leaq 0x8b06(%rip), %rsi      # 0x15b2b
movq %rbx, %rdi
callq 0xcf70
testl %eax, %eax
je 0xd040
leaq 0x8af6(%rip), %rsi      # 0x15b2e
movq %rbx, %rdi
callq 0xcf70
movslq (%rbx), %rsi
cmpq $0x5f, %rsi
je 0xd055
movq (%r15), %rax
movzwl (%rax,%rsi,2), %eax
andl $0x8, %eax
je 0xd092
movq %rbx, %rdi
callq 0xcf03
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xd070
callq 0xc41c
movl %eax, %esi
jmp 0xd07f
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %esi
movl %esi, (%rbx)
cmpl $0x5f, %esi
je 0xd055
movq (%r15), %rax
movslq %esi, %rcx
movzwl (%rax,%rcx,2), %eax
jmp 0xd050
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcf03
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xd0c6
movb 0x58(%rbx), %cl
cmpb $0x2e, -0x1(%rdi,%rax)
jne 0xd0ba
movb %cl, -0x1(%rdi,%rax)
decq %rax
jne 0xd0af
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x840e
testl %eax, %eax
je 0xd0dd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8a4d(%rip), %rsi      # 0x15b31
movq %rbx, %rdi
movl $0x11c, %edx            # imm = 0x11C
callq 0xce64
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x4265
movq %rax, %r14
movq 0x30(%r15), %rax
movq 0x8(%rax), %rsi
movb 0xb(%rsi), %cl
movq $-0x1, %rax
shlq %cl, %rax
notl %eax
andl 0xc(%r14), %eax
cltq
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x20(%rsi), %rax
cmpl $0x4, 0x18(%rax)
jne 0xd141
cmpq %r14, 0x10(%rax)
je 0xd161
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xd135
movq %rsp, %rdx
movq %r14, (%rdx)
movl $0x4, 0x8(%rdx)
movq %rbx, %rdi
callq 0x7b71
jmp 0xd16d
leaq 0x8330(%rip), %rcx      # 0x15498
cmpq %rcx, %rax
je 0xd14a
cmpl $0x0, 0x8(%rax)
jne 0xd193
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xd193
movq %rbx, %rdi
callq 0x6bbf
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl $0x100, %esi            # imm = 0x100
jg 0xd1cf
movq %rdi, %r14
callq 0x32f0
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x2, (%rax,%rcx,2)
movq 0x38(%r14), %rdi
jne 0xd1e8
leaq 0x8916(%rip), %rsi      # 0x15ae3
jmp 0xd1ef
addl $0xfffffeff, %ebx       # imm = 0xFFFFFEFF
leaq 0xe774(%rip), %rax      # 0x1b950
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x88eb(%rip), %rsi      # 0x15ada
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4d90
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl %esi, 0x10(%rdi)
jne 0xd246
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xd22c
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xc46b
movl %eax, 0x10(%rbx)
jmp 0xd240
leaq 0x10(%rbx), %rax
addq $0x20, %rbx
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl $0x11f, (%rbx)          # imm = 0x11F
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0x10, %rsp
movq 0x30(%rdi), %rbx
movq %rsp, %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movb %cl, 0xe(%rax)
movb 0x4a(%rbx), %dl
movb %dl, 0xc(%rax)
movb %cl, 0xd(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x28(%rbx)
callq 0xb65d
movq %rbx, %rdi
callq 0xfe67
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0xd1ff
testl %eax, %eax
je 0xd2ab
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl %ebp, 0x4(%rbx)
jne 0xd2bb
movq %rbx, %rdi
movl %r15d, %esi
callq 0xfef5
movq 0x38(%rbx), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0xd1a0
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0xd1a0
leaq 0x8a18(%rip), %rsi      # 0x15cf7
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x4d90
movl 0x10(%rbx), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce64
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rbx
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0xd329
xorl %eax, %eax
cmpb $0x0, 0xe(%r14)
jne 0xd338
movzbl 0xd(%r14), %ecx
orl %ecx, %eax
movq (%r14), %r14
testq %r14, %r14
jne 0xd313
movl 0x10(%rdi), %edx
leaq 0x8a5d(%rip), %rsi      # 0x15d90
callq 0xce64
testl %eax, %eax
je 0xd356
movzbl 0xc(%r14), %esi
shll $0x6, %esi
orl $0x23, %esi
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0xe291
addq $0x8, %r14
movq %rbx, %rdi
callq 0xd417
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd3d7
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xd39b
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xc46b
movl %eax, 0x10(%rbx)
jmp 0xd3af
leaq 0x20(%rbx), %rax
leaq 0x10(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %rbx, %rdi
callq 0xd45e
movl %eax, %ebp
movq %rbx, %rdi
movl $0x112, %esi            # imm = 0x112
callq 0xd49c
movq %rbx, %rdi
callq 0xd247
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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:
cmpl $-0x1, %edx
je 0xd416
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0xd414
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl %ecx, %esi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
shrl $0xe, %ecx
leal -0x1ffff(%rcx), %r8d
cmpl $-0x1, %r8d
je 0xd40f
addl %esi, %ecx
addl $0xfffe0002, %ecx       # imm = 0xFFFE0002
cmpl $-0x1, %ecx
jne 0xd3ea
jmp 0xe4b2
movl %edx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x38(%rdi), %ebp
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq 0x18(%rdi), %rax
movl 0x8(%rax), %edx
movl $0x7fff8016, %esi       # imm = 0x7FFF8016
callq 0xe291
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xd3d7
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0xd5a1
cmpl $0x1, (%r14)
jne 0xd482
movl $0x3, (%rsp)
movq 0x30(%rbx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0xd4e5
movl 0x14(%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe021
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0xd56f
cmpl $0x2, %eax
je 0xd56f
cmpl $0xa, %eax
jne 0xd53e
movq (%r14), %rcx
movslq 0x8(%rbx), %rdx
leaq (,%rdx,4), %rax
addq 0x18(%rcx), %rax
testq %rdx, %rdx
jle 0xd54f
movl -0x4(%rax), %ecx
movabsq $0x3df07fffff, %rdx     # imm = 0x3DF07FFFFF
btq %rcx, %rdx
jb 0xd54f
addq $-0x4, %rax
jmp 0xd551
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xfcd3
movl %eax, %edx
jmp 0xd56f
movl (%rax), %ecx
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x8(%rbx), %edx
leaq 0x14(%rbx), %rsi
movq %r14, %rdi
callq 0xd3d7
movl 0x10(%rbx), %edx
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
leaq 0x38(%r14), %rsi
movq %r14, %rdi
callq 0xd3d7
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_exp2anyreg
static int luaK_exp2anyreg(FuncState*fs,expdesc*e){
luaK_dischargevars(fs,e);
if(e->k==VNONRELOC){
if(!hasjumps(e))return e->u.s.info;
if(e->u.s.info>=fs->nactvar){
exp2reg(fs,e,e->u.s.info);
return e->u.s.info;
}
}
luaK_exp2nextreg(fs,e);
return e->u.s.info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe021
cmpl $0xc, (%rbx)
jne 0xde3c
movl 0x10(%rbx), %eax
leaq 0x8(%rbx), %r15
cmpl 0x14(%rbx), %eax
je 0xde4e
movl (%r15), %edx
movzbl 0x4a(%r14), %eax
cmpl %eax, %edx
jge 0xde57
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe1f0
addq $0x8, %rbx
movq %rbx, %r15
movl (%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe0ba
jmp 0xde4e
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: codearith
static void codearith(FuncState*fs,OpCode op,expdesc*e1,expdesc*e2){
if(constfolding(op,e1,e2))
return;
else{
int o2=(op!=OP_UNM&&op!=OP_LEN)?luaK_exp2RK(fs,e2):0;
int o1=luaK_exp2RK(fs,e1);
if(o1>o2){
freeexp(fs,e1);
freeexp(fs,e2);
}
else{
freeexp(fs,e2);
freeexp(fs,e1);
}
e1->u.s.info=luaK_codeABC(fs,op,0,o1,o2);
e1->k=VRELOCABLE;
}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x5, (%rdx)
jne 0xdea8
cmpl $-0x1, 0x10(%rbx)
jne 0xdea8
cmpl $-0x1, 0x14(%rbx)
jne 0xdea8
cmpl $0x5, (%r12)
jne 0xdea8
cmpl $-0x1, 0x10(%r12)
jne 0xdea8
cmpl $-0x1, 0x14(%r12)
je 0xdf67
xorl %ebp, %ebp
cmpl $0x12, %r15d
je 0xdec3
cmpl $0x14, %r15d
je 0xdec3
movq %r14, %rdi
movq %r12, %rsi
callq 0xe900
movl %eax, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe900
cmpl %ebp, %eax
jle 0xdefb
cmpl $0xc, (%rbx)
jne 0xdeed
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0xdeed
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xdeed
decl 0x3c(%r14)
cmpl $0xc, (%r12)
jne 0xdf35
movl 0x8(%r12), %ecx
jmp 0xdf22
cmpl $0xc, (%r12)
jne 0xdf1a
movl 0x8(%r12), %ecx
btl $0x8, %ecx
jb 0xdf1a
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xdf1a
decl 0x3c(%r14)
cmpl $0xc, (%rbx)
jne 0xdf35
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0xdf35
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0xdf35
decl 0x3c(%r14)
shll $0x17, %eax
shll $0xe, %ebp
orl %eax, %ebp
orl %r15d, %ebp
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0xe291
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorpd %xmm0, %xmm0
leal -0xc(%r15), %eax
cmpl $0x8, %eax
ja 0xdfdc
movsd 0x8(%rbx), %xmm2
movsd 0x8(%r12), %xmm1
leaq 0x73dd(%rip), %rcx      # 0x15364
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
jmp 0xdfce
movapd %xmm2, %xmm0
callq 0x30c0
jmp 0xdfd2
subsd %xmm1, %xmm2
jmp 0xdfce
xorpd 0x70b1(%rip), %xmm2     # 0x15060
jmp 0xdfce
xorl %ebp, %ebp
jmp 0xdec3
mulsd %xmm1, %xmm2
jmp 0xdfce
ucomisd %xmm0, %xmm1
jne 0xdfca
jnp 0xdeb6
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
ucomisd %xmm0, %xmm0
jp 0xdea8
movsd %xmm0, 0x8(%rbx)
jmp 0xdf5a
ucomisd %xmm0, %xmm1
jne 0xdff2
jnp 0xdeb6
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x3270
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xdfd2
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_dischargevars
static void luaK_dischargevars(FuncState*fs,expdesc*e){
switch(e->k){
case VLOCAL:{
e->k=VNONRELOC;
break;
}
case VUPVAL:{
e->u.s.info=luaK_codeABC(fs,OP_GETUPVAL,0,e->u.s.info,0);
e->k=VRELOCABLE;
break;
}
case VGLOBAL:{
e->u.s.info=luaK_codeABx(fs,OP_GETGLOBAL,0,e->u.s.info);
e->k=VRELOCABLE;
break;
}
case VINDEXED:{
freereg(fs,e->u.s.aux);
freereg(fs,e->u.s.info);
e->u.s.info=luaK_codeABC(fs,OP_GETTABLE,0,e->u.s.info,e->u.s.aux);
e->k=VRELOCABLE;
break;
}
case VVARARG:
case VCALL:{
luaK_setoneret(fs,e);
break;
}
default:break;
}
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x8, %eax
ja 0xe0b8
movq %rsi, %rbx
leaq 0x734e(%rip), %rcx      # 0x15388
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rsi
popq %rbx
jmp 0xe244
movl 0x8(%rbx), %esi
shll $0xe, %esi
orl $0x5, %esi
jmp 0xe0a3
movl $0xc, (%rbx)
jmp 0xe0b8
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x4, %esi
jmp 0xe0a3
movl 0xc(%rbx), %eax
btl $0x8, %eax
jb 0xe07e
movzbl 0x4a(%rdi), %ecx
cmpl %ecx, %eax
jl 0xe07e
decl 0x3c(%rdi)
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0xe095
movzbl 0x4a(%rdi), %ecx
cmpl %ecx, %eax
jl 0xe095
decl 0x3c(%rdi)
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %esi
shll $0x17, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x6, %esi
movq 0x18(%rdi), %rax
movl 0x8(%rax), %edx
callq 0xe291
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: exp2reg
static void exp2reg(FuncState*fs,expdesc*e,int reg){
discharge2reg(fs,e,reg);
if(e->k==VJMP)
luaK_concat(fs,&e->t,e->u.s.info);
if(hasjumps(e)){
int final;
int p_f=(-1);
int p_t=(-1);
if(need_value(fs,e->t)||need_value(fs,e->f)){
int fj=(e->k==VJMP)?(-1):luaK_jump(fs);
p_f=code_label(fs,reg,0,1);
p_t=code_label(fs,reg,1,0);
luaK_patchtohere(fs,fj);
}
final=luaK_getlabel(fs);
patchlistaux(fs,e->f,final,reg,p_f);
patchlistaux(fs,e->t,final,reg,p_t);
}
e->f=e->t=(-1);
e->u.s.info=reg;
e->k=VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe4fb
cmpl $0xa, (%rbx)
jne 0xe0e6
leaq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0xd3d7
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %r15d
cmpl %r15d, %esi
je 0xe1c2
movq %r14, %rdi
callq 0xe5e7
testl %eax, %eax
jne 0xe115
movq %r14, %rdi
movl %r15d, %esi
callq 0xe5e7
testl %eax, %eax
je 0xe1e2
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0xa, (%rbx)
je 0xe12b
movq %r14, %rdi
callq 0xd417
movl %eax, %r15d
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
movl %ebp, %r13d
shll $0x6, %r13d
movl %r13d, %esi
orl $0x4002, %esi           # imm = 0x4002
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0xe291
movl %eax, %r12d
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
orl $0x800002, %r13d        # imm = 0x800002
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %r13d, %esi
callq 0xe291
movl %eax, %r13d
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
leaq 0x38(%r14), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0xd3d7
movl %r12d, %r8d
movl 0x14(%rbx), %r15d
movl 0x30(%r14), %r12d
movl %r12d, 0x34(%r14)
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xe3c8
movl 0x10(%rbx), %esi
movq %r14, %rdi
movl %r12d, %edx
movl %ebp, %ecx
movl %r13d, %r8d
callq 0xe3c8
movq $-0x1, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
jmp 0xe197
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_exp2nextreg
static void luaK_exp2nextreg(FuncState*fs,expdesc*e){
luaK_dischargevars(fs,e);
freeexp(fs,e);
luaK_reserveregs(fs,1);
exp2reg(fs,e,fs->freereg-1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe021
cmpl $0xc, (%rbx)
jne 0xe21a
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0xe21a
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %eax
jl 0xe21a
decl 0x3c(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0xe8d1
movl 0x3c(%r14), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x3c(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe0ba
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_setoneret
static void luaK_setoneret(FuncState*fs,expdesc*e){
if(e->k==VCALL){
e->k=VNONRELOC;
e->u.s.info=GETARG_A(getcode(fs,e));
}
else if(e->k==VVARARG){
SETARG_B(getcode(fs,e),2);
e->k=VRELOCABLE;
}
}

// Assembly:
movl (%rsi), %eax
cmpl $0xe, %eax
je 0xe26e
cmpl $0xd, %eax
jne 0xe290
movl $0xc, (%rsi)
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x6, %eax
movzbl %al, %eax
movl %eax, 0x8(%rsi)
retq
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %edx         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %edx
orl $0x1000000, %edx        # imm = 0x1000000
movl %edx, (%rax,%rcx,4)
movl $0xb, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_code
static int luaK_code(FuncState*fs,Instruction i,int line){
Proto*f=fs->f;
dischargejpc(fs);
luaM_growvector(fs->L,f->code,fs->pc,f->sizecode,Instruction,
(INT_MAX-2),"code size overflow");
f->code[fs->pc]=i;
luaM_growvector(fs->L,f->lineinfo,fs->pc,f->sizelineinfo,int,
(INT_MAX-2),"code size overflow");
f->lineinfo[fs->pc]=line;
return fs->pc++;
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movl %ecx, (%rsp)
cmpl $-0x1, %esi
je 0xe436
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movq (%r12), %rax
movq 0x18(%rax), %rdi
movslq %r15d, %r13
movl (%rdi,%r13,4), %ebx
shrl $0xe, %ebx
leal -0x1ffff(%rbx), %ebp
movl %r13d, %esi
movl (%rsp), %edx
callq 0xe445
testl %eax, %eax
movl %r14d, %edx
cmovel 0x4(%rsp), %edx
movq %r12, %rdi
movl %r13d, %esi
callq 0xe4b2
cmpl $-0x1, %ebp
je 0xe436
addl %ebx, %r15d
addl $0xfffe0002, %r15d      # imm = 0xFFFE0002
cmpl $-0x1, %r15d
jne 0xe3e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: patchtestreg
static int patchtestreg(FuncState*fs,int node,int reg){
Instruction*i=getjumpcontrol(fs,node);
if(GET_OPCODE(*i)!=OP_TESTSET)
return 0;
if(reg!=((1<<8)-1)&&reg!=GETARG_B(*i))
SETARG_A(*i,reg);
else
*i=CREATE_ABC(OP_TEST,GETARG_B(*i),0,GETARG_C(*i));
return 1;
}

// Assembly:
movslq %esi, %rax
leaq (%rdi,%rax,4), %rcx
testl %eax, %eax
jle 0xe469
movl -0x4(%rcx), %esi
movabsq $0x3df07fffff, %rax     # imm = 0x3DF07FFFFF
btq %rsi, %rax
jb 0xe469
addq $-0x4, %rcx
jmp 0xe46b
movl (%rcx), %esi
movl %esi, %edi
andl $0x3f, %edi
xorl %eax, %eax
cmpl $0x1b, %edi
jne 0xe4b1
cmpl $0xff, %edx
je 0xe49a
movl %esi, %eax
shrl $0x17, %eax
cmpl %edx, %eax
je 0xe49a
andl $0xffffc01b, %esi       # imm = 0xFFFFC01B
movzbl %dl, %eax
shll $0x6, %eax
orl %esi, %eax
movl %eax, %esi
jmp 0xe4aa
movl %esi, %eax
shrl $0x11, %eax
andl $-0x40, %eax
andl $0x7fc01a, %esi         # imm = 0x7FC01A
orl %eax, %esi
movl %esi, (%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: fixjump
static void fixjump(FuncState*fs,int pc,int dest){
Instruction*jmp=&fs->f->code[pc];
int offset=dest-(pc+1);
if(abs(offset)>(((1<<(9+9))-1)>>1))
luaX_syntaxerror(fs->ls,"control structure too long");
SETARG_sBx(*jmp,offset);
}

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe021
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0xe5de
leaq 0x6e87(%rip), %rdx      # 0x153ac
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %ebp, %ecx
shll $0x6, %ecx
cmpl $0x2, %eax
movl $0x800000, %eax         # imm = 0x800000
movl $0x2, %esi
cmovel %eax, %esi
orl %ecx, %esi
orl $0x2, %esi
jmp 0xe5c6
movq (%r14), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rbx), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movzbl %bpl, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
jmp 0xe5d5
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0xe5d5
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
jmp 0xe5c6
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0xe646
jmp 0xe5d5
movl 0x8(%rbx), %esi
movl %ebp, %eax
shll $0x6, %eax
shll $0xe, %esi
jmp 0xe5c2
movsd 0x8(%rbx), %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0xe6dd
movl %ebp, %esi
shll $0x6, %esi
shll $0xe, %eax
orl %eax, %esi
incl %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0xe291
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: need_value
static int need_value(FuncState*fs,int list){
for(;list!=(-1);list=getjump(fs,list)){
Instruction i=*getjumpcontrol(fs,list);
if(GET_OPCODE(i)!=OP_TESTSET)return 1;
}
return 0;
}

// Assembly:
xorl %eax, %eax
cmpl $-0x1, %esi
je 0xe63f
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movabsq $0x3df07fffff, %rdx     # imm = 0x3DF07FFFFF
movslq %esi, %rdi
testl %edi, %edi
jle 0xe611
movl -0x4(%rcx,%rdi,4), %r8d
btq %r8, %rdx
jae 0xe615
movl (%rcx,%rdi,4), %r8d
andl $0x3f, %r8d
cmpl $0x1b, %r8d
jne 0xe640
movl (%rcx,%rdi,4), %edi
shrl $0xe, %edi
leal -0x1ffff(%rdi), %r8d
cmpl $-0x1, %r8d
je 0xe63f
addl %edi, %esi
addl $0xfffe0002, %esi       # imm = 0xFFFE0002
cmpl $-0x1, %esi
jne 0xe5ff
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_nil
static void luaK_nil(FuncState*fs,int from,int n){
Instruction*previous;
if(fs->pc>fs->lasttarget){
if(fs->pc==0){
if(from>=fs->nactvar)
return;
}
else{
previous=&fs->f->code[fs->pc-1];
if(GET_OPCODE(*previous)==OP_LOADNIL){
int pfrom=GETARG_A(*previous);
int pto=GETARG_B(*previous);
if(pfrom<=from&&from<=pto+1){
if(from+n-1>pto)
SETARG_B(*previous,from+n-1);
return;
}
}
}
}
luaK_codeABC(fs,OP_LOADNIL,from,from+n-1,0);
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x7aff
cmpl $0x3, 0x8(%rax)
jne 0xe70e
cvttsd2si (%rax), %eax
jmp 0xe8c7
movq (%rbx), %r12
leaq 0x4c(%r12), %rdx
movslq 0x4c(%r12), %r13
cvtsi2sdl 0x40(%rbx), %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
movl (%rdx), %ecx
cmpl %ecx, 0x40(%rbx)
jl 0xe75b
movq 0x10(%r12), %rsi
leaq 0x7453(%rip), %r9       # 0x15b91
movl $0x10, %ecx
movq %r14, %rdi
movl $0x3ffff, %r8d          # imm = 0x3FFFF
callq 0xe350
movq %rax, 0x10(%r12)
movl 0x4c(%r12), %ecx
movq 0x10(%r12), %rax
cmpl %ecx, %r13d
jge 0xe870
movslq %ecx, %rdx
subq %r13, %rdx
leaq 0x3(%rdx), %rcx
andq $-0x4, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shlq $0x4, %r13
leaq (%rax,%r13), %rdx
addq $0x38, %rdx
xorl %esi, %esi
movdqa 0x6876(%rip), %xmm1     # 0x15010
movdqa 0x687e(%rip), %xmm2     # 0x15020
movdqa 0x6886(%rip), %xmm3     # 0x15030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0xe7fc
movl $0x0, -0x30(%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xe812
movl $0x0, -0x20(%rdx)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0xe84e
movl $0x0, -0x10(%rdx)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0xe85f
movl $0x0, (%rdx)
addq $0x4, %rsi
addq $0x40, %rdx
cmpq %rsi, %rcx
jne 0xe7b2
movslq 0x40(%rbx), %rcx
shlq $0x4, %rcx
movq (%r15), %rdx
movq %rdx, (%rax,%rcx)
movl 0x8(%r15), %edx
movl %edx, 0x8(%rax,%rcx)
cmpl $0x4, %edx
jl 0xe8be
movq (%r15), %rsi
testb $0x3, 0x9(%rsi)
je 0xe8be
movb 0x9(%r12), %al
testb $0x4, %al
je 0xe8be
movq 0x20(%r14), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0xe8af
callq 0x46ab
jmp 0xe8be
andb $-0x8, %al
movb 0x20(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r12)
movl 0x40(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x40(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_checkstack
static void luaK_checkstack(FuncState*fs,int n){
int newstack=fs->freereg+n;
if(newstack>fs->f->maxstacksize){
if(newstack>=250)
luaX_syntaxerror(fs->ls,"function or expression too complex");
fs->f->maxstacksize=cast_byte(newstack);
}
}

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe9c8
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0xe926
cmpl $0x4, %eax
je 0xe95e
cmpl $0x5, %eax
jne 0xe968
cmpl $0xff, 0x40(%r14)
jg 0xe968
cmpl $0x5, %eax
je 0xe97a
cmpl $0x1, %eax
jne 0xe991
leaq 0x18(%rsp), %rdx
movl $0x0, 0x8(%rdx)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
movq %r14, %rdi
jmp 0xe9ad
movl 0x8(%rbx), %eax
cmpl $0xff, %eax
jle 0xe9bb
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xde0f
movsd 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
jmp 0xe9a7
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0xe6dd
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
orl $0x100, %eax            # imm = 0x100
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: listfield
static void listfield(LexState*ls,struct ConsControl*cc){
expr(ls,&cc->v);
luaY_checklimit(ls->fs,cc->na,(INT_MAX-2),"items in a constructor");
cc->na++;
cc->tostore++;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rbx
movl 0x3c(%rbx), %r13d
cmpl $0x11d, 0x10(%rdi)      # imm = 0x11D
jne 0xf341
cmpl $0x7ffffffe, 0x20(%r14) # imm = 0x7FFFFFFE
jge 0xf3c9
movq %r15, %rdi
callq 0xf50f
movq 0x30(%r15), %rdi
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movl $0x4, %ebp
movl %ebp, 0x8(%r12)
movq %r12, %rsi
movq %r12, %rdx
callq 0xe6dd
movq $-0x1, 0x10(%r12)
movl %ebp, (%r12)
movl %eax, 0x8(%r12)
jmp 0xf34e
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xf4a2
incl 0x20(%r14)
movq %r15, %rdi
movl $0x3d, %esi
callq 0xd49c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe900
movl %eax, %ebp
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xd5a1
movq 0x18(%r14), %rax
movl 0x8(%rax), %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe900
shll $0x6, %r14d
shll $0x17, %ebp
shll $0xe, %eax
orl %eax, %ebp
orl %r14d, %ebp
orl $0x9, %ebp
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe291
movl %r13d, 0x3c(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6827(%rip), %rdx      # 0x15bf7
movq %rbx, %rdi
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0xf45a
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: errorlimit
static void errorlimit(FuncState*fs,int limit,const char*what){
const char*msg=(fs->f->linedefined==0)?
luaO_pushfstring(fs->L,"main function has more than %d %s",limit,what):
luaO_pushfstring(fs->L,"function at line %d has more than %d %s",
fs->f->linedefined,limit,what);
luaX_lexerror(fs->ls,msg,0);
}

// Assembly:
pushq %rbx
movq %rdx, %r8
movl %esi, %ecx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rdi), %rdi
movl 0x60(%rax), %edx
testl %edx, %edx
jne 0xf486
leaq 0x6796(%rip), %rsi      # 0x15c0e
movl %ecx, %edx
movq %r8, %rcx
xorl %eax, %eax
callq 0x4d90
jmp 0xf494
leaq 0x67a3(%rip), %rsi      # 0x15c30
xorl %eax, %eax
callq 0x4d90
movq 0x18(%rbx), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xce64
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: yindex
static void yindex(LexState*ls,expdesc*v){
luaX_next(ls);
expr(ls,v);
luaK_exp2val(ls->fs,v);
checknext(ls,']');
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xf4ce
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xc46b
movl %eax, 0x10(%rbx)
jmp 0xf4e2
leaq 0x20(%rbx), %rax
leaq 0x10(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd5a1
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xe9c8
movq %rbx, %rdi
movl $0x5d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd49c
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_checkname
static TString*str_checkname(LexState*ls){
TString*ts;
check(ls,TK_NAME);
ts=ls->t.seminfo.ts;
luaX_next(ls);
return ts;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x11d, 0x10(%rdi)      # imm = 0x11D
jne 0xf562
movq 0x18(%rbx), %r14
movl 0x4(%rbx), %eax
movl %eax, 0x8(%rbx)
cmpl $0x11f, 0x20(%rbx)      # imm = 0x11F
jne 0xf543
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xc46b
movl %eax, 0x10(%rbx)
jmp 0xf557
leaq 0x10(%rbx), %rax
addq $0x20, %rbx
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl $0x11f, (%rbx)          # imm = 0x11F
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0x11d, %esi            # imm = 0x11D
callq 0xfef5
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: field
static void field(LexState*ls,expdesc*v){
FuncState*fs=ls->fs;
expdesc key;
luaK_exp2anyreg(fs,v);
luaX_next(ls);
checkname(ls,&key);
luaK_indexed(fs,v,&key);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x30(%rdi), %r14
movq %r14, %rdi
callq 0xde0f
movl 0x4(%r15), %eax
movl 0x20(%r15), %ecx
movl %eax, 0x8(%r15)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xf7dc
leaq 0x18(%r15), %rsi
movq %r15, %rdi
callq 0xc46b
movl %eax, 0x10(%r15)
jmp 0xf7f0
leaq 0x20(%r15), %rax
leaq 0x10(%r15), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %r15, %rdi
callq 0xf50f
movq 0x30(%r15), %rdi
movq %rsp, %r15
movq %rax, (%r15)
movl $0x4, %ebp
movl %ebp, 0x8(%r15)
movq %r15, %rsi
movq %r15, %rdx
callq 0xe6dd
movq $-0x1, 0x10(%r15)
movl %ebp, (%r15)
movl %eax, 0x8(%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0xe900
movl %eax, 0xc(%rbx)
movl $0x9, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: singlevar
static void singlevar(LexState*ls,expdesc*var){
TString*varname=str_checkname(ls);
FuncState*fs=ls->fs;
if(singlevaraux(fs,varname,var,1)==VGLOBAL)
var->u.s.info=luaK_stringK(fs,varname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xf50f
movq %rax, %r15
movq 0x30(%r14), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xfa8b
cmpl $0x8, %eax
jne 0xfa81
movq %rsp, %rdx
movq %r15, (%rdx)
movl $0x4, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0xe6dd
movl %eax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq