LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_setfenv
static int luaB_setfenv(lua_State*L){
luaL_checktype(L,2,5);
getfunc(L,0);
lua_pushvalue(L,2);
if(lua_isnumber(L,1)&&lua_tonumber(L,1)==0){
lua_pushthread(L);
lua_insert(L,-2);
lua_setfenv(L,-2);
return 0;
}
else if(lua_iscfunction(L,-2)||lua_setfenv(L,-2)==0)
luaL_error(L,
LUA_QL("setfenv")" cannot change environment of given object");
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl $0x2, %esi
movl $0x5, %edx
callq 0xf886
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpq %rax, %rcx
setae %dl
leaq 0xa906(%rip), %r15      # 0x14420
cmpq %r15, %rcx
sete %sil
orb %dl, %sil
jne 0x9b3f
cmpl $0x6, 0x8(%rcx)
jne 0x9b3f
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
jmp 0x9b9b
movq %rbx, %rdi
movl $0x1, %esi
callq 0xa770
movq %rax, %r14
testl %r14d, %r14d
js 0x9c5b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0xa228
testl %eax, %eax
je 0x9c64
leaq 0xb744(%rip), %rsi      # 0x152bb
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xa27a
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r15, %rcx
je 0x9b9b
cmpl $0x0, -0x8(%rax)
je 0x9c78
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
addq $0x10, %rcx
cmpq %rax, %rcx
cmovbq %rcx, %r15
movq (%r15), %rcx
movq %rcx, (%rax)
movl 0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xa7de
testl %eax, %eax
je 0x9c16
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf8db
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9c16
jp 0x9c16
movq 0x10(%rbx), %rax
movq %rbx, (%rax)
movl $0x8, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xa80f
movq %rbx, %rdi
callq 0xf90a
xorl %eax, %eax
jmp 0x9c3d
movq 0x10(%rbx), %rax
cmpl $0x6, -0x18(%rax)
jne 0x9c2a
movq -0x20(%rax), %rax
cmpb $0x0, 0xa(%rax)
jne 0x9c4a
movq %rbx, %rdi
callq 0xf90a
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x9c4a
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb14d(%rip), %rsi      # 0x14d9e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa049
leaq 0xb170(%rip), %rdx      # 0x14dd2
jmp 0x9c6b
leaq 0xb182(%rip), %rdx      # 0x14ded
movq %rbx, %rdi
movl $0x1, %esi
callq 0xa173
leaq 0xb17c(%rip), %rsi      # 0x14dfb
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xa049
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_setmetatable
static int luaB_setmetatable(lua_State*L){
int t=lua_type(L,2);
luaL_checktype(L,1,5);
luaL_argcheck(L,t==0||t==5,2,
"nil or table expected");
if(luaL_getmetafield(L,1,"__metatable"))
luaL_error(L,"cannot change a protected metatable");
lua_settop(L,2);
lua_setmetatable(L,1);
return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq 0x10(%rax), %rcx
cmpq 0x10(%rdi), %rcx
setae %dl
leaq 0xa774(%rip), %r14      # 0x14420
cmpq %r14, %rcx
sete %cl
orb %dl, %cl
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jne 0x9cbe
movl 0x18(%rax), %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0xf886
testl %ebp, %ebp
je 0x9cdd
cmpl $0x5, %ebp
jne 0x9d9b
movq %rbx, %rdi
callq 0xf9a2
testl %eax, %eax
je 0x9d37
leaq 0xb153(%rip), %rsi      # 0x14e43
movl $0xb, %edx
movq %rbx, %rdi
callq 0x90a1
movq 0x10(%rbx), %r15
movq -0x20(%r15), %rdi
leaq -0x10(%r15), %rsi
callq 0x759e
movq (%rax), %rcx
movq %rcx, -0x10(%r15)
movl 0x8(%rax), %eax
movl %eax, -0x8(%r15)
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r14, %rcx
je 0x9d7d
cmpl $0x0, -0x8(%rax)
jne 0x9d7d
addq $-0x20, %rax
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
addq $0x20, %rax
cmpq %rax, %rcx
jae 0x9d5c
movl $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x9d48
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x94dd
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf9ff
leaq 0xb0be(%rip), %rsi      # 0x14e4f
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa049
leaq 0xb08b(%rip), %rdx      # 0x14e2d
movq %rbx, %rdi
movl $0x2, %esi
callq 0xa173
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_tonumber
static int luaB_tonumber(lua_State*L){
int base=luaL_optint(L,2,10);
if(base==10){
luaL_checkany(L,1);
if(lua_isnumber(L,1)){
lua_pushnumber(L,lua_tonumber(L,1));
return 1;
}
}
else{
const char*s1=luaL_checkstring(L,1);
char*s2;
unsigned long n;
luaL_argcheck(L,2<=base&&base<=36,2,"base out of range");
n=strtoul(s1,&s2,base);
if(s1!=s2){
while(isspace((unsigned char)(*s2)))s2++;
if(*s2=='\0'){
lua_pushnumber(L,(lua_Number)n);
return 1;
}
}
}
lua_pushnil(L);
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %edx
movl $0x2, %esi
callq 0xa737
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0xa, %r14d
jne 0x9e0a
callq 0xa010
movq %rbx, %rdi
movl $0x1, %esi
callq 0xa7de
testl %eax, %eax
je 0x9e60
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf8db
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0x9e9e
xorl %edx, %edx
callq 0xa6a8
movq %rax, %r15
leal -0x2(%r14), %eax
cmpl $0x23, %eax
jae 0x9ebb
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x3260
cmpq (%r12), %r15
je 0x9e60
movq %rax, %r14
callq 0x32f0
movq (%rax), %rcx
movq (%rsp), %rax
decq %rax
movzbl 0x1(%rax), %edx
incq %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x9e4a
movq %rax, (%rsp)
testb %dl, %dl
je 0x9e75
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
jmp 0x9eaa
movq %r14, %xmm0
punpckldq 0xa70e(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xa716(%rip), %xmm0     # 0x145a0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq 0x10(%rbx), %rax
movsd %xmm1, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xafb1(%rip), %rdx      # 0x14e73
movq %rbx, %rdi
movl $0x2, %esi
callq 0xa173
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_unpack
static int luaB_unpack(lua_State*L){
int i,e,n;
luaL_checktype(L,1,5);
i=luaL_optint(L,2,1);
e=luaL_opt(L,luaL_checkint,3,luaL_getn(L,1));
if(i>e)return 0;
n=e-i+1;
if(n<=0||!lua_checkstack(L,n))
return luaL_error(L,"too many results to unpack");
lua_rawgeti(L,1,i);
while(i++<e)
lua_rawgeti(L,1,i);
return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0xf886
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0xa737
movq %rax, %r14
movq 0x18(%rbx), %rax
leaq 0x20(%rax), %rcx
cmpq 0x10(%rbx), %rcx
setae %dl
leaq 0xa4b7(%rip), %rsi      # 0x14420
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0x9f88
cmpl $0x0, 0x28(%rax)
jle 0x9f88
movq %rbx, %rdi
movl $0x3, %esi
callq 0xa770
jmp 0x9f95
movq %rbx, %rdi
movl $0x1, %esi
callq 0xfa2e
movq %rax, %r15
xorl %eax, %eax
movl %r15d, %ebp
subl %r14d, %ebp
jl 0x9ff4
js 0x9fff
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfa91
testl %eax, %eax
je 0x9fff
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0xfb01
cmpl %r14d, %r15d
jle 0x9ff2
negl %r15d
incl %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0xfb01
leal (%r15,%r14), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x9fcf
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xae7f(%rip), %rsi      # 0x14e85
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa049
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_error
static int luaL_error(lua_State*L,const char*fmt,...){
va_list argp;
va_start(argp,fmt);
luaL_where(L,1);
lua_pushvfstring(L,fmt,argp);
va_end(argp);
lua_concat(L,2);
return lua_error(L);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xa0a9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movl $0x1, %esi
callq 0xa517
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xa0e9
movq %rbx, %rdi
callq 0x68ed
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47c2
movq %rbx, %rdi
movl $0x2, %esi
callq 0xa57b
movq %rbx, %rdi
callq 0x4a5f
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_optlstring
static const char*luaL_optlstring(lua_State*L,int narg,
const char*def,size_t*len){
if(lua_isnoneornil(L,narg)){
if(len)
*len=(def?strlen(def):0);
return def;
}
else return luaL_checklstring(L,narg,len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x975f
leaq 0xa2f6(%rip), %rcx      # 0x14420
cmpq %rcx, %rax
je 0xa14c
cmpl $0x0, 0x8(%rax)
jle 0xa14c
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa6a8
testq %rbx, %rbx
je 0xa165
testq %r14, %r14
je 0xa160
movq %r14, %rdi
callq 0x30e0
jmp 0xa162
xorl %eax, %eax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_argerror
static int luaL_argerror(lua_State*L,int narg,const char*extramsg){
lua_Debug ar;
if(!lua_getstack(L,0,&ar))
return luaL_error(L,"bad argument #%d (%s)",narg,extramsg);
lua_getinfo(L,"n",&ar);
if(strcmp(ar.namewhat,"method")==0){
narg--;
if(narg==0)
return luaL_error(L,"calling "LUA_QL("%s")" on bad self (%s)",
ar.name,extramsg);
}
if(ar.name==NULL)
ar.name="?";
return luaL_error(L,"bad argument #%d to "LUA_QL("%s")" (%s)",
narg,ar.name,extramsg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x28(%rdi), %rax
subq 0x50(%rdi), %rax
jbe 0xa1e3
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
movq %rsp, %r15
movl %eax, 0x74(%r15)
leaq 0xa510(%rip), %rsi      # 0x146b7
movq %r14, %rdi
movq %r15, %rdx
callq 0xa27a
movq 0x10(%r15), %rdi
leaq 0xa7f3(%rip), %rsi      # 0x149b0
callq 0x3170
testl %eax, %eax
jne 0xa1f9
decl %ebp
jne 0xa1f9
movq 0x8(%rsp), %rdx
leaq 0xa7e1(%rip), %rsi      # 0x149b7
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xa049
leaq 0xa7b0(%rip), %rsi      # 0x1499a
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xa049
cmpq $0x0, 0x8(%rsp)
jne 0xa20d
leaq 0xa7cd(%rip), %rax      # 0x149d5
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
leaq 0xa7be(%rip), %rsi      # 0x149d7
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0xa049
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_getstack
static int lua_getstack(lua_State*L,int level,lua_Debug*ar){
int status;
CallInfo*ci;
for(ci=L->ci;level>0&&ci>L->base_ci;ci--){
level--;
if(f_isLua(ci))
level-=ci->tailcalls;
}
if(level==0&&ci>L->base_ci){
status=1;
ar->i_ci=cast_int(ci-L->base_ci);
}
else if(level<0){
status=1;
ar->i_ci=0;
}
else status=0;
return status;
}

// Assembly:
movq 0x28(%rdi), %rax
testl %esi, %esi
jle 0xa254
movq 0x50(%rdi), %rcx
cmpq %rcx, %rax
jbe 0xa254
decl %esi
movq 0x8(%rax), %r8
movq (%r8), %r8
cmpb $0x0, 0xa(%r8)
jne 0xa24c
subl 0x24(%rax), %esi
addq $-0x28, %rax
testl %esi, %esi
jg 0xa234
testl %esi, %esi
jne 0xa26a
subq 0x50(%rdi), %rax
jbe 0xa26a
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
jmp 0xa271
xorl %eax, %eax
testl %esi, %esi
js 0xa271
retq
movl %eax, 0x74(%rdx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_where
static void luaL_where(lua_State*L,int level){
lua_Debug ar;
if(lua_getstack(L,level,&ar)){
lua_getinfo(L,"Sl",&ar);
if(ar.currentline>0){
lua_pushfstring(L,"%s:%d: ",ar.short_src,ar.currentline);
return;
}
}
lua_pushliteral(L,"");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
callq 0xa228
testl %eax, %eax
je 0xa562
leaq 0xa4e3(%rip), %rsi      # 0x14a17
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xa27a
movl 0x28(%r14), %ecx
testl %ecx, %ecx
jle 0xa562
leaq 0x38(%rsp), %rdx
leaq 0xa4c4(%rip), %rsi      # 0x14a1a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa5f8
jmp 0xa573
leaq 0xa392(%rip), %rsi      # 0x148fb
movq %rbx, %rdi
xorl %edx, %edx
callq 0x90a1
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_concat
static void lua_concat(lua_State*L,int n){
api_checknelems(L,n);
if(n>=2){
luaC_checkGC(L);
luaV_concat(L,n,cast_int(L->top-L->base)-1);
L->top-=(n-1);
}
else if(n==0){
setsvalue(L,L->top,luaS_newlstr(L,"",0));
api_incr_top(L);
}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0xa5c6
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xa5a0
movq %rbx, %rdi
callq 0x68ed
movq 0x10(%rbx), %rdx
subq 0x18(%rbx), %rdx
shrq $0x4, %rdx
decl %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4d28
decl %r14d
shlq $0x4, %r14
subq %r14, 0x10(%rbx)
jmp 0xa5f0
testl %r14d, %r14d
jne 0xa5f0
movq 0x10(%rbx), %r14
leaq 0xa325(%rip), %rsi      # 0x148fb
movq %rbx, %rdi
xorl %edx, %edx
callq 0x412b
movq %rax, (%r14)
movl $0x4, 0x8(%r14)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_pushfstring
static const char*lua_pushfstring(lua_State*L,const char*fmt,...){
const char*ret;
va_list argp;
luaC_checkGC(L);
va_start(argp,fmt);
ret=luaO_pushvfstring(L,fmt,argp);
va_end(argp);
return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xa657
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xa66d
movq %r14, %rdi
callq 0x68ed
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47c2
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_checkinteger
static lua_Integer luaL_checkinteger(lua_State*L,int narg){
lua_Integer d=lua_tointeger(L,narg);
if(d==0&&!lua_isnumber(L,narg))
tag_error(L,narg,3);
return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0xa7af
movq %rax, %r15
testq %rax, %rax
jne 0xa795
movq %r14, %rdi
movl %ebx, %esi
callq 0xa7de
testl %eax, %eax
je 0xa79e
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9f5c(%rip), %rdx      # 0x14701
movq %r14, %rdi
movl %ebx, %esi
callq 0xa6d4
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_tointeger
static lua_Integer lua_tointeger(lua_State*L,int idx){
TValue n;
const TValue*o=index2adr(L,idx);
if(tonumber(o,&n)){
lua_Integer res;
lua_Number num=nvalue(o);
lua_number2integer(res,num);
return res;
}
else
return 0;
}

// Assembly:
subq $0x18, %rsp
callq 0x975f
cmpl $0x3, 0x8(%rax)
je 0xa7d0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x747e
testq %rax, %rax
je 0xa7da
cvttsd2si (%rax), %rax
addq $0x18, %rsp
retq
xorl %eax, %eax
jmp 0xa7d5
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_insert
static void lua_insert(lua_State*L,int idx){
StkId p;
StkId q;
p=index2adr(L,idx);
api_checkvalidindex(L,p);
for(q=L->top;q>p;q--)setobj(L,q,q-1);
setobj(L,p,L->top);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x975f
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
jbe 0xa83a
movq -0x10(%rcx), %rdx
movq %rdx, (%rcx)
movl -0x8(%rcx), %edx
movl %edx, 0x8(%rcx)
leaq -0x10(%rcx), %rdx
movq %rdx, %rcx
cmpq %rax, %rdx
ja 0xa821
movq 0x10(%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_load
static int lua_load(lua_State*L,lua_Reader reader,void*data,
const char*chunkname){
ZIO z;
int status;
if(!chunkname)chunkname="?";
luaZ_init(L,&z,reader,data);
status=luaD_protectedparser(L,&z,chunkname);
return status;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
testq %rcx, %rcx
leaq 0xa174(%rip), %rax      # 0x149d5
cmovneq %rcx, %rax
movq %rsp, %rcx
movq %rdi, 0x20(%rcx)
movq %rsi, 0x10(%rcx)
movq %rdx, 0x18(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
leaq 0x28(%rsp), %r14
movq %rcx, (%r14)
movq %rax, 0x20(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x18(%r14)
movq 0x10(%rdi), %rcx
movq 0xb0(%rdi), %r8
subq 0x40(%rdi), %rcx
leaq 0xfa(%rip), %rsi        # 0xa9a0
movq %r14, %rdx
callq 0xa8f2
movl %eax, %ebp
movq 0x8(%r14), %rsi
movq 0x18(%r14), %r14
movq 0x20(%rbx), %rbx
movq 0x18(%rbx), %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0x10(%rbx)
subq %r14, 0x78(%rbx)
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getS
static const char*getS(lua_State*L,void*ud,size_t*size){
LoadS*ls=(LoadS*)ud;
(void)L;
if(ls->size==0)return NULL;
*size=ls->size;
ls->size=0;
return ls->s;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xa8ef
movq %rax, (%rdx)
movq $0x0, 0x8(%rsi)
movq (%rsi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaD_pcall
static int luaD_pcall(lua_State*L,Pfunc func,void*u,
ptrdiff_t old_top,ptrdiff_t ef){
int status;
unsigned short oldnCcalls=L->nCcalls;
ptrdiff_t old_ci=saveci(L,L->ci);
lu_byte old_allowhooks=L->allowhook;
ptrdiff_t old_errfunc=L->errfunc;
L->errfunc=ef;
status=luaD_rawrunprotected(L,func,u);
if(status!=0){
StkId oldtop=restorestack(L,old_top);
luaF_close(L,oldtop);
luaD_seterrorobj(L,status,oldtop);
L->nCcalls=oldnCcalls;
L->ci=restoreci(L,old_ci);
L->base=L->ci->base;
L->savedpc=L->ci->savedpc;
L->allowhook=old_allowhooks;
restore_stack_limit(L);
}
L->errfunc=old_errfunc;
return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movzwl 0x60(%rdi), %eax
movw %ax, 0x6(%rsp)
movq 0x28(%rdi), %r13
movq 0x50(%rdi), %r12
movb 0x65(%rdi), %al
movb %al, 0x5(%rsp)
movq 0xb0(%rdi), %r15
movq %r8, 0xb0(%rdi)
callq 0x3ce5
movl %eax, %ebp
testl %eax, %eax
je 0xa988
subq %r12, %r13
addq 0x40(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x438e
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x447b
movzwl 0x6(%rsp), %eax
movw %ax, 0x60(%rbx)
movq 0x50(%rbx), %rax
leaq (%rax,%r13), %rcx
movq %rcx, 0x28(%rbx)
movq (%rax,%r13), %rcx
movq %rcx, 0x18(%rbx)
movq 0x18(%rax,%r13), %rax
movq %rax, 0x30(%rbx)
movb 0x5(%rsp), %al
movb %al, 0x65(%rbx)
movq %rbx, %rdi
callq 0x44e4
movq %r15, 0xb0(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: f_parser
static void f_parser(lua_State*L,void*ud){
int i;
Proto*tf;
Closure*cl;
struct SParser*p=cast(struct SParser*,ud);
luaC_checkGC(L);
tf=luaY_parser(L,p->z,
&p->buff,p->name);
cl=luaF_newLclosure(L,tf->nups,hvalue(gt(L)));
cl->l.p=tf;
for(i=0;i<tf->nups;i++)
cl->l.upvals[i]=luaF_newupval(L);
setclvalue(L,L->top,cl);
incr_top(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xa9ca
movq %rbx, %rdi
callq 0x68ed
leaq 0x8(%r14), %rax
movq (%r14), %r15
movq 0x20(%r14), %r14
movq %rax, 0x48(%rsp)
movq %r14, %rdi
callq 0x30e0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x412b
movb $0x2e, 0x58(%rsp)
movq %rbx, 0x38(%rsp)
movl $0x11f, 0x20(%rsp)      # imm = 0x11F
movq %r15, 0x40(%rsp)
movq $0x0, 0x30(%rsp)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x4(%rsp)
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
movl $0x20, %ecx
movq %rbx, %rdi
callq 0x42ab
movq 0x48(%rsp), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
movq 0x40(%rsp), %rdi
subq $0x1, (%rdi)
jae 0xaa5f
callq 0xba6c
jmp 0xaa6e
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movq %rsp, %r14
movl %eax, (%r14)
leaq 0x60(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xaba7
movq (%r15), %rax
movb $0x2, 0x72(%rax)
movl 0x4(%r14), %eax
movl 0x20(%r14), %ecx
movl %eax, 0x8(%r14)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xaab5
leaq 0x18(%rsp), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xbabb
movl %eax, 0x10(%r14)
jmp 0xaac7
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, -0x10(%rax)
movl $0x11f, (%rax)          # imm = 0x11F
movq %rsp, %r14
movq %r14, %rdi
callq 0xacd9
cmpl $0x11f, 0x10(%r14)      # imm = 0x11F
jne 0xab9a
movq %rsp, %rdi
callq 0xb88a
movq 0x60(%rsp), %r15
movzbl 0x70(%r15), %esi
movq 0x78(%rbx), %rdx
movq %rbx, %rdi
callq 0x7517
movq %rax, %r14
movq %r15, 0x20(%rax)
cmpb $0x0, 0x70(%r15)
je 0xab5d
xorl %r12d, %r12d
movl $0x28, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x42ab
movq 0x20(%rbx), %rcx
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x28(%rcx)
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0xa, 0x8(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x28(%r14,%r12,8)
incq %r12
movzbl 0x70(%r15), %eax
cmpq %rax, %r12
jb 0xab0f
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movl $0x6, 0x8(%rax)
movq 0x38(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x10, %rax
jg 0xab86
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4d13
addq $0x10, 0x10(%rbx)
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdi
movl $0x11f, %esi            # imm = 0x11F
callq 0xf391
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: open_func
static void open_func(LexState*ls,FuncState*fs){
lua_State*L=ls->L;
Proto*f=luaF_newproto(L);
fs->f=f;
fs->prev=ls->fs;
fs->ls=ls;
fs->L=L;
ls->fs=fs;
fs->pc=0;
fs->lasttarget=-1;
fs->jpc=(-1);
fs->freereg=0;
fs->nk=0;
fs->np=0;
fs->nlocvars=0;
fs->nactvar=0;
fs->bl=NULL;
f->source=ls->source;
f->maxstacksize=2;
fs->h=luaH_new(L,0,0);
sethvalue(L,L->top,fs->h);
incr_top(L);
setptvalue(L,L->top,f);
incr_top(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x38(%rdi), %rbx
xorl %r13d, %r13d
movl $0x78, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x42ab
movq %rax, %r14
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rcx
movq %rcx, (%r14)
movq %r14, 0x28(%rax)
movb 0x20(%rax), %al
andb $0x3, %al
movb %al, 0x9(%r14)
movb $0x9, 0x8(%r14)
movq %r13, 0x60(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movl $0x0, 0x70(%r14)
movq %r14, (%r15)
movq 0x30(%r12), %rax
movq %rax, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %rbx, 0x20(%r15)
movq %r15, 0x30(%r12)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x30(%r15)
movl $0xffffffff, 0x38(%r15) # imm = 0xFFFFFFFF
movq %r13, 0x28(%r15)
movq %r13, 0x3c(%r15)
movq %r13, 0x43(%r15)
movq 0x50(%r12), %rax
movq %rax, 0x40(%r14)
movb $0x2, 0x73(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3fc8
movq %rax, 0x8(%r15)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x5, 0x8(%rcx)
movq 0x38(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x10, %rax
jg 0xac98
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4d13
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, 0x10(%rax)
movl $0x9, 0x18(%rax)
movq 0x38(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x10, %rax
jg 0xacca
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4d13
addq $0x10, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: close_func
static void close_func(LexState*ls){
lua_State*L=ls->L;
FuncState*fs=ls->fs;
Proto*f=fs->f;
removevars(ls,0);
luaK_ret(fs,0,0);
luaM_reallocvector(L,f->code,f->sizecode,fs->pc,Instruction);
f->sizecode=fs->pc;
luaM_reallocvector(L,f->lineinfo,f->sizelineinfo,fs->pc,int);
f->sizelineinfo=fs->pc;
luaM_reallocvector(L,f->k,f->sizek,fs->nk,TValue);
f->sizek=fs->nk;
luaM_reallocvector(L,f->p,f->sizep,fs->np,Proto*);
f->sizep=fs->np;
luaM_reallocvector(L,f->locvars,f->sizelocvars,fs->nlocvars,LocVar);
f->sizelocvars=fs->nlocvars;
luaM_reallocvector(L,f->upvalues,f->sizeupvalues,f->nups,TString*);
f->sizeupvalues=f->nups;
ls->fs=fs->prev;
if(fs)anchor_token(ls);
L->top-=2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %rbx
movq (%r15), %r12
movzbl 0x4a(%r15), %eax
testq %rax, %rax
je 0xb8cd
movl 0x30(%r15), %ecx
movq 0x30(%r12), %rdx
movzwl 0xc2(%r15,%rax,2), %esi
shll $0x4, %esi
movl %ecx, 0xc(%rdx,%rsi)
decq %rax
jne 0xb8b3
movb $0x0, 0x4a(%r15)
movq 0x18(%r15), %rax
movl 0x8(%rax), %edx
movq %r15, %rdi
movl $0x80001e, %esi         # imm = 0x80001E
callq 0xd83d
movslq 0x30(%r15), %rcx
cmpq $-0x1, %rcx
jl 0xba5b
movq 0x18(%r12), %rsi
movslq 0x50(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0x42ab
movq %rax, 0x18(%r12)
movslq 0x30(%r15), %rcx
movl %ecx, 0x50(%r12)
cmpq $-0x2, %rcx
jle 0xba5b
movq 0x28(%r12), %rsi
movslq 0x54(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0x42ab
movq %rax, 0x28(%r12)
movl 0x30(%r15), %eax
movl %eax, 0x54(%r12)
movslq 0x40(%r15), %rcx
cmpq $-0x2, %rcx
jle 0xba5b
movq 0x10(%r12), %rsi
movslq 0x4c(%r12), %rdx
shlq $0x4, %rdx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x42ab
movq %rax, 0x10(%r12)
movl 0x40(%r15), %eax
movl %eax, 0x4c(%r12)
movslq 0x44(%r15), %rcx
cmpq $-0x2, %rcx
jle 0xba5b
movq 0x20(%r12), %rsi
movslq 0x58(%r12), %rdx
shlq $0x3, %rdx
shlq $0x3, %rcx
movq %rbx, %rdi
callq 0x42ab
movq %rax, 0x20(%r12)
movl 0x44(%r15), %eax
movl %eax, 0x58(%r12)
movswq 0x48(%r15), %rcx
leaq 0x1(%rcx), %rax
shrq $0x3c, %rax
jne 0xba5b
movq 0x30(%r12), %rsi
movslq 0x5c(%r12), %rdx
shlq $0x4, %rdx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x42ab
movq %rax, 0x30(%r12)
movswl 0x48(%r15), %eax
movl %eax, 0x5c(%r12)
movzbl 0x70(%r12), %ecx
movq 0x38(%r12), %rsi
movslq 0x48(%r12), %rdx
shlq $0x3, %rdx
shll $0x3, %ecx
movq %rbx, %rdi
callq 0x42ab
movq %rax, 0x38(%r12)
movzbl 0x70(%r12), %eax
movl %eax, 0x48(%r12)
movq 0x10(%r15), %rax
movq %rax, 0x30(%r14)
movl $0xfffffee3, %eax       # imm = 0xFFFFFEE3
addl 0x10(%r14), %eax
cmpl $0x2, %eax
jae 0xba4a
movq 0x18(%r14), %rsi
movq 0x10(%rsi), %rdx
addq $0x18, %rsi
movq %r14, %rdi
callq 0xc749
addq $-0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8bb7(%rip), %rsi      # 0x14619
movq %rbx, %rdi
xorl %eax, %eax
callq 0x46c4
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdi
movq %rsp, %r14
movq %r14, %rdx
callq *0x10(%rbx)
testq %rax, %rax
sete %cl
movq (%r14), %rdx
testq %rdx, %rdx
sete %sil
orb %cl, %sil
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jne 0xbab1
decq %rdx
movq %rdx, (%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x8(%rbx)
movzbl (%rax), %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq 0x40(%rdi), %rdi
subq $0x1, (%rdi)
jae 0xc263
callq 0xba6c
jmp 0xc272
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0xc27e
cmpl $0xa, %eax
jne 0xc2a4
cmpl %ebp, %eax
je 0xc2a4
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xc293
callq 0xba6c
jmp 0xc2a2
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
cmpl $0x7ffffffc, %eax       # imm = 0x7FFFFFFC
jge 0xc2bb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl 0x10(%rbx), %edx
leaq 0x8798(%rip), %rsi      # 0x14a5d
movq %rbx, %rdi
callq 0xc4a9
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl (%rdi), %ebx
movl %ebx, %esi
callq 0xc548
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xc2ee
callq 0xba6c
jmp 0xc2fd
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
xorl %ebp, %ebp
cmpl $0x3d, %eax
jne 0xc340
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x3d, %esi
callq 0xc548
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xc327
callq 0xba6c
jmp 0xc336
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
incl %ebp
cmpl $0x3d, %eax
je 0xc309
xorl %ecx, %ecx
cmpl %ebx, %eax
setne %cl
negl %ecx
xorl %ebp, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc548
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xc378
callq 0xba6c
jmp 0xc387
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0xd, %eax
je 0xc394
cmpl $0xa, %eax
jne 0xc404
movq %r14, %rdi
callq 0xc24a
jmp 0xc404
cmpl $0xa, %esi
jne 0xc3cb
movq %r14, %rdi
movl $0xa, %esi
callq 0xc548
movq %r14, %rdi
callq 0xc24a
testq %rbx, %rbx
jne 0xc404
movq 0x48(%r14), %rax
movq $0x0, 0x8(%rax)
jmp 0xc404
cmpl $-0x1, %esi
je 0xc487
testq %rbx, %rbx
je 0xc3e1
movq %r14, %rdi
callq 0xc548
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xc3f2
callq 0xba6c
jmp 0xc401
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 0xc39e
cmpl $0xd, %esi
je 0xc3a3
cmpl $0x5d, %esi
jne 0xc3d4
movq %r14, %rdi
callq 0xc2cd
cmpl %r15d, %eax
jne 0xc404
movl (%r14), %esi
movq %r14, %rdi
callq 0xc548
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xc43f
callq 0xba6c
jmp 0xc44e
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0xc481
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 0xc749
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
testq %rbx, %rbx
leaq 0x85fc(%rip), %rax      # 0x14a8d
leaq 0x85de(%rip), %rsi      # 0x14a76
cmoveq %rax, %rsi
movq %r14, %rdi
movl $0x11f, %edx            # imm = 0x11F
callq 0xc4a9
// File: /workspace/github_c_makefile_star2_O1/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 0x4b52
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x815d(%rip), %rsi      # 0x14640
movq %r12, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x4c39
testl %r14d, %r14d
je 0xc53a
movq %rax, %r15
movq 0x38(%rbx), %r12
leal -0x11c(%r14), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0xc51b
xorl %esi, %esi
callq 0xc548
movq 0x48(%rbx), %rax
movq (%rax), %rcx
jmp 0xc526
movl %r14d, %esi
callq 0xc7f9
movq %rax, %rcx
leaq 0x8578(%rip), %rsi      # 0x14aa5
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4c39
movq 0x38(%rbx), %rdi
movl $0x3, %esi
callq 0x42f5
// File: /workspace/github_c_makefile_star2_O1/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), %rax
incq %rcx
cmpq %rax, %rcx
jbe 0xc596
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, %rax
jae 0xc5ae
movq 0x10(%r15), %rdx
leaq (%rdx,%rdx), %r14
movq 0x38(%rdi), %rdi
cmpq $-0x2, %r14
je 0xc5bc
movq (%r15), %rsi
movq %r14, %rcx
callq 0x42ab
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq (%r15), %rax
movq 0x8(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r15)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8535(%rip), %rsi      # 0x14aea
xorl %edx, %edx
callq 0xc4a9
leaq 0x8056(%rip), %rsi      # 0x14619
xorl %eax, %eax
callq 0x46c4
// File: /workspace/github_c_makefile_star2_O1/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 0xc5fc
movq %rbx, %rdi
movl %ebp, %esi
callq 0xc548
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xc600
callq 0xba6c
jmp 0xc60f
xorl %eax, %eax
jmp 0xc616
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_O1/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 (%rbx), %esi
movq %rbx, %rdi
callq 0xc548
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xc647
callq 0xba6c
movl %eax, %ebp
jmp 0xc656
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movl %ebp, (%rbx)
callq 0x32f0
cmpl $0x2e, %ebp
je 0xc62a
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0xc62a
leaq 0x8486(%rip), %rsi      # 0x14b03
movq %rbx, %rdi
callq 0xc5ca
testl %eax, %eax
je 0xc698
leaq 0x8476(%rip), %rsi      # 0x14b06
movq %rbx, %rdi
callq 0xc5ca
movslq (%rbx), %rsi
cmpq $0x5f, %rsi
je 0xc6ad
movq (%r15), %rax
movzwl (%rax,%rsi,2), %eax
andl $0x8, %eax
je 0xc6ea
movq %rbx, %rdi
callq 0xc548
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xc6c8
callq 0xba6c
movl %eax, %esi
jmp 0xc6d7
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %esi
movl %esi, (%rbx)
cmpl $0x5f, %esi
je 0xc6ad
movq (%r15), %rax
movslq %esi, %rcx
movzwl (%rax,%rcx,2), %eax
jmp 0xc6a8
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc548
movq 0x48(%rbx), %rdx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0xc717
movb 0x58(%rbx), %cl
movq (%rdx), %rdx
cmpb $0x2e, -0x1(%rdx,%rax)
jne 0xc712
movb %cl, -0x1(%rdx,%rax)
decq %rax
jne 0xc707
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x8139
testl %eax, %eax
je 0xc735
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x83cd(%rip), %rsi      # 0x14b09
movq %rbx, %rdi
movl $0x11c, %edx            # imm = 0x11C
callq 0xc4a9
// File: /workspace/github_c_makefile_star2_O1/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 0x412b
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
leaq 0x7c8c(%rip), %rcx      # 0x14420
cmpl $0x4, 0x18(%rax)
jne 0xc7a0
cmpq %r14, 0x10(%rax)
je 0xc7ac
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xc794
movq %rcx, %rax
cmpq %rcx, %rax
jne 0xc7c6
movq %rsp, %rdx
movq %r14, (%rdx)
movl $0x4, 0x8(%rdx)
movq %rbx, %rdi
callq 0x78c4
cmpl $0x0, 0x8(%rax)
jne 0xc7ec
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xc7ec
movq %rbx, %rdi
callq 0x68ed
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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 0xc828
movq %rdi, %r14
callq 0x32f0
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x2, (%rax,%rcx,2)
movq 0x38(%r14), %rdi
jne 0xc841
leaq 0x8295(%rip), %rsi      # 0x14abb
jmp 0xc848
addl $0xfffffeff, %ebx       # imm = 0xFFFFFEFF
leaq 0xe11b(%rip), %rax      # 0x1a950
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x826a(%rip), %rsi      # 0x14ab2
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4c39
// File: /workspace/github_c_makefile_star2_O1/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 0xc89f
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xc885
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xbabb
movl %eax, 0x10(%rbx)
jmp 0xc899
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_O1/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 0xacd9
movq %rbx, %rdi
callq 0xf303
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc858
testl %eax, %eax
je 0xc904
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl %ebp, 0x4(%rbx)
jne 0xc914
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf391
movq 0x38(%rbx), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0xc7f9
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc7f9
leaq 0x8397(%rip), %rsi      # 0x14ccf
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x4c39
movl 0x10(%rbx), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc4a9
// File: /workspace/github_c_makefile_star2_O1/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 0xc982
xorl %eax, %eax
cmpb $0x0, 0xe(%r14)
jne 0xc991
movzbl 0xd(%r14), %ecx
orl %ecx, %eax
movq (%r14), %r14
testq %r14, %r14
jne 0xc96c
movl 0x10(%rdi), %edx
leaq 0x83dc(%rip), %rsi      # 0x14d68
callq 0xc4a9
testl %eax, %eax
je 0xc9af
movzbl 0xc(%r14), %esi
shll $0x6, %esi
orl $0x23, %esi
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0xd83d
addq $0x8, %r14
movq %rbx, %rdi
callq 0xca74
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xca30
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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 0xc9f4
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xbabb
movl %eax, 0x10(%rbx)
jmp 0xca08
leaq 0x20(%rbx), %rax
leaq 0x10(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %rbx, %rdi
callq 0xcabb
movl %eax, %ebp
movq %rbx, %rdi
movl $0x112, %esi            # imm = 0x112
callq 0xcaf9
movq %rbx, %rdi
callq 0xc8a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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 0xca73
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0xca71
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl %ecx, %esi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %r8d
shrl $0xe, %r8d
leal -0x1ffff(%r8), %r9d
cmpl $-0x1, %r9d
leal -0x1fffe(%rcx,%r8), %ecx
cmovel %r9d, %ecx
cmpl $-0x1, %ecx
jne 0xca43
jmp 0xda56
movl %edx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd83d
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xca30
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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 0xcbb5
cmpl $0x1, (%r14)
jne 0xcadf
movl $0x3, (%rsp)
movq 0x30(%rbx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0xcb42
movl 0x14(%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd5d1
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0xcb83
cmpl $0x2, %eax
je 0xcb83
movq %r14, %rdi
movq %rbx, %rsi
cmpl $0xa, %eax
jne 0xcb7a
callq 0xdea4
movl 0x8(%rbx), %edx
jmp 0xcb83
xorl %edx, %edx
callq 0xf146
movl %eax, %edx
leaq 0x14(%rbx), %rsi
movq %r14, %rdi
callq 0xca30
movl 0x10(%rbx), %edx
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
leaq 0x38(%r14), %rsi
movq %r14, %rdi
callq 0xca30
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd5d1
cmpl $0xc, (%rbx)
jne 0xd3ec
movl 0x10(%rbx), %eax
leaq 0x8(%rbx), %r15
cmpl 0x14(%rbx), %eax
je 0xd3fe
movl (%r15), %edx
movzbl 0x4a(%r14), %eax
cmpl %eax, %edx
jge 0xd407
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd79c
addq $0x8, %rbx
movq %rbx, %r15
movl (%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd66a
jmp 0xd3fe