LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_loadstring
static int luaB_loadstring(lua_State*L){
size_t l;
const char*s=luaL_checklstring(L,1,&l);
const char*chunkname=luaL_optstring(L,2,s);
return load_aux(L,luaL_loadbuffer(L,s,l,chunkname));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
callq 0x11450
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x10880
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x11960
movq (%rsp), %rdi
movl %eax, %esi
callq 0x11820
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_pcall
static int luaB_pcall(lua_State*L){
int status;
luaL_checkany(L,1);
status=lua_pcall(L,lua_gettop(L)-1,(-1),0);
lua_pushboolean(L,(status==0));
lua_insert(L,1);
return lua_gettop(L);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x106e0
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x10910
movq (%rsp), %rdi
movl %eax, %esi
subl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3b70
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
cmpl $0x0, 0xc(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1a180
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x118a0
movq 0x10(%rsp), %rdi
callq 0x10910
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_rawget
static int luaB_rawget(lua_State*L){
luaL_checktype(L,1,5);
luaL_checkany(L,2);
lua_settop(L,2);
lua_rawget(L,1);
return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x106e0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x11600
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x1a210
movl $0x1, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0x1a1d0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1a290
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0xf7f0
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x117c0
cmpl $0x0, %eax
je 0x10298
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1a3e0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10298
jp 0x10298
movq 0x8(%rsp), %rdi
callq 0x1a450
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x118a0
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1a4b0
movl $0x0, 0x14(%rsp)
jmp 0x102dd
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1a5f0
cmpl $0x0, %eax
jne 0x102c0
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1a4b0
cmpl $0x0, %eax
jne 0x102d3
movq 0x8(%rsp), %rdi
leaq 0x12ca9(%rip), %rsi     # 0x22f75
movb $0x0, %al
callq 0x10790
jmp 0x102d5
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x10930
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movb $0x1, %al
cmpl $0x0, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x1035a
movb $0x1, %al
cmpl $0x5, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x1035a
movq 0x10(%rsp), %rdi
movl $0x2, %esi
leaq 0x12cb9(%rip), %rdx     # 0x23004
callq 0x10980
cmpl $0x0, %eax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x12cab(%rip), %rdx     # 0x2301a
callq 0x1a650
cmpl $0x0, %eax
je 0x1038c
movq 0x10(%rsp), %rdi
leaq 0x12ca1(%rip), %rsi     # 0x23026
movb $0x0, %al
callq 0x10790
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11600
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xfae0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
movl $0xa, %edx
callq 0x115b0
movl %eax, 0x34(%rsp)
cmpl $0xa, 0x34(%rsp)
jne 0x10440
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x106e0
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x117c0
cmpl $0x0, %eax
je 0x1043b
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x1a3e0
movq 0x10(%rsp), %rdi
callq 0x1a870
movl $0x1, 0x44(%rsp)
jmp 0x1054a
jmp 0x10538
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x28(%rsp)
movl $0x2, %eax
cmpl 0x34(%rsp), %eax
jg 0x10470
movb $0x1, %al
cmpl $0x24, 0x34(%rsp)
movb %al, 0xf(%rsp)
jle 0x10490
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x12bc9(%rip), %rdx     # 0x2304a
callq 0x10980
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %edx
leaq 0x20(%rsp), %rsi
callq 0x3250
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x10536
jmp 0x104ba
callq 0x32d0
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x104eb
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x104ba
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10534
movq 0x38(%rsp), %rdi
movaps 0x1225c(%rip), %xmm1    # 0x22760
movq 0x18(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1225a(%rip), %xmm1    # 0x22770
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x1a870
movl $0x1, 0x44(%rsp)
jmp 0x1054a
jmp 0x10536
jmp 0x10538
movq 0x38(%rsp), %rdi
callq 0x11870
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1a1d0
movq 0x18(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x115b0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x10930
cmpl $0x0, %eax
jg 0x1061e
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x1a8c0
movl %eax, 0x8(%rsp)
jmp 0x10631
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x116e0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jle 0x10650
movl $0x0, 0x24(%rsp)
jmp 0x106d5
movl 0x10(%rsp), %eax
subl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x10679
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1a9b0
cmpl $0x0, %eax
jne 0x10692
movq 0x18(%rsp), %rdi
leaq 0x129d7(%rip), %rsi     # 0x2305c
movb $0x0, %al
callq 0x10790
movl %eax, 0x24(%rsp)
jmp 0x106d5
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x1, %esi
callq 0x1aaa0
movl 0x14(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rsp)
cmpl 0x10(%rsp), %eax
jge 0x106cd
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x1, %esi
callq 0x1aaa0
jmp 0x106a5
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xd8, %rsp
testb %al, %al
je 0x107cc
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, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rsp, %rax
movq %rax, 0xc0(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0xb8(%rsp)
movl $0x30, 0xb4(%rsp)
movl $0x10, 0xb0(%rsp)
movq 0xd0(%rsp), %rdi
movl $0x1, %esi
callq 0x11150
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x111e0
movq 0xd0(%rsp), %rdi
movl $0x2, %esi
callq 0x11240
movq 0xd0(%rsp), %rdi
callq 0x11330
addq $0xd8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x10930
cmpl $0x0, %eax
jg 0x108ed
cmpq $0x0, 0x10(%rsp)
je 0x108e1
cmpq $0x0, 0x18(%rsp)
je 0x108cb
movq 0x18(%rsp), %rdi
callq 0x30f0
movq %rax, 0x8(%rsp)
jmp 0x108d4
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x108d4
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x10905
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x11450
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rdi
xorl %esi, %esi
movq %rsp, %rdx
callq 0x10ab0
cmpl $0x0, %eax
jne 0x109e0
movq 0x88(%rsp), %rdi
movl 0x84(%rsp), %edx
movq 0x78(%rsp), %rcx
leaq 0x121a8(%rip), %rsi     # 0x22b75
movb $0x0, %al
callq 0x10790
movl %eax, 0x94(%rsp)
jmp 0x10a95
movq 0x88(%rsp), %rdi
leaq 0x11ea3(%rip), %rsi     # 0x22892
movq %rsp, %rdx
callq 0x10bb0
movq 0x10(%rsp), %rdi
leaq 0x12188(%rip), %rsi     # 0x22b8b
callq 0x3180
cmpl $0x0, %eax
jne 0x10a53
movl 0x84(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x84(%rsp)
cmpl $0x0, 0x84(%rsp)
jne 0x10a51
movq 0x88(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x78(%rsp), %rcx
leaq 0x12151(%rip), %rsi     # 0x22b92
movb $0x0, %al
callq 0x10790
movl %eax, 0x94(%rsp)
jmp 0x10a95
jmp 0x10a53
cmpq $0x0, 0x8(%rsp)
jne 0x10a67
leaq 0x1214e(%rip), %rax     # 0x22bb0
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rdi
movl 0x84(%rsp), %edx
movq 0x8(%rsp), %rcx
movq 0x78(%rsp), %r8
leaq 0x1212b(%rip), %rsi     # 0x22bb2
movb $0x0, %al
callq 0x10790
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rsp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rsp)
movb %al, -0x29(%rsp)
jle 0x10aee
movq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x50(%rcx), %rax
seta %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0x10af8
jmp 0x10b39
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
jne 0x10b27
movq -0x28(%rsp), %rax
movl 0x24(%rax), %ecx
movl -0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rsp)
jmp 0x10b29
movq -0x28(%rsp), %rax
addq $-0x28, %rax
movq %rax, -0x28(%rsp)
jmp 0x10acc
cmpl $0x0, -0xc(%rsp)
jne 0x10b7f
movq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jbe 0x10b7f
movl $0x1, -0x1c(%rsp)
movq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movl %eax, %ecx
movq -0x18(%rsp), %rax
movl %ecx, 0x74(%rax)
jmp 0x10ba6
cmpl $0x0, -0xc(%rsp)
jge 0x10b9c
movl $0x1, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl $0x0, 0x74(%rax)
jmp 0x10ba4
movl $0x0, -0x1c(%rsp)
jmp 0x10ba6
movl -0x1c(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_getinfo
static int lua_getinfo(lua_State*L,const char*what,lua_Debug*ar){
int status;
Closure*f=NULL;
CallInfo*ci=NULL;
if(*what=='>'){
StkId func=L->top-1;
luai_apicheck(L,ttisfunction(func));
what++;
f=clvalue(func);
L->top--;
}
else if(ar->i_ci!=0){
ci=L->base_ci+ar->i_ci;
f=clvalue(ci->func);
}
status=auxgetinfo(L,what,ar,f,ci);
if(strchr(what,'f')){
if(f==NULL)setnilvalue(L->top);
else setclvalue(L,L->top,f);
incr_top(L);
}
if(strchr(what,'L'))
collectvalidlines(L,f);
return status;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0x10c22
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
jmp 0x10c5e
movq 0x30(%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0x10c5c
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x30(%rsp), %rcx
movslq 0x74(%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x10c5e
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x10d50
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x66, %esi
callq 0x3100
cmpq $0x0, %rax
je 0x10d19
cmpq $0x0, 0x20(%rsp)
jne 0x10cb3
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x8(%rax)
jmp 0x10cda
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x6, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x40(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jg 0x10d06
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x61d0
jmp 0x10d08
jmp 0x10d08
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rdi
movl $0x4c, %esi
callq 0x3100
cmpq $0x0, %rax
je 0x10d3d
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10eb0
movl 0x2c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: auxgetinfo
static int auxgetinfo(lua_State*L,const char*what,lua_Debug*ar,
Closure*f,CallInfo*ci){
int status=1;
if(f==NULL){
info_tailcall(ar);
return status;
}
for(;*what;what++){
switch(*what){
case'S':{
funcinfo(ar,f);
break;
}
case'l':{
ar->currentline=(ci)?currentline(L,ci):-1;
break;
}
case'u':{
ar->nups=f->c.nupvalues;
break;
}
case'n':{
ar->namewhat=(ci)?NULL:NULL;
if(ar->namewhat==NULL){
ar->namewhat="";
ar->name=NULL;
}
break;
}
case'L':
case'f':
break;
default:status=0;
}
}
return status;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x10d94
movq 0x28(%rsp), %rdi
callq 0x10fe0
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x10e9b
jmp 0x10d96
movq 0x30(%rsp), %rax
cmpb $0x0, (%rax)
je 0x10e93
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
addl $-0x4c, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x29, %eax
ja 0x10e76
movq 0x8(%rsp), %rax
leaq 0x11399(%rip), %rcx     # 0x22164
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11070
jmp 0x10e7e
cmpq $0x0, 0x18(%rsp)
je 0x10e05
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5d50
movl %eax, 0x4(%rsp)
jmp 0x10e10
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rsp)
jmp 0x10e10
movl 0x4(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x28(%rax)
jmp 0x10e7e
movq 0x20(%rsp), %rax
movzbl 0xb(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x2c(%rax)
jmp 0x10e7e
movq 0x18(%rsp), %rax
xorl %ecx, %ecx
cmpq $0x0, %rax
cmovneq %rcx, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x10e72
movq 0x28(%rsp), %rax
leaq 0x11c75(%rip), %rcx     # 0x22ad6
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x10e7e
jmp 0x10e7e
movl $0x0, 0x14(%rsp)
jmp 0x10e80
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x10d96
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: collectvalidlines
static void collectvalidlines(lua_State*L,Closure*f){
if(f==NULL||f->c.isC){
setnilvalue(L->top);
}
else{
Table*t=luaH_new(L,0,0);
int*lineinfo=f->l.p->lineinfo;
int i;
for(i=0;i<f->l.p->sizelineinfo;i++)
setbvalue(luaH_setnum(L,t,lineinfo[i]),1);
sethvalue(L,L->top,t);
}
incr_top(L);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x10ed4
movq 0x28(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
je 0x10ee9
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x8(%rax)
jmp 0x10f91
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4620
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpl 0x54(%rcx), %eax
jge 0x10f6d
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edx
callq 0xb640
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x8(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x10f16
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0x5, 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 0x10fbd
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x61d0
jmp 0x10fbf
jmp 0x10fbf
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: info_tailcall
static void info_tailcall(lua_Debug*ar){
ar->name=ar->namewhat="";
ar->what="tail";
ar->lastlinedefined=ar->linedefined=ar->currentline=-1;
ar->source="=(tail call)";
luaO_chunkid(ar->short_src,ar->source,60);
ar->nups=0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
leaq 0x11ae6(%rip), %rcx     # 0x22ad6
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
leaq 0x11ad7(%rip), %rcx     # 0x22ad6
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
leaq 0x11bc2(%rip), %rcx     # 0x22bd0
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x34(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
leaq 0x11b97(%rip), %rcx     # 0x22bd5
movq %rcx, 0x20(%rax)
movq (%rsp), %rdi
addq $0x38, %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
movl $0x3c, %edx
callq 0x5de0
movq (%rsp), %rax
movl $0x0, 0x2c(%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: funcinfo
static void funcinfo(lua_Debug*ar,Closure*cl){
if(cl->c.isC){
ar->source="=[C]";
ar->linedefined=-1;
ar->lastlinedefined=-1;
ar->what="C";
}
else{
ar->source=getstr(cl->l.p->source);
ar->linedefined=cl->l.p->linedefined;
ar->lastlinedefined=cl->l.p->lastlinedefined;
ar->what=(ar->linedefined==0)?"main":"Lua";
}
luaO_chunkid(ar->short_src,ar->source,60);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, 0xa(%rax)
je 0x110c3
movq 0x10(%rsp), %rax
leaq 0x11b4d(%rip), %rcx     # 0x22be2
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x34(%rax) # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
leaq 0x11b2a(%rip), %rcx     # 0x22be7
movq %rcx, 0x18(%rax)
jmp 0x1112b
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x40(%rax), %rcx
addq $0x18, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x60(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x64(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x34(%rax)
movq 0x10(%rsp), %rax
movl 0x30(%rax), %edx
leaq 0x1239d(%rip), %rcx     # 0x234b1
leaq 0x11ace(%rip), %rax     # 0x22be9
cmpl $0x0, %edx
cmoveq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movl $0x3c, %edx
callq 0x5de0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq 0x80(%rsp), %rdi
movl 0x7c(%rsp), %esi
movq %rsp, %rdx
callq 0x10ab0
cmpl $0x0, %eax
je 0x111bf
movq 0x80(%rsp), %rdi
leaq 0x11a63(%rip), %rsi     # 0x22bee
movq %rsp, %rdx
callq 0x10bb0
cmpl $0x0, 0x28(%rsp)
jle 0x111bd
movq 0x80(%rsp), %rdi
movq %rsp, %rdx
addq $0x38, %rdx
movl 0x28(%rsp), %ecx
leaq 0x11a3d(%rip), %rsi     # 0x22bf1
movb $0x0, %al
callq 0x11350
jmp 0x111d7
jmp 0x111bf
movq 0x80(%rsp), %rdi
leaq 0x11908(%rip), %rsi     # 0x22ad6
xorl %eax, %eax
movl %eax, %edx
callq 0xf860
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_pushvfstring
static const char*lua_pushvfstring(lua_State*L,const char*fmt,
va_list argp){
const char*ret;
luaC_checkGC(L);
ret=luaO_pushvfstring(L,fmt,argp);
return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x70(%rcx), %rax
jb 0x11219
movq 0x20(%rsp), %rdi
callq 0xa270
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5620
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jl 0x112cb
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 0x1127a
movq 0x10(%rsp), %rdi
callq 0xa270
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %edx
subl $0x1, %edx
callq 0x6220
movl 0xc(%rsp), %edx
subl $0x1, %edx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movslq %edx, %rsi
xorl %edx, %edx
subq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
jmp 0x1131c
cmpl $0x0, 0xc(%rsp)
jne 0x1131a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
leaq 0x117eb(%rip), %rsi     # 0x22ad6
xorl %eax, %eax
movl %eax, %edx
callq 0x49c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0x4, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
jmp 0x1131c
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xe8, %rsp
testb %al, %al
je 0x1138c
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 0xe0(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rax
movq 0xe0(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x70(%rcx), %rax
jb 0x113df
movq 0xe0(%rsp), %rdi
callq 0xa270
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: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
jl 0x11670
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq -0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x11650
movq -0x8(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movl $0x0, 0x8(%rax)
jmp 0x11610
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movslq -0xc(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1168e
movl -0xc(%rsp), %edx
addl $0x1, %edx
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x11740
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1172c
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x117c0
cmpl $0x0, %eax
jne 0x1172c
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3, %edx
callq 0x114a0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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 $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0xfd90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x3, 0x8(%rax)
je 0x11785
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xb540
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x117ac
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
cvttsd2si 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x117b5
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x1183e
movl $0x1, 0x14(%rsp)
jmp 0x1185f
movq 0x8(%rsp), %rdi
callq 0x11870
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x118a0
movl $0x2, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0xfd90
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x11922
movq 0x28(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%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)
movq 0x28(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x28(%rsp)
jmp 0x118ce
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%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 $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_loadbuffer
static int luaL_loadbuffer(lua_State*L,const char*buff,size_t size,
const char*name){
LoadS ls;
ls.s=buff;
ls.size=size;
return lua_load(L,getS,&ls,name);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x83(%rip), %rsi        # 0x11a20
leaq 0x8(%rsp), %rdx
callq 0x119b0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x119dc
leaq 0x111d9(%rip), %rax     # 0x22bb0
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
leaq 0x10(%rsp), %rsi
callq 0x11a90
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x11af0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11a50
movq $0x0, -0x8(%rsp)
jmp 0x11a7b
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaZ_init
static void luaZ_init(lua_State*L,ZIO*z,lua_Reader reader,void*data){
z->L=L;
z->reader=reader;
z->data=data;
z->n=0;
z->p=NULL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaD_protectedparser
static int luaD_protectedparser(lua_State*L,ZIO*z,const char*name){
struct SParser p;
int status;
p.z=z;p.name=name;
luaZ_initbuffer(L,&p.buff);
status=luaD_pcall(L,f_parser,&p,savestack(L,L->top),L->errfunc);
luaZ_freebuffer(L,&p.buff);
return status;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
subq %rax, %rcx
movq 0x40(%rsp), %rax
movq 0xb0(%rax), %r8
leaq 0x19a(%rip), %rsi       # 0x11cf0
leaq 0x8(%rsp), %rdx
callq 0x11ba0
movl %eax, 0x4(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
shlq $0x0, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4b30
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl 0x4(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movw 0x60(%rax), %ax
movw %ax, 0x2a(%rsp)
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x50(%rsp), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movb 0x65(%rax), %al
movb %al, 0x1f(%rsp)
movq 0x50(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0xb0(%rax)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x4250
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x11cd1
movq 0x50(%rsp), %rax
movq 0x40(%rax), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4d10
movq 0x50(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x4e30
movw 0x2a(%rsp), %cx
movq 0x50(%rsp), %rax
movw %cx, 0x60(%rax)
movq 0x50(%rsp), %rax
movq 0x50(%rax), %rcx
addq 0x20(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x30(%rax)
movb 0x1f(%rsp), %cl
movq 0x50(%rsp), %rax
movb %cl, 0x65(%rax)
movq 0x50(%rsp), %rdi
callq 0x4f40
movq 0x10(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0xb0(%rax)
movl 0x2c(%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: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x70(%rcx), %rax
jb 0x11d2e
movq 0x30(%rsp), %rdi
callq 0xa270
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
addq $0x8, %rdx
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
callq 0x11e30
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movzbl 0x70(%rax), %esi
movq 0x30(%rsp), %rax
movq 0x78(%rax), %rdx
callq 0xb730
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x18(%rsp), %rcx
movzbl 0x70(%rcx), %ecx
cmpl %ecx, %eax
jge 0x11dc8
movq 0x30(%rsp), %rdi
callq 0x11f40
movq %rax, %rdx
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq %rdx, 0x28(%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x11d8e
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0x6, 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 0x11e18
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x61d0
jmp 0x11e1a
jmp 0x11e1a
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaY_parser
static Proto*luaY_parser(lua_State*L,ZIO*z,Mbuffer*buff,const char*name){
struct LexState lexstate;
struct FuncState funcstate;
lexstate.buff=buff;
luaX_setinput(L,&lexstate,z,luaS_new(L,name));
open_func(&lexstate,&funcstate);
funcstate.f->is_vararg=2;
luaX_next(&lexstate);
chunk(&lexstate);
check(&lexstate,TK_EOS);
close_func(&lexstate);
return funcstate.f;
}

// Assembly:
subq $0x2f8, %rsp            # imm = 0x2F8
movq %rdi, 0x2f0(%rsp)
movq %rsi, 0x2e8(%rsp)
movq %rdx, 0x2e0(%rsp)
movq %rcx, 0x2d8(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2c0(%rsp)
movq 0x2f0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x2f0(%rsp), %rax
movq %rax, (%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x2d8(%rsp), %rdi
callq 0x30f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x49c0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
leaq 0x278(%rsp), %rsi
callq 0x11fb0
leaq 0x278(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x120e0
movq 0x20(%rsp), %rax
movb $0x2, 0x72(%rax)
leaq 0x278(%rsp), %rdi
callq 0x122d0
leaq 0x278(%rsp), %rdi
callq 0x12340
leaq 0x278(%rsp), %rdi
movl $0x11f, %esi            # imm = 0x11F
callq 0x123e0
leaq 0x278(%rsp), %rdi
callq 0x12410
movq 0x20(%rsp), %rax
addq $0x2f8, %rsp            # imm = 0x2F8
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaF_newupval
static UpVal*luaF_newupval(lua_State*L){
UpVal*uv=luaM_new(L,UpVal);
luaC_link(L,obj2gco(uv),(8+2));
uv->v=&uv->u.value;
setnilvalue(uv->v);
return uv;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x28, %ecx
movq %rdx, %rsi
callq 0x4b30
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0xd320
movq 0x8(%rsp), %rcx
addq $0x18, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaX_setinput
static void luaX_setinput(lua_State*L,LexState*ls,ZIO*z,TString*source){
ls->decpoint='.';
ls->L=L;
ls->lookahead.token=TK_EOS;
ls->z=z;
ls->fs=NULL;
ls->linenumber=1;
ls->lastline=1;
ls->source=source;
luaZ_resizebuffer(ls->L,ls->buff,32);
next(ls);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movb $0x2e, 0x58(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rax
movl $0x11f, 0x20(%rax)      # imm = 0x11F
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x18(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x18(%rsp), %rax
movl $0x1, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
movl $0x20, %ecx
callq 0x4b30
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq $0x20, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x120b9
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x120cb
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12790
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x12830
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x30(%rax)
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x34(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movl $0x0, 0x3c(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x40(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x44(%rax)
movq 0x28(%rsp), %rax
movw $0x0, 0x48(%rax)
movq 0x28(%rsp), %rax
movb $0x0, 0x4a(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x18(%rsp), %rax
movb $0x2, 0x73(%rax)
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4620
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x5, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jg 0x12249
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x61d0
jmp 0x1224b
jmp 0x1224b
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x9, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jg 0x122af
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x61d0
jmp 0x122b1
jmp 0x122b1
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x4(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
cmpl $0x11f, 0x20(%rax)      # imm = 0x11F
je 0x12315
movq (%rsp), %rax
movq (%rsp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movl $0x11f, 0x20(%rax)      # imm = 0x11F
jmp 0x12333
movq (%rsp), %rdi
movq (%rsp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
callq 0x12960
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: chunk
static void chunk(LexState*ls){
int islast=0;
enterlevel(ls);
while(!islast&&!block_follow(ls->t.token)){
islast=statement(ls);
testnext(ls,';');
ls->fs->freereg=ls->fs->nactvar;
}
leavelevel(ls);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x145b0
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0xb(%rsp)
jne 0x12381
movq 0x10(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x145f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x1238b
jmp 0x123c3
movq 0x10(%rsp), %rdi
callq 0x14640
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3b, %esi
callq 0x147e0
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movzbl 0x4a(%rax), %ecx
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movl %ecx, 0x3c(%rax)
jmp 0x1235b
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movw 0x60(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x60(%rax)
addq $0x18, %rsp
retq
nopl (%rax)