LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
pushq $0x5
popq %rdx
callq 0xe177
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x965e
pushq $0x1
popq %rsi
movq %rbx, %rdi
cmpl $0x6, %eax
jne 0x9128
callq 0x8917
jmp 0x9178
callq 0x9cae
movq %rax, %r14
testl %r14d, %r14d
js 0x9214
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x9722
testl %eax, %eax
je 0x921d
leaq 0xa18b(%rip), %rsi      # 0x132e3
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x977a
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x965e
testl %eax, %eax
je 0x922f
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8917
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9d18
testl %eax, %eax
je 0x91d5
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xe1c4
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x91d5
jp 0x91d5
movq 0x10(%rbx), %rax
movq %rbx, (%rax)
movl $0x8, 0x8(%rax)
addq $0x10, 0x10(%rbx)
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x9d72
movq %rbx, %rdi
callq 0xe1f3
xorl %ebp, %ebp
jmp 0x91f5
movq 0x10(%rbx), %rax
cmpl $0x6, -0x18(%rax)
jne 0x91e9
movq -0x20(%rax), %rax
cmpb $0x0, 0xa(%rax)
jne 0x9203
movq %rbx, %rdi
callq 0xe1f3
testl %eax, %eax
je 0x9203
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9bbc(%rip), %rsi      # 0x12dc6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9546
leaq 0x9bdf(%rip), %rdx      # 0x12dfa
jmp 0x9224
leaq 0x9bf1(%rip), %rdx      # 0x12e15
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x967a
leaq 0x9bed(%rip), %rsi      # 0x12e23
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x965e
movl %eax, %ebp
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0xe177
testl %ebp, %ebp
je 0x926a
cmpl $0x5, %ebp
jne 0x92e1
movq %rbx, %rdi
callq 0xe272
testl %eax, %eax
je 0x92a4
leaq 0x9bee(%rip), %rsi      # 0x12e6b
movq %rbx, %rdi
callq 0x3820
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0xe19c
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x965e
testl %eax, %eax
jne 0x92c5
addq $-0x20, 0x10(%rbx)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x9c5a
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8c6a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0xe2cd
leaq 0x9ba0(%rip), %rsi      # 0x12e77
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9546
leaq 0x9b6d(%rip), %rdx      # 0x12e55
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x967a
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
pushq $0xa
popq %rdx
callq 0x9c2f
movq %rax, %r14
cmpl $0xa, %r14d
jne 0x9349
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x94f6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9d18
testl %eax, %eax
je 0x93a0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xe1c4
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0x93db
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9b97
movq %rax, %r15
leal -0x2(%r14), %eax
cmpl $0x23, %eax
jae 0x93f7
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x3250
movq (%r12), %r12
cmpq %r12, %r15
je 0x93a0
movq %rax, %r14
callq 0x32e0
movq (%rax), %rax
movzbl (%r12), %ecx
incq %r12
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x938d
testb %cl, %cl
je 0x93b2
movq 0x10(%rbx), %rax
andl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
jmp 0x93e7
movq %r14, %xmm0
punpckldq 0x91f1(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x91f9(%rip), %xmm0     # 0x125c0
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)
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9a9d(%rip), %rdx      # 0x12e9b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x967a
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
callq 0xe177
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x9c2f
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x965e
testl %eax, %eax
jle 0x9493
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x9cae
jmp 0x949e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xe2fc
movq %rax, %r15
xorl %eax, %eax
movl %r15d, %ebp
subl %r14d, %ebp
jl 0x94dc
js 0x94e5
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe35f
testl %eax, %eax
je 0x94e5
incl %r15d
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0xe3d0
incl %r14d
cmpl %r14d, %r15d
jne 0x94c4
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x99c1(%rip), %rsi      # 0x12ead
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/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 0x95a6
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)
pushq $0x1
popq %rsi
callq 0x9a06
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x95e4
movq %rbx, %rdi
callq 0x662b
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4609
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x9a6a
movq %rbx, %rdi
callq 0x48c4
// File: /workspace/github_c_makefile_star2_O2/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 0x965e
testl %eax, %eax
jle 0x9637
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9b97
testq %rbx, %rbx
je 0x9650
testq %r14, %r14
je 0x964b
movq %r14, %rdi
callq 0x30e0
jmp 0x964d
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_O2/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 %rsp, %rdx
xorl %esi, %esi
callq 0x9722
testl %eax, %eax
jne 0x96b0
leaq 0x9321(%rip), %rsi      # 0x129c2
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x9546
leaq 0x9028(%rip), %rsi      # 0x126df
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x977a
movq 0x10(%r15), %rdi
leaq 0x9308(%rip), %rsi      # 0x129d8
callq 0x3160
testl %eax, %eax
jne 0x96f6
decl %ebp
jne 0x96f6
movq 0x8(%rsp), %rdx
leaq 0x92f6(%rip), %rsi      # 0x129df
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x9546
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
jne 0x970c
leaq 0x92f6(%rip), %rcx      # 0x129fd
movq %rcx, 0x8(%rsp)
leaq 0x92ec(%rip), %rsi      # 0x129ff
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0x9546
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rcx
movq 0x28(%rdi), %rax
movq %rax, %r8
testl %esi, %esi
jle 0x9753
cmpq 0x50(%rdi), %r8
jbe 0x9777
decl %esi
movq 0x8(%r8), %rdx
movq (%rdx), %rdx
cmpb $0x0, 0xa(%rdx)
jne 0x9749
subl 0x24(%r8), %esi
addq $-0x28, %r8
addq $-0x28, %rax
jmp 0x972c
xorl %edx, %edx
testl %esi, %esi
jne 0x9770
movq 0x50(%rdi), %rdx
cmpq %rdx, %r8
jbe 0x9777
subq %rdx, %rax
pushq $0x28
popq %rsi
cqto
idivq %rsi
movq %rax, %rdx
movl %edx, 0x74(%rcx)
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9722
testl %eax, %eax
je 0x9a51
leaq 0x901c(%rip), %rsi      # 0x12a3f
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x977a
movl 0x28(%r14), %ecx
testl %ecx, %ecx
jle 0x9a51
leaq 0x38(%rsp), %rdx
leaq 0x8ffd(%rip), %rsi      # 0x12a42
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9ae7
jmp 0x9a62
leaq 0x8ecb(%rip), %rsi      # 0x12923
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8937
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9ab5
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x9a8f
movq %rbx, %rdi
callq 0x662b
movq 0x10(%rbx), %rdx
subq 0x18(%rbx), %rdx
shrq $0x4, %rdx
decl %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4b80
decl %r14d
shlq $0x4, %r14
subq %r14, 0x10(%rbx)
jmp 0x9adf
testl %r14d, %r14d
jne 0x9adf
movq 0x10(%rbx), %r14
leaq 0x8e5e(%rip), %rsi      # 0x12923
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4008
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_O2/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 0x9b46
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 0x9b5c
movq %r14, %rdi
callq 0x662b
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 0x4609
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_settop
static void lua_settop(lua_State*L,int idx){
if(idx>=0){
luai_apicheck(L,idx<=L->stack_last-L->base);
while(L->top<L->base+idx)
setnilvalue(L->top++);
L->top=L->base+idx;
}
else{
luai_apicheck(L,-(idx+1)<=(L->top-L->base));
L->top+=idx+1;
}
}

// Assembly:
testl %esi, %esi
js 0x9c82
movl %esi, %eax
shlq $0x4, %rax
addq 0x18(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
jae 0x9c94
leaq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rdi)
andl $0x0, 0x8(%rcx)
movq %rdx, %rcx
jmp 0x9c6c
movq 0x10(%rdi), %rax
movslq %esi, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9ce9
movq %rax, %r15
testq %rax, %rax
jne 0x9cd3
movq %r14, %rdi
movl %ebx, %esi
callq 0x9d18
testl %eax, %eax
je 0x9cdc
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x3
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9bbf
// File: /workspace/github_c_makefile_star2_O2/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 0x8e4b
cmpl $0x3, 0x8(%rax)
je 0x9d0a
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x70bd
testq %rax, %rax
je 0x9d14
cvttsd2si (%rax), %rax
addq $0x18, %rsp
retq
xorl %eax, %eax
jmp 0x9d0f
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: load_aux
static int load_aux(lua_State*L,int status){
if(status==0)
return 1;
else{
lua_pushnil(L);
lua_insert(L,-2);
return 2;
}
}

// Assembly:
testl %esi, %esi
je 0x9d6e
pushq %rax
movq 0x10(%rdi), %rax
andl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rdi)
pushq $-0x2
popq %rsi
callq 0x9d72
pushq $0x2
popq %rax
addq $0x8, %rsp
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8e4b
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
jbe 0x9d97
movq -0x10(%rcx), %rdx
movq %rdx, (%rcx)
movl -0x8(%rcx), %edx
movl %edx, 0x8(%rcx)
addq $-0x10, %rcx
jmp 0x9d7f
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_O2/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
testq %rcx, %rcx
leaq 0x8c42(%rip), %rax      # 0x129fd
cmovneq %rcx, %rax
movq %rdi, %rbx
movq %rsp, %rcx
movq %rdi, 0x20(%rcx)
movq %rsi, 0x10(%rcx)
movq %rdx, 0x18(%rcx)
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %r14
movq %rcx, (%r14)
movq %rax, 0x20(%r14)
andq $0x0, 0x8(%r14)
movaps %xmm0, (%rcx)
andq $0x0, 0x18(%r14)
movq 0x10(%rdi), %rcx
movq 0xb0(%rdi), %r8
subq 0x40(%rdi), %rcx
leaq 0xed(%rip), %rsi        # 0x9ef0
movq %r14, %rdx
callq 0x9e42
movl %eax, %ebp
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4158
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9e3f
movq %rax, (%rdx)
andq $0x0, 0x8(%rsi)
movq (%rsi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c01
movl %eax, %ebp
testl %eax, %eax
je 0x9ed8
subq %r12, %r13
addq 0x40(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4235
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4307
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 0x4369
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_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x9f1c
movq %rbx, %rdi
callq 0x662b
movq (%r14), %r15
movq 0x20(%r14), %r12
leaq 0x8(%r14), %rax
movq %rax, 0x50(%rsp)
movq %r12, %rdi
callq 0x30e0
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4008
movb $0x2e, 0x60(%rsp)
movq %rbx, 0x40(%rsp)
movl $0x11f, 0x28(%rsp)      # imm = 0x11F
movq %r15, 0x48(%rsp)
andq $0x0, 0x38(%rsp)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0xc(%rsp)
movq %rax, 0x58(%rsp)
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rdx
pushq $0x20
popq %rcx
movq %rbx, %rdi
callq 0x4158
movq %rax, 0x8(%r14)
movq $0x20, 0x18(%r14)
subq $0x1, (%r15)
jae 0x9fa2
movq %r15, %rdi
callq 0xacb0
jmp 0x9fb1
movq 0x8(%r15), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%r15)
movzbl (%rax), %eax
leaq 0x8(%rsp), %r14
movl %eax, (%r14)
leaq 0x68(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa0ab
movq (%r15), %rax
movb $0x2, 0x72(%rax)
movq %r14, %rdi
callq 0xa1e0
movq %r14, %rdi
callq 0xa21c
movq %r14, %rdi
movl $0x11f, %esi            # imm = 0x11F
callq 0xaaf9
movq %r14, %rdi
callq 0xab05
movq (%r15), %r12
movzbl 0x70(%r12), %esi
movq 0x78(%rbx), %rdx
movq %rbx, %rdi
callq 0x7156
movq %rax, %r14
movq %r12, 0x20(%rax)
xorl %r13d, %r13d
pushq $0x28
popq %r15
movzbl 0x70(%r12), %eax
cmpq %rax, %r13
jae 0xa064
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x4158
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)
andl $0x0, 0x20(%rax)
movq %rax, 0x28(%r14,%r13,8)
incq %r13
jmp 0xa018
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movl $0x6, 0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0xa092
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x4b6b
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movq 0x38(%rdi), %rbx
pushq $0x78
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4158
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)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
andq $0x0, 0x60(%r14)
movups %xmm0, 0x10(%r14)
andl $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)
orl $-0x1, 0x38(%r15)
andq $0x0, 0x28(%r15)
andq $0x0, 0x3c(%r15)
andq $0x0, 0x43(%r15)
movq 0x50(%r12), %rax
movq %rax, 0x40(%r14)
movb $0x2, 0x73(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3ebe
movq %rax, 0x8(%r15)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x5, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0xa199
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x4b6b
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, 0x10(%rax)
movl $0x9, 0x18(%rax)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0xa1cc
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x4b6b
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaX_next
static void luaX_next(LexState*ls){
ls->lastline=ls->linenumber;
if(ls->lookahead.token!=TK_EOS){
ls->t=ls->lookahead;
ls->lookahead.token=TK_EOS;
}
else
ls->t.token=llex(ls,&ls->t.seminfo);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xa206
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0xacfd
movl %eax, 0x10(%rbx)
jmp 0xa21a
leaq 0x20(%rbx), %rax
addq $0x10, %rbx
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movl $0x11f, (%rax)          # imm = 0x11F
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %esi, %esi
callq 0xdd12
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xdfe7
movslq 0x30(%r15), %rcx
cmpq $-0x1, %rcx
jl 0xaca8
movq 0x18(%r12), %rsi
movslq 0x50(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0x4158
movq %rax, 0x18(%r12)
movslq 0x30(%r15), %rcx
movl %ecx, 0x50(%r12)
cmpq $-0x2, %rcx
jle 0xaca8
movq 0x28(%r12), %rsi
movslq 0x54(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0x4158
movq %rax, 0x28(%r12)
movl 0x30(%r15), %eax
movl %eax, 0x54(%r12)
movslq 0x40(%r15), %rcx
cmpq $-0x2, %rcx
jle 0xaca8
movq 0x10(%r12), %rsi
movslq 0x4c(%r12), %rdx
shlq $0x4, %rdx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x4158
movq %rax, 0x10(%r12)
movl 0x40(%r15), %eax
movl %eax, 0x4c(%r12)
movslq 0x44(%r15), %rcx
cmpq $-0x2, %rcx
jle 0xaca8
movq 0x20(%r12), %rsi
movslq 0x58(%r12), %rdx
shlq $0x3, %rdx
shlq $0x3, %rcx
movq %rbx, %rdi
callq 0x4158
movq %rax, 0x20(%r12)
movl 0x44(%r15), %eax
movl %eax, 0x58(%r12)
movswq 0x48(%r15), %rcx
leaq 0x1(%rcx), %rax
shrq $0x3c, %rax
jne 0xaca8
movq 0x30(%r12), %rsi
movslq 0x5c(%r12), %rdx
shlq $0x4, %rdx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x4158
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 0x4158
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 0xac97
movq 0x18(%r14), %rsi
movq 0x10(%rsi), %rdx
addq $0x18, %rsi
movq %r14, %rdi
callq 0xb935
addq $-0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x44fe
// File: /workspace/github_c_makefile_star2_O2/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 %dl
movq (%r14), %rcx
testq %rcx, %rcx
sete %sil
orb %dl, %sil
je 0xace2
pushq $-0x1
popq %rax
jmp 0xacf5
decq %rcx
movq %rcx, (%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x8(%rbx)
movzbl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb471
callq 0xacb0
jmp 0xb480
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0xb48c
cmpl $0xa, %eax
jne 0xb4b2
cmpl %ebp, %eax
je 0xb4b2
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xb4a1
callq 0xacb0
jmp 0xb4b0
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 0xb4c9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x75b5(%rip), %rsi      # 0x12a85
movq %rbx, %rdi
callq 0xb9b8
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %ebx
movl %ebx, %esi
callq 0xb756
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xb4fc
callq 0xacb0
jmp 0xb50b
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
xorl %ebp, %ebp
pushq $0x3d
popq %r15
cmpl $0x3d, %eax
jne 0xb54b
movq %r14, %rdi
movl %r15d, %esi
callq 0xb756
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xb535
callq 0xacb0
jmp 0xb544
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
incl %ebp
jmp 0xb514
xorl %ecx, %ecx
cmpl %ebx, %eax
setne %cl
negl %ecx
xorl %ecx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
callq 0xb756
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xb58b
callq 0xacb0
jmp 0xb59a
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0xd, %eax
je 0xb5a7
cmpl $0xa, %eax
jne 0xb5af
movq %r14, %rdi
callq 0xb458
pushq $0xa
popq %rbp
movl (%r14), %esi
cmpl $0xa, %esi
je 0xb5eb
cmpl $0xd, %esi
je 0xb5eb
cmpl $0x5d, %esi
je 0xb60d
cmpl $-0x1, %esi
je 0xb699
testq %rbx, %rbx
je 0xb5da
movq %r14, %rdi
callq 0xb756
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xb61c
callq 0xacb0
jmp 0xb62b
movq %r14, %rdi
movl %ebp, %esi
callq 0xb756
movq %r14, %rdi
callq 0xb458
testq %rbx, %rbx
jne 0xb5b2
movq 0x48(%r14), %rax
andq $0x0, 0x8(%rax)
jmp 0xb5b2
movq %r14, %rdi
callq 0xb4d8
cmpl %r15d, %eax
jne 0xb5b2
jmp 0xb630
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
jmp 0xb5b2
movl (%r14), %esi
movq %r14, %rdi
callq 0xb756
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xb64c
callq 0xacb0
jmp 0xb65b
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0xb68e
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 0xb935
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rbx, %rbx
leaq 0x7412(%rip), %rax      # 0x12ab5
leaq 0x73f4(%rip), %rsi      # 0x12a9e
cmoveq %rax, %rsi
movq %r14, %rdi
movl $0x11f, %edx            # imm = 0x11F
callq 0xb6bb
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x50
popq %rdx
movq %r12, %rdi
callq 0x49a2
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x6f75(%rip), %rsi      # 0x12668
movq %r12, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x4a89
testl %r14d, %r14d
je 0xb74a
movq %rax, %r15
movq 0x38(%rbx), %r12
leal -0x11c(%r14), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0xb72b
xorl %esi, %esi
callq 0xb756
movq 0x48(%rbx), %rax
movq (%rax), %rcx
jmp 0xb736
movl %r14d, %esi
callq 0xb9c1
movq %rax, %rcx
leaq 0x7390(%rip), %rsi      # 0x12acd
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4a89
movq 0x38(%rbx), %rdi
pushq $0x3
popq %rsi
callq 0x41a0
// File: /workspace/github_c_makefile_star2_O2/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 0xb7a5
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rax, %rdx
jae 0xb7b5
leaq (%rdx,%rdx), %r14
movq 0x38(%rdi), %rdi
movq (%r15), %rsi
movq %r14, %rcx
callq 0x4158
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq 0x8(%r15), %rcx
leaq 0x1(%rcx), %rsi
jmp 0xb7a8
movq (%r15), %rax
movq %rsi, 0x8(%r15)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7356(%rip), %rsi      # 0x12b12
xorl %edx, %edx
callq 0xb6bb
// File: /workspace/github_c_makefile_star2_O2/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 0xb7f5
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb756
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xb7f9
callq 0xacb0
jmp 0xb808
xorl %eax, %eax
jmp 0xb80d
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb756
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xb840
callq 0xacb0
movl %eax, %ebp
jmp 0xb84f
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movl %ebp, (%rbx)
callq 0x32e0
cmpl $0x2e, %ebp
je 0xb823
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0xb823
leaq 0x72b5(%rip), %rsi      # 0x12b2b
movq %rbx, %rdi
callq 0xb7c3
testl %eax, %eax
je 0xb891
leaq 0x72a5(%rip), %rsi      # 0x12b2e
movq %rbx, %rdi
callq 0xb7c3
movl (%rbx), %esi
cmpl $0x5f, %esi
je 0xb8a7
movq (%r15), %rax
movslq %esi, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
je 0xb8d5
movq %rbx, %rdi
callq 0xb756
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xb8c2
callq 0xacb0
movl %eax, %esi
jmp 0xb8d1
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %esi
movl %esi, (%rbx)
jmp 0xb893
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb756
movb 0x58(%rbx), %al
movq 0x48(%rbx), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq %rdx, %rsi
subq $0x1, %rdx
jb 0xb903
cmpb $0x2e, -0x1(%rcx,%rsi)
jne 0xb8ed
movb %al, -0x1(%rcx,%rsi)
jmp 0xb8ed
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x7b11
testl %eax, %eax
je 0xb921
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7209(%rip), %rsi      # 0x12b31
movq %rbx, %rdi
movl $0x11c, %edx            # imm = 0x11C
callq 0xb6bb
// File: /workspace/github_c_makefile_star2_O2/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 0x4008
movq %rax, %r14
movq 0x30(%r15), %rax
movq 0x8(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5042
leaq 0x6ad6(%rip), %rcx      # 0x12440
cmpq %rcx, %rax
jne 0xb987
movq %rsp, %rdx
movq %r14, (%rdx)
movl $0x4, 0x8(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7414
cmpl $0x0, 0x8(%rax)
jne 0xb9ab
pushq $0x1
popq %rcx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xb9ab
movq %rbx, %rdi
callq 0x662b
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb9f0
movq %rdi, %r14
callq 0x32e0
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x2, (%rax,%rcx,2)
movq 0x38(%r14), %rdi
jne 0xba09
leaq 0x70f5(%rip), %rsi      # 0x12ae3
jmp 0xba10
addl $0xfffffeff, %ebx       # imm = 0xFFFFFEFF
leaq 0xef53(%rip), %rax      # 0x1a950
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x70ca(%rip), %rsi      # 0x12ada
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4a89
// File: /workspace/github_c_makefile_star2_O2/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
orl $-0x1, 0x8(%rax)
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 0xa21c
movq %rbx, %rdi
callq 0xdcbc
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xba44
testl %eax, %eax
je 0xbaba
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl %ebp, 0x4(%rbx)
jne 0xbaca
movq %rbx, %rdi
movl %r15d, %esi
callq 0xdd48
movq 0x38(%rbx), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0xb9c1
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0xb9c1
leaq 0x7209(%rip), %rsi      # 0x12cf7
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x4a89
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb9b8
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x28(%rbx), %r14
xorl %eax, %eax
movq (%r14), %r14
testq %r14, %r14
je 0xbb68
cmpb $0x0, 0xe(%r14)
jne 0xbb32
movzbl 0xd(%r14), %ecx
orl %ecx, %eax
jmp 0xbb1a
testl %eax, %eax
je 0xbb4b
movzbl 0xc(%r14), %edx
pushq $0x23
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc633
addq $0x8, %r14
movq %rbx, %rdi
callq 0xbbb1
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbb74
leaq 0x7221(%rip), %rsi      # 0x12d90
callq 0xb9b8
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edx
je 0xbbac
movl %edx, %ebx
movl (%rsi), %eax
cmpl $-0x1, %eax
je 0xbbaa
movq %rdi, %r14
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0xc847
cmpl $-0x1, %eax
jne 0xbb89
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xc8c5
movl %ebx, (%rsi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
orl $-0x1, 0x38(%rdi)
pushq $0x16
popq %rsi
xorl %edx, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0xc64e
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xbb74
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xbc52
cmpl $0x1, (%r14)
jne 0xbc26
movl $0x3, (%rsp)
movq 0x30(%rbx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0xbc56
movl 0x14(%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc45b
movl (%rbx), %eax
pushq $-0x1
popq %rdx
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0xbc95
cmpl $0x2, %eax
je 0xbc95
movq %r14, %rdi
movq %rbx, %rsi
cmpl $0xa, %eax
jne 0xbc8c
callq 0xcd01
movl 0x8(%rbx), %edx
jmp 0xbc95
xorl %edx, %edx
callq 0xdb91
movl %eax, %edx
leaq 0x14(%rbx), %rsi
movq %r14, %rdi
callq 0xbb74
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0xbbf3
orl $-0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc45b
cmpl $0xc, (%rbx)
jne 0xc2e2
movl 0x10(%rbx), %eax
leaq 0x8(%rbx), %r15
cmpl 0x14(%rbx), %eax
je 0xc2f4
movl (%r15), %edx
movzbl 0x4a(%r14), %eax
cmpl %eax, %edx
jge 0xc2fd
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc5f6
addq $0x8, %rbx
movq %rbx, %r15
movl (%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc4fa
jmp 0xc2f4
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq %rdx, %rdi
callq 0xc29d
testl %eax, %eax
je 0xc3ad
movq %r12, %rdi
callq 0xc29d
testl %eax, %eax
je 0xc3ad
xorpd %xmm0, %xmm0
leal -0xc(%r14), %eax
cmpl $0x8, %eax
ja 0xc3a6
movsd 0x8(%rbx), %xmm2
movsd 0x8(%r12), %xmm1
leaq 0x5f98(%rip), %rcx      # 0x122f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
jmp 0xc39c
movapd %xmm2, %xmm0
callq 0x30c0
jmp 0xc3a0
subsd %xmm1, %xmm2
jmp 0xc39c
xorpd 0x624c(%rip), %xmm2     # 0x125d0
jmp 0xc39c
xorl %ebp, %ebp
jmp 0xc3c8
mulsd %xmm1, %xmm2
jmp 0xc39c
ucomisd %xmm0, %xmm1
jne 0xc398
jnp 0xc3bb
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
ucomisd %xmm0, %xmm0
jp 0xc3ad
movsd %xmm0, 0x8(%rbx)
jmp 0xc412
xorl %ebp, %ebp
cmpl $0x12, %r14d
je 0xc3c8
cmpl $0x14, %r14d
je 0xc3c8
movq %r15, %rdi
movq %r12, %rsi
callq 0xcc33
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0xcc33
movl %eax, %r13d
cmpl %ebp, %eax
movq %r12, %rsi
cmovgq %rbx, %rsi
cmovleq %rbx, %r12
movq %r15, %rdi
callq 0xcbdf
movq %r15, %rdi
movq %r12, %rsi
callq 0xcbdf
movq %r15, %rdi
movl %r14d, %esi
xorl %edx, %edx
movl %r13d, %ecx
movl %ebp, %r8d
callq 0xc633
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
ucomisd %xmm0, %xmm1
jne 0xc429
jnp 0xc3bb
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x3260
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xc3a0