LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaG_errormsg
static void luaG_errormsg(lua_State*L){
if(L->errfunc!=0){
StkId errfunc=restorestack(L,L->errfunc);
if(!ttisfunction(errfunc))luaD_throw(L,5);
setobj(L,L->top,L->top-1);
setobj(L,L->top-1,errfunc);
incr_top(L);
luaD_call(L,L->top-2,1);
}
luaD_throw(L,2);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x5d37
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x30(%rsp), %rcx
addq 0xb0(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x6, 0x8(%rax)
je 0x5c60
movq 0x30(%rsp), %rdi
movl $0x5, %esi
callq 0x4bc0
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jg 0x5d08
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x61d0
jmp 0x5d0a
jmp 0x5d0a
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
addq $-0x20, %rsi
movl $0x1, %edx
callq 0x6ce0
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x4bc0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: currentline
static int currentline(lua_State*L,CallInfo*ci){
int pc=currentpc(L,ci);
if(pc<0)
return-1;
else
return getline_(ci_func(ci)->l.p,pc);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6090
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x5d82
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5dcb
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x5dbb
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
jmp 0x5dc3
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x5dc3
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaO_chunkid
static void luaO_chunkid(char*out,const char*source,size_t bufflen){
if(*source=='='){
strncpy(out,source+1,bufflen);
out[bufflen-1]='\0';
}
else{
if(*source=='@'){
size_t l;
source++;
bufflen-=sizeof(" '...' ");
l=strlen(source);
strcpy(out,"");
if(l>bufflen){
source+=(l-bufflen);
strcat(out,"...");
}
strcat(out,source);
}
else{
size_t len=strcspn(source,"\n\r");
bufflen-=sizeof(" [string \"...\"] ");
if(len>bufflen)len=bufflen;
strcpy(out,"[string \"");
if(source[len]!='\0'){
strncat(out,source,len);
strcat(out,"...");
}
else
strcat(out,source);
strcat(out,"\"]");
}
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x5e2f
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
movq 0x10(%rsp), %rdx
callq 0x3050
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x5f63
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
jne 0x5ec1
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
subq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x30f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1cc5f(%rip), %rsi     # 0x22ad6
callq 0x3070
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x5ead
movq 0x8(%rsp), %rax
subq 0x10(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c95a(%rip), %rsi     # 0x22802
callq 0x3270
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3270
jmp 0x5f61
movq 0x18(%rsp), %rdi
leaq 0x1c939(%rip), %rsi     # 0x22806
callq 0x3130
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
subq $0x11, %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x5ef8
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c905(%rip), %rsi     # 0x22809
callq 0x3070
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5f41
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
callq 0x3120
movq 0x20(%rsp), %rdi
leaq 0x1c8c8(%rip), %rsi     # 0x22802
callq 0x3270
jmp 0x5f50
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3270
movq 0x20(%rsp), %rdi
leaq 0x1c8b7(%rip), %rsi     # 0x22813
callq 0x3270
jmp 0x5f63
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaO_pushfstring
static const char*luaO_pushfstring(lua_State*L,const char*fmt,...){
const char*msg;
va_list argp;
va_start(argp,fmt);
msg=luaO_pushvfstring(L,fmt,argp);
va_end(argp);
return msg;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x5ffc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rsp, %rax
movq %rax, 0xc0(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0xb8(%rsp)
movl $0x30, 0xb4(%rsp)
movl $0x10, 0xb0(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x5620
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: currentpc
static int currentpc(lua_State*L,CallInfo*ci){
if(!isLua(ci))return-1;
if(ci==L->ci)
ci->savedpc=L->savedpc;
return pcRel(ci->savedpc,ci_func(ci)->l.p);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x6, 0x8(%rax)
jne 0x60bb
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
je 0x60c5
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x6112
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x60e7
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
sarq $0x2, %rax
subl $0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaD_growstack
static void luaD_growstack(lua_State*L,int n){
if(n<=L->stacksize)
luaD_reallocstack(L,2*L->stacksize);
else
luaD_reallocstack(L,L->stacksize+n);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jg 0x6201
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x58(%rax), %esi
shll %esi
callq 0x6550
jmp 0x6217
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x58(%rax), %esi
addl 0xc(%rsp), %esi
callq 0x6550
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaD_reallocstack
static void luaD_reallocstack(lua_State*L,int newsize){
TValue*oldstack=L->stack;
int realsize=newsize+1+5;
luaM_reallocvector(L,L->stack,L->stacksize,realsize,TValue);
L->stacksize=realsize;
L->stack_last=L->stack+newsize;
correctstack(L,oldstack);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
addl $0x5, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
cltq
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
cmpq %rcx, %rax
ja 0x65c0
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x20(%rsp), %rax
movslq 0x58(%rax), %rdx
shlq $0x4, %rdx
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
callq 0x4b30
movq %rax, (%rsp)
jmp 0x65ce
movq 0x20(%rsp), %rdi
callq 0x5480
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x40(%rax)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x58(%rax)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movslq 0x1c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6620
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: correctstack
static void correctstack(lua_State*L,TValue*oldstack){
CallInfo*ci;
GCObject*up;
L->top=(L->top-oldstack)+L->stack;
for(up=L->openupval;up!=NULL;up=up->gch.next)
gco2uv(up)->v=(gco2uv(up)->v-oldstack)+L->stack;
for(ci=L->base_ci;ci<=L->ci;ci++){
ci->top=(ci->top-oldstack)+L->stack;
ci->base=(ci->base-oldstack)+L->stack;
ci->func=(ci->func-oldstack)+L->stack;
}
L->base=(L->base-oldstack)+L->stack;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x40(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x66a8
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x40(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x6666
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x28(%rcx), %rax
ja 0x675c
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x40(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x40(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x40(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rsp)
jmp 0x66b6
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x40(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaV_tostring
static int luaV_tostring(lua_State*L,StkId obj){
if(!ttisnumber(obj))
return 0;
else{
char s[32];
lua_Number n=nvalue(obj);
lua_number2str(s,n);
setsvalue(L,obj,luaS_new(L,s));
return 1;
}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpl $0x3, 0x8(%rax)
je 0x67b3
movl $0x0, 0x54(%rsp)
jmp 0x6832
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
leaq 0x1c065(%rip), %rsi     # 0x22839
movb $0x1, %al
callq 0x3280
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x30f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x49c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x4, 0x8(%rax)
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: call_binTM
static int call_binTM(lua_State*L,const TValue*p1,const TValue*p2,
StkId res,TMS event){
const TValue*tm=luaT_gettmbyobj(L,p1,event);
if(ttisnil(tm))
tm=luaT_gettmbyobj(L,p2,event);
if(ttisnil(tm))return 0;
callTMres(L,res,tm,p1,p2);
return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x69e0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x6895
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x69e0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x68a9
movl $0x0, 0x34(%rsp)
jmp 0x68ce
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x6aa0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaZ_openspace
static char*luaZ_openspace(lua_State*L,Mbuffer*buff,size_t n){
if(n>buff->buffsize){
if(n<32)n=32;
luaZ_resizebuffer(L,buff,n);
}
return buff->buffer;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x69cc
cmpq $0x20, 0x10(%rsp)
jae 0x6964
movq $0x20, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
cmpq $-0x3, %rax
ja 0x69a2
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
movq 0x10(%rsp), %rcx
shlq $0x0, %rcx
callq 0x4b30
movq %rax, 0x8(%rsp)
jmp 0x69b1
movq 0x20(%rsp), %rdi
callq 0x5480
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaT_gettmbyobj
static const TValue*luaT_gettmbyobj(lua_State*L,const TValue*o,TMS event){
Table*mt;
switch(ttype(o)){
case 5:
mt=hvalue(o)->metatable;
break;
case 7:
mt=uvalue(o)->metatable;
break;
default:
mt=G(L)->mt[ttype(o)];
}
return(mt?luaH_getstr(mt,G(L)->tmname[event]):(&luaO_nilobject_));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
subl $0x5, %eax
je 0x6a10
jmp 0x6a05
movl 0x14(%rsp), %eax
subl $0x7, %eax
je 0x6a23
jmp 0x6a36
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x6a55
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x6a55
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq 0xe0(%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x6a83
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x24(%rsp), %ecx
movq 0x128(%rax,%rcx,8), %rsi
callq 0x6c40
movq %rax, 0x8(%rsp)
jmp 0x6a91
leaq 0x1bb4e(%rip), %rax     # 0x225d8
movq %rax, 0x8(%rsp)
jmp 0x6a91
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: callTMres
static void callTMres(lua_State*L,StkId res,const TValue*f,
const TValue*p1,const TValue*p2){
ptrdiff_t result=savestack(L,res);
setobj(L,L->top,f);
setobj(L,L->top+1,p1);
setobj(L,L->top+2,p2);
luaD_checkstack(L,3);
L->top+=3;
luaD_call(L,L->top-3,1);
res=restorestack(L,result);
L->top--;
setobj(L,res,L->top);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x30, %rax
jg 0x6baf
movq 0x70(%rsp), %rdi
movl $0x3, %esi
callq 0x61d0
jmp 0x6bb1
jmp 0x6bb1
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x30, %rcx
movq %rcx, 0x10(%rax)
movq 0x70(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rsi
addq $-0x30, %rsi
movl $0x1, %edx
callq 0x6ce0
movq 0x70(%rsp), %rax
movq 0x40(%rax), %rax
addq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x78, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaH_getstr
static const TValue*luaH_getstr(Table*t,TString*key){
Node*n=hashstr(t,key);
do{
if(ttisstring(gkey(n))&&rawtsvalue(gkey(n))==key)
return gval(n);
else n=gnext(n);
}while(n);
return(&luaO_nilobject_);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x28(%rsp), %rcx
subq $0x1, %rdx
andq %rdx, %rcx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x6cb5
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x6cb5
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x6cd9
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x6cc5
cmpq $0x0, -0x20(%rsp)
jne 0x6c8e
leaq 0x1b904(%rip), %rax     # 0x225d8
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaD_call
static void luaD_call(lua_State*L,StkId func,int nResults){
if(++L->nCcalls>=200){
if(L->nCcalls==200)
luaG_runerror(L,"C stack overflow");
else if(L->nCcalls>=(200+(200>>3)))
luaD_throw(L,5);
}
if(luaD_precall(L,func,nResults)==0)
luaV_execute(L,1);
L->nCcalls--;
luaC_checkGC(L);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rcx
movw 0x60(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x60(%rcx)
movzwl %ax, %eax
cmpl $0xc8, %eax
jl 0x6d55
movq 0x10(%rsp), %rax
movzwl 0x60(%rax), %eax
cmpl $0xc8, %eax
jne 0x6d32
movq 0x10(%rsp), %rdi
leaq 0x1bb16(%rip), %rsi     # 0x2283f
movb $0x0, %al
callq 0x54a0
jmp 0x6d53
movq 0x10(%rsp), %rax
movzwl 0x60(%rax), %eax
cmpl $0xe1, %eax
jl 0x6d51
movq 0x10(%rsp), %rdi
movl $0x5, %esi
callq 0x4bc0
jmp 0x6d53
jmp 0x6d55
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x6dc0
cmpl $0x0, %eax
jne 0x6d7c
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x7190
movq 0x10(%rsp), %rax
movw 0x60(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x60(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x70(%rcx), %rax
jb 0x6db3
movq 0x10(%rsp), %rdi
callq 0xa270
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaC_step
static void luaC_step(lua_State*L){
global_State*g=G(L);
l_mem lim=(1024u/100)*g->gcstepmul;
if(lim==0)
lim=(((lu_mem)(~(lu_mem)0)-2)-1)/2;
g->gcdept+=g->totalbytes-g->GCthreshold;
do{
lim-=singlestep(L);
if(g->gcstate==0)
break;
}while(lim>0);
if(g->gcstate!=0){
if(g->gcdept<1024u)
g->GCthreshold=g->totalbytes+1024u;
else{
g->gcdept-=1024u;
g->GCthreshold=g->totalbytes;
}
}
else{
setthreshold(g);
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
imull $0xa, 0x94(%rax), %eax
movl %eax, %eax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xa2ae
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rcx
movq 0x8(%rsp), %rax
subq 0x70(%rax), %rcx
movq 0x8(%rsp), %rax
addq 0x88(%rax), %rcx
movq %rcx, 0x88(%rax)
movq 0x10(%rsp), %rdi
callq 0xd380
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x0, %eax
jne 0xa2fb
jmp 0xa304
jmp 0xa2fd
cmpq $0x0, (%rsp)
jg 0xa2d3
movq 0x8(%rsp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x0, %eax
je 0xa36d
movq 0x8(%rsp), %rax
cmpq $0x400, 0x88(%rax) # imm = 0x400
jae 0xa33f
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rcx
addq $0x400, %rcx            # imm = 0x400
movq 0x8(%rsp), %rax
movq %rcx, 0x70(%rax)
jmp 0xa36b
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rcx
subq $0x400, %rcx            # imm = 0x400
movq %rcx, 0x88(%rax)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x70(%rax)
jmp 0xa39f
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x8(%rsp), %rax
movslq 0x90(%rax), %rax
imulq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x70(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: tryfuncTM
static StkId tryfuncTM(lua_State*L,StkId func){
const TValue*tm=luaT_gettmbyobj(L,func,TM_CALL);
StkId p;
ptrdiff_t funcr=savestack(L,func);
if(!ttisfunction(tm))
luaG_typeerror(L,func,"call");
for(p=L->top;p>func;p--)setobj(L,p,p-1);
incr_top(L);
func=restorestack(L,funcr);
setobj(L,func,tm);
return func;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x10, %edx
callq 0x69e0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x6, 0x8(%rax)
je 0xa40e
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x18625(%rip), %rdx     # 0x22a2e
callq 0xa800
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0xa470
movq 0x28(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x28(%rsp)
jmp 0xa41c
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x40(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jg 0xa49c
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x61d0
jmp 0xa49e
jmp 0xa49e
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: adjust_varargs
static StkId adjust_varargs(lua_State*L,Proto*p,int actual){
int i;
int nfixargs=p->numparams;
Table*htab=NULL;
StkId base,fixed;
for(;actual<nfixargs;++actual)
setnilvalue(L->top++);
fixed=L->top-actual;
base=L->top;
for(i=0;i<nfixargs;i++){
setobj(L,L->top++,fixed+i);
setnilvalue(fixed+i);
}
if(htab){
sethvalue(L,L->top++,htab);
}
return base;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x10(%rsp), %rax
movzbl 0x71(%rax), %eax
movl %eax, -0x1c(%rsp)
movq $0x0, -0x28(%rsp)
movl -0x14(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0xa556
movq -0x8(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movl $0x0, 0x8(%rax)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xa524
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0xa609
movq -0x38(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rsp)
movq -0x8(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
movq -0x40(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x40(%rsp), %rax
movl 0x8(%rax), %ecx
movq -0x48(%rsp), %rax
movl %ecx, 0x8(%rax)
movq -0x38(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xa58b
cmpq $0x0, -0x28(%rsp)
je 0xa643
movq -0x8(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, -0x50(%rsp)
movq -0x28(%rsp), %rcx
movq -0x50(%rsp), %rax
movq %rcx, (%rax)
movq -0x50(%rsp), %rax
movl $0x5, 0x8(%rax)
movq -0x30(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: growCI
static CallInfo*growCI(lua_State*L){
if(L->size_ci>20000)
luaD_throw(L,5);
else{
luaD_reallocCI(L,2*L->size_ci);
if(L->size_ci>20000)
luaG_runerror(L,"stack overflow");
}
return++L->ci;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x4e20, 0x5c(%rax)     # imm = 0x4E20
jle 0xa672
movq (%rsp), %rdi
movl $0x5, %esi
callq 0x4bc0
jmp 0xa6a5
movq (%rsp), %rdi
movq (%rsp), %rax
movl 0x5c(%rax), %esi
shll %esi
callq 0x5390
movq (%rsp), %rax
cmpl $0x4e20, 0x5c(%rax)     # imm = 0x4E20
jle 0xa6a3
movq (%rsp), %rdi
leaq 0x181a5(%rip), %rsi     # 0x22841
movb $0x0, %al
callq 0x54a0
jmp 0xa6a5
movq (%rsp), %rcx
movq 0x28(%rcx), %rax
addq $0x28, %rax
movq %rax, 0x28(%rcx)
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaD_poscall
static int luaD_poscall(lua_State*L,StkId firstResult){
StkId res;
int wanted,i;
CallInfo*ci;
ci=L->ci--;
res=ci->func;
wanted=ci->nresults;
L->base=(ci-1)->base;
L->savedpc=(ci-1)->savedpc;
for(i=wanted;i!=0&&firstResult<L->top;i--)
setobj(L,res++,firstResult++);
while(i-->0)
setnilvalue(res++);
L->top=res;
return(wanted-(-1));
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rcx
movq 0x28(%rcx), %rax
movq %rax, %rdx
addq $-0x28, %rdx
movq %rdx, 0x28(%rcx)
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x28(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rsp)
movq -0x28(%rsp), %rax
movq -0x28(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rsp), %rax
movq -0x10(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movl -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
xorl %eax, %eax
cmpl $0x0, -0x20(%rsp)
movb %al, -0x39(%rsp)
je 0xa74b
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
setb %al
movb %al, -0x39(%rsp)
movb -0x39(%rsp), %al
testb $0x1, %al
jne 0xa755
jmp 0xa7b1
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x10(%rsp)
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x18(%rsp)
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x30(%rsp), %rax
movl 0x8(%rax), %ecx
movq -0x38(%rsp), %rax
movl %ecx, 0x8(%rax)
movl -0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0xa729
jmp 0xa7b3
movl -0x20(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rsp)
cmpl $0x0, %eax
jle 0xa7df
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x18(%rsp)
movl $0x0, 0x8(%rax)
jmp 0xa7b3
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rsp), %eax
subl $-0x1, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaG_typeerror
static void luaG_typeerror(lua_State*L,const TValue*o,const char*op){
const char*name=NULL;
const char*t=luaT_typenames[ttype(o)];
const char*kind=(isinstack(L->ci,o))?
NULL:
NULL;
if(kind)
luaG_runerror(L,"attempt to %s %s "LUA_QL("%s")" (a %s value)",
op,kind,name,t);
else
luaG_runerror(L,"attempt to %s a %s value",op,t);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movslq 0x8(%rax), %rcx
leaq 0x1e024(%rip), %rax     # 0x28850
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xa8b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xa889
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
leaq 0x17fd0(%rip), %rsi     # 0x22850
movb $0x0, %al
callq 0x54a0
jmp 0xa8a6
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x17fd4(%rip), %rsi     # 0x22873
movb $0x0, %al
callq 0x54a0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: isinstack
static int isinstack(CallInfo*ci,const TValue*o){
StkId p;
for(p=ci->base;p<ci->top;p++)
if(o==p)return 1;
return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa8ff
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jne 0xa8ed
movl $0x1, -0x4(%rsp)
jmp 0xa907
jmp 0xa8ef
movq -0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rsp)
jmp 0xa8c7
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaV_gettable
static void luaV_gettable(lua_State*L,const TValue*t,TValue*key,StkId val){
int loop;
for(loop=0;loop<100;loop++){
const TValue*tm;
if(ttistable(t)){
Table*h=hvalue(t);
const TValue*res=luaH_get(h,key);
if(!ttisnil(res)||
(tm=fasttm(L,h->metatable,TM_INDEX))==NULL){
setobj(L,val,res);
return;
}
}
else if(ttisnil(tm=luaT_gettmbyobj(L,t,TM_INDEX)))
luaG_typeerror(L,t,"index");
if(ttisfunction(tm)){
callTMres(L,val,tm,t,key);
return;
}
t=tm;
}
luaG_runerror(L,"loop in gettable");
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
cmpl $0x64, 0x44(%rsp)
jge 0xaa9c
movq 0x58(%rsp), %rax
cmpl $0x5, 0x8(%rax)
jne 0xaa23
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xb970
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xa9e8
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xa98b
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0xa9d8
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0xa(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa9a9
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xa9ce
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x128(%rax), %rdx
xorl %esi, %esi
callq 0xba80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
jne 0xaa21
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0xaaaf
jmp 0xaa57
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
xorl %edx, %edx
callq 0x69e0
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x8(%rax)
jne 0xaa55
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
leaq 0x188ff(%rip), %rdx     # 0x2334f
callq 0xa800
jmp 0xaa57
movq 0x38(%rsp), %rax
cmpl $0x6, 0x8(%rax)
jne 0xaa82
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0x6aa0
jmp 0xaaaf
movq 0x38(%rsp), %rax
movq %rax, 0x58(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xa930
movq 0x60(%rsp), %rdi
leaq 0x17e74(%rip), %rsi     # 0x2291c
movb $0x0, %al
callq 0x54a0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaV_settable
static void luaV_settable(lua_State*L,const TValue*t,TValue*key,StkId val){
int loop;
TValue temp;
for(loop=0;loop<100;loop++){
const TValue*tm;
if(ttistable(t)){
Table*h=hvalue(t);
TValue*oldval=luaH_set(L,h,key);
if(!ttisnil(oldval)||
(tm=fasttm(L,h->metatable,TM_NEWINDEX))==NULL){
setobj(L,oldval,val);
h->flags=0;
luaC_barriert(L,h,val);
return;
}
}
else if(ttisnil(tm=luaT_gettmbyobj(L,t,TM_NEWINDEX)))
luaG_typeerror(L,t,"index");
if(ttisfunction(tm)){
callTM(L,tm,t,key,val);
return;
}
setobj(L,&temp,tm);
t=&temp;
}
luaG_runerror(L,"loop in settable");
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
cmpl $0x64, 0x64(%rsp)
jge 0xacef
movq 0x78(%rsp), %rax
cmpl $0x5, 0x8(%rax)
jne 0xac36
movq 0x78(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0xbee0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xabb0
movq 0x40(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xab49
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0xab9c
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0xa(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xab67
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xab92
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x80(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x130(%rax), %rdx
movl $0x1, %esi
callq 0xba80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, %rax
jne 0xac34
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rax
movb $0x0, 0xa(%rax)
movq 0x68(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jl 0xac2f
movq 0x68(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xac2f
movq 0x40(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xac2f
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xb6d0
jmp 0xad05
jmp 0xac73
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movl $0x1, %edx
callq 0x69e0
movq %rax, 0x48(%rsp)
cmpl $0x0, 0x8(%rax)
jne 0xac71
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
leaq 0x186e3(%rip), %rdx     # 0x2334f
callq 0xa800
jmp 0xac73
movq 0x48(%rsp), %rax
cmpl $0x6, 0x8(%rax)
jne 0xaca1
movq 0x80(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x70(%rsp), %rcx
movq 0x68(%rsp), %r8
callq 0xbfb0
jmp 0xad05
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
leaq 0x50(%rsp), %rax
movq %rax, 0x78(%rsp)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0xaae6
movq 0x80(%rsp), %rdi
leaq 0x17c2f(%rip), %rsi     # 0x2292d
movb $0x0, %al
callq 0x54a0
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaH_getn
static int luaH_getn(Table*t){
unsigned int j=t->sizearray;
if(j>0&&ttisnil(&t->array[j-1])){
unsigned int i=0;
while(j-i>1){
unsigned int m=(i+j)/2;
if(ttisnil(&t->array[m-1]))j=m;
else i=m;
}
return i;
}
else if(t->node==(&dummynode_))
return j;
else return unbound_search(t,j);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jbe 0xb0bb
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0xb0bb
movl $0x0, 0x10(%rsp)
movl 0x14(%rsp), %eax
subl 0x10(%rsp), %eax
cmpl $0x1, %eax
jbe 0xb0b1
movl 0x10(%rsp), %eax
addl 0x14(%rsp), %eax
shrl %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0xb0a7
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0xb0af
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0xb063
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xb0e9
movq 0x18(%rsp), %rax
leaq 0x17521(%rip), %rcx     # 0x225e8
cmpq %rcx, 0x20(%rax)
jne 0xb0d7
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xb0e9
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xcce0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaV_equalval
static int luaV_equalval(lua_State*L,const TValue*t1,const TValue*t2){
const TValue*tm;
switch(ttype(t1)){
case 0:return 1;
case 3:return luai_numeq(nvalue(t1),nvalue(t2));
case 1:return bvalue(t1)==bvalue(t2);
case 2:return pvalue(t1)==pvalue(t2);
case 7:{
if(uvalue(t1)==uvalue(t2))return 1;
tm=get_compTM(L,uvalue(t1)->metatable,uvalue(t2)->metatable,
TM_EQ);
break;
}
case 5:{
if(hvalue(t1)==hvalue(t2))return 1;
tm=get_compTM(L,hvalue(t1)->metatable,hvalue(t2)->metatable,TM_EQ);
break;
}
default:return gcvalue(t1)==gcvalue(t2);
}
if(tm==NULL)return 0;
callTMres(L,L->top,tm,t1,t2);
return!l_isfalse(L->top);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x7, %rax
ja 0xb24e
movq 0x8(%rsp), %rax
leaq 0x16faa(%rip), %rcx     # 0x220e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x34(%rsp)
jmp 0xb2f7
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movq 0x18(%rsp), %rax
ucomisd (%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0xb2f7
movq 0x20(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0xb2f7
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0xb2f7
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jne 0xb1d3
movl $0x1, 0x34(%rsp)
jmp 0xb2f7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdx
movl $0x4, %ecx
callq 0xcdd0
movq %rax, 0x10(%rsp)
jmp 0xb26f
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jne 0xb220
movl $0x1, 0x34(%rsp)
jmp 0xb2f7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdx
movl $0x4, %ecx
callq 0xcdd0
movq %rax, 0x10(%rsp)
jmp 0xb26f
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0xb2f7
cmpq $0x0, 0x10(%rsp)
jne 0xb281
movl $0x0, 0x34(%rsp)
jmp 0xb2f7
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x6aa0
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rcx
movb $0x1, %al
cmpl $0x0, 0x8(%rcx)
movb %al, 0x7(%rsp)
je 0xb2e8
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
cmpl $0x1, 0x8(%rcx)
movb %al, 0x6(%rsp)
jne 0xb2e0
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaV_lessthan
static int luaV_lessthan(lua_State*L,const TValue*l,const TValue*r){
int res;
if(ttype(l)!=ttype(r))
return luaG_ordererror(L,l,r);
else if(ttisnumber(l))
return luai_numlt(nvalue(l),nvalue(r));
else if(ttisstring(l))
return l_strcmp(rawtsvalue(l),rawtsvalue(r))<0;
else if((res=call_orderTM(L,l,r,TM_LT))!=-1)
return res;
return luaG_ordererror(L,l,r);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0xb342
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xcf50
movl %eax, 0x24(%rsp)
jmp 0xb3ec
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0xb371
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xb3ec
movq 0x10(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jne 0xb3a2
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0xcff0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xb3ec
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0xd, %ecx
callq 0xd110
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xb3ce
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xb3ec
jmp 0xb3d0
jmp 0xb3d2
jmp 0xb3d4
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xcf50
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lessequal
static int lessequal(lua_State*L,const TValue*l,const TValue*r){
int res;
if(ttype(l)!=ttype(r))
return luaG_ordererror(L,l,r);
else if(ttisnumber(l))
return luai_numle(nvalue(l),nvalue(r));
else if(ttisstring(l))
return l_strcmp(rawtsvalue(l),rawtsvalue(r))<=0;
else if((res=call_orderTM(L,l,r,TM_LE))!=-1)
return res;
else if((res=call_orderTM(L,r,l,TM_LT))!=-1)
return!res;
return luaG_ordererror(L,l,r);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0xb442
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xcf50
movl %eax, 0x24(%rsp)
jmp 0xb52b
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0xb474
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xb52b
movq 0x10(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jne 0xb4a8
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0xcff0
cmpl $0x0, %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xb52b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0xe, %ecx
callq 0xd110
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xb4d4
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xb52b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl $0xd, %ecx
callq 0xd110
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xb50b
cmpl $0x0, 0x4(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xb52b
jmp 0xb50d
jmp 0xb50f
jmp 0xb511
jmp 0xb513
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xcf50
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaV_tonumber
static const TValue*luaV_tonumber(const TValue*obj,TValue*n){
lua_Number num;
if(ttisnumber(obj))return obj;
if(ttisstring(obj)&&luaO_str2d(svalue(obj),&num)){
setnvalue(n,num);
return n;
}
else
return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0xb565
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xb5c2
movq 0x18(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jne 0xb5b9
movq 0x18(%rsp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0xd210
cmpl $0x0, %eax
je 0xb5b9
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movsd 0x8(%rsp), %xmm0
movq (%rsp), %rax
movsd %xmm0, (%rax)
movq (%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xb5c2
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaH_setnum
static TValue*luaH_setnum(lua_State*L,Table*t,int key){
const TValue*p=luaH_getnum(t,key);
if(p!=(&luaO_nilobject_))
return cast(TValue*,p);
else{
TValue k;
setnvalue(&k,cast_num(key));
return newkey(L,t,&k);
}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xbaf0
movq %rax, 0x20(%rsp)
leaq 0x16f6c(%rip), %rax     # 0x225d8
cmpq %rax, 0x20(%rsp)
je 0xb67f
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xb6bd
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cvtsi2sdl 0x2c(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xc120
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaC_barrierback
static void luaC_barrierback(lua_State*L,Table*t){
global_State*g=G(L);
GCObject*o=obj2gco(t);
black2gray(o);
t->gclist=g->grayagain;
g->grayagain=o;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl 0x9(%rax), %ecx
andl $0xfb, %ecx
movb %cl, 0x9(%rax)
movq -0x18(%rsp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x40(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaF_newLclosure
static Closure*luaF_newLclosure(lua_State*L,int nelems,Table*e){
Closure*c=cast(Closure*,luaM_malloc(L,sizeLclosure(nelems)));
luaC_link(L,obj2gco(c),6);
c->l.isC=0;
c->l.env=e;
c->l.nupvalues=cast_byte(nelems);
while(nelems--)c->l.upvals[nelems]=NULL;
return c;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
subl $0x1, %eax
cltq
shlq $0x3, %rax
addl $0x30, %eax
movslq %eax, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x4b30
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x6, %edx
callq 0xd320
movq 0x8(%rsp), %rax
movb $0x0, 0xa(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x1c(%rsp), %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0xb(%rax)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rsp)
cmpl $0x0, %eax
je 0xb7cb
movq 0x8(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq $0x0, 0x28(%rax,%rcx,8)
jmp 0xb7a4
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)