LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_pushcclosure
static void lua_pushcclosure(lua_State*L,lua_CFunction fn,int n){
Closure*cl;
luaC_checkGC(L);
api_checknelems(L,n);
cl=luaF_newCclosure(L,n,getcurrenv(L));
cl->c.f=fn;
L->top-=n;
while(n--)
setobj(L,&cl->c.upvalue[n],L->top+n);
setclvalue(L,L->top,cl);
api_incr_top(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x9073
movq %rbx, %rdi
callq 0x6bbf
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x908a
movq 0x8(%rax), %rax
movq (%rax), %rax
addq $0x18, %rax
jmp 0x908e
leaq 0x78(%rbx), %rax
movq (%rax), %r15
movl %ebp, %ecx
shll $0x4, %ecx
addl $0x28, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x43d1
movq 0x20(%rbx), %rcx
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x28(%rcx)
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0x6, 0x8(%rax)
movb $0x1, 0xa(%rax)
movq %r15, 0x18(%rax)
movb %bpl, 0xb(%rax)
movq %r14, 0x20(%rax)
movq 0x10(%rbx), %rcx
movl %ebp, %edx
shlq $0x4, %rdx
subq %rdx, %rcx
movq %rcx, 0x10(%rbx)
testl %ebp, %ebp
je 0x9113
movslq %ebp, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
movq 0x10(%rbx), %rsi
movq -0x10(%rsi,%rdx), %rdi
movq %rdi, 0x18(%rax,%rdx)
movl -0x8(%rsi,%rdx), %esi
movl %esi, 0x20(%rax,%rdx)
addq $-0x10, %rdx
decq %rcx
jne 0x90f0
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x6, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaopen_io
static int luaopen_io(lua_State*L){
createmeta(L);
newfenv(L,io_fclose);
lua_replace(L,(-10001));
luaL_register(L,"io",iolib);
newfenv(L,io_noclose);
createstdfile(L,stdin,1,"stdin");
createstdfile(L,stdout,2,"stdout");
createstdfile(L,stderr,0,"stderr");
lua_pop(L,1);
lua_getfield(L,-1,"popen");
newfenv(L,io_pclose);
lua_setfenv(L,-2);
lua_pop(L,1);
return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xcd29(%rip), %rdx      # 0x15fb1
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x114a3
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
leaq 0xc1f7(%rip), %rdx      # 0x15498
cmpq %rdx, %rcx
je 0x92e8
cmpl $0x0, -0x8(%rax)
jne 0x92e8
movq %rcx, 0x10(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x38a5
movq 0x10(%rbx), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
leaq 0xccda(%rip), %rdx      # 0x15fb1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x39af
movq 0x10(%rbx), %rax
movq -0x10(%rax), %rcx
movq %rcx, (%rax)
movl -0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
leaq 0xc511(%rip), %rdx      # 0x15812
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x39af
leaq 0x1295b(%rip), %rdx     # 0x1bc70
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3780
leaq 0x7fc3(%rip), %rsi      # 0x112e9
movq %rbx, %rdi
callq 0x112ad
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x11320
leaq 0xc5e2(%rip), %rsi      # 0x15924
leaq 0x12887(%rip), %rdx     # 0x1bbd0
movq %rbx, %rdi
callq 0x3780
leaq 0x80a4(%rip), %rsi      # 0x113fc
movq %rbx, %rdi
callq 0x112ad
movq 0x12c71(%rip), %rax     # 0x1bfd8
movq (%rax), %rsi
leaq 0xcf86(%rip), %rcx      # 0x162f7
movq %rbx, %rdi
movl $0x1, %edx
callq 0x11428
movq 0x12c4b(%rip), %rax     # 0x1bfd0
movq (%rax), %rsi
leaq 0xcc0e(%rip), %rcx      # 0x15f9d
movq %rbx, %rdi
movl $0x2, %edx
callq 0x11428
movq 0x12c55(%rip), %rax     # 0x1bff8
movq (%rax), %rsi
leaq 0xcbf7(%rip), %rcx      # 0x15fa4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11428
addq $-0x10, 0x10(%rbx)
leaq 0xcbe8(%rip), %rdx      # 0x15fab
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x114a3
leaq 0x8124(%rip), %rsi      # 0x114fb
movq %rbx, %rdi
callq 0x112ad
movq %rbx, %rdi
callq 0x104be
addq $-0x10, 0x10(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: ipairsaux
static int ipairsaux(lua_State*L){
int i=luaL_checkint(L,2);
luaL_checktype(L,1,5);
i++;
lua_pushinteger(L,i);
lua_rawgeti(L,1,i);
return(lua_isnil(L,-1))?0:2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x2, %ebx
movl $0x2, %esi
callq 0xb0cc
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
incl %r15d
movq 0x10(%r14), %rax
cvtsi2sd %r15d, %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x106bf
movq 0x10(%r14), %rax
leaq -0x10(%rax), %rcx
leaq 0xbe6c(%rip), %rdx      # 0x15498
cmpq %rdx, %rcx
je 0x963c
xorl %ebx, %ebx
cmpl $0x0, -0x8(%rax)
setne %bl
addl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_pairs
static int luaB_pairs(lua_State*L){
luaL_checktype(L,1,5);
lua_pushvalue(L,lua_upvalueindex(1));
lua_pushvalue(L,1);
lua_pushnil(L);
return 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
cmpb $0x0, 0xb(%rcx)
leaq 0x28(%rcx), %rcx
leaq 0xbe23(%rip), %rdx      # 0x15498
cmoveq %rdx, %rcx
movq (%rcx), %rsi
movq %rsi, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
leaq 0x10(%rax), %rsi
movq %rsi, 0x10(%rbx)
cmpq %rsi, %rcx
cmovbq %rcx, %rdx
movq (%rdx), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%rdx), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rbx), %rax
movl $0x0, 0x18(%rax)
addq $0x20, %rax
movq %rax, 0x10(%rbx)
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_setmetatable
static int lua_setmetatable(lua_State*L,int objindex){
TValue*obj;
Table*mt;
api_checknelems(L,1);
obj=index2adr(L,objindex);
api_checkvalidindex(L,obj);
if(ttisnil(L->top-1))
mt=NULL;
else{
luai_apicheck(L,ttistable(L->top-1));
mt=hvalue(L->top-1);
}
switch(ttype(obj)){
case 5:{
hvalue(obj)->metatable=mt;
if(mt)
luaC_objbarriert(L,hvalue(obj),mt);
break;
}
case 7:{
uvalue(obj)->metatable=mt;
if(mt)
luaC_objbarrier(L,rawuvalue(obj),mt);
break;
}
default:{
G(L)->mt[ttype(obj)]=mt;
break;
}
}
L->top--;
return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x9d4e
movq 0x10(%rbx), %rcx
cmpl $0x0, -0x8(%rcx)
je 0x99e8
movq -0x10(%rcx), %rsi
jmp 0x99ea
xorl %esi, %esi
movslq 0x8(%rax), %rcx
cmpq $0x7, %rcx
je 0x9a2e
cmpl $0x5, %ecx
jne 0x9a5c
movq (%rax), %rcx
movq %rsi, 0x10(%rcx)
testq %rsi, %rsi
je 0x9a68
testb $0x3, 0x9(%rsi)
je 0x9a68
movq (%rax), %rax
movb 0x9(%rax), %cl
testb $0x4, %cl
je 0x9a68
movq 0x20(%rbx), %rdx
andb $-0x5, %cl
movb %cl, 0x9(%rax)
movq 0x40(%rdx), %rcx
movq %rcx, 0x30(%rax)
movq %rax, 0x40(%rdx)
jmp 0x9a68
movq (%rax), %rcx
movq %rsi, 0x10(%rcx)
testq %rsi, %rsi
je 0x9a68
testb $0x3, 0x9(%rsi)
je 0x9a68
movq (%rax), %rax
movb 0x9(%rax), %cl
testb $0x4, %cl
je 0x9a68
movq 0x20(%rbx), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x9a6f
callq 0x46ab
jmp 0x9a68
movq 0x20(%rbx), %rax
movq %rsi, 0xe0(%rax,%rcx,8)
addq $-0x10, 0x10(%rbx)
popq %rbx
retq
andb $-0x8, %cl
movb 0x20(%rdi), %dl
andb $0x3, %dl
orb %cl, %dl
movb %dl, 0x9(%rax)
jmp 0x9a68
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: index2adr
static TValue*index2adr(lua_State*L,int idx){
if(idx>0){
TValue*o=L->base+(idx-1);
luai_apicheck(L,idx<=L->ci->top-L->base);
if(o>=L->top)return cast(TValue*,(&luaO_nilobject_));
else return o;
}
else if(idx>(-10000)){
luai_apicheck(L,idx!=0&&-idx<=L->top-L->base);
return L->top+idx;
}
else switch(idx){
case(-10000):return registry(L);
case(-10001):{
Closure*func=curr_func(L);
sethvalue(L,&L->env,func->c.env);
return&L->env;
}
case(-10002):return gt(L);
default:{
Closure*func=curr_func(L);
idx=(-10002)-idx;
return(idx<=func->c.nupvalues)
?&func->c.upvalue[idx-1]
:cast(TValue*,(&luaO_nilobject_));
}
}
}

// Assembly:
testl %esi, %esi
jle 0x9d73
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x4, %rcx
addq %rax, %rcx
addq $-0x10, %rcx
cmpq 0x10(%rdi), %rcx
leaq 0xb72a(%rip), %rax      # 0x15498
cmovbq %rcx, %rax
retq
cmpl $0xffffd8f1, %esi       # imm = 0xFFFFD8F1
jl 0x9d87
movslq %esi, %rax
shlq $0x4, %rax
addq 0x10(%rdi), %rax
retq
cmpl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
je 0x9dd1
cmpl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
je 0x9da9
cmpl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
jne 0x9dd9
movl $0xa0, %eax
addq 0x20(%rdi), %rax
retq
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
leaq 0x88(%rdi), %rax
movq 0x18(%rcx), %rcx
movq %rcx, 0x88(%rdi)
movl $0x5, 0x90(%rdi)
retq
addq $0x78, %rdi
movq %rdi, %rax
retq
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl $0xffffd8ee, %ecx       # imm = 0xFFFFD8EE
subl %esi, %ecx
movzbl 0xb(%rax), %edx
movl $0xffffd8ed, %edi       # imm = 0xFFFFD8ED
subl %esi, %edi
shlq $0x4, %rdi
cmpl %edx, %ecx
leaq 0x28(%rax,%rdi), %rcx
leaq 0xb690(%rip), %rax      # 0x15498
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_assert
static int luaB_assert(lua_State*L){
luaL_checkany(L,1);
if(!lua_toboolean(L,1))
return luaL_error(L,"%s",luaL_optstring(L,2,"assertion failed!"));
return lua_gettop(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0xa907
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpq %rax, %rcx
leaq 0xb66b(%rip), %rdx      # 0x15498
cmovbq %rcx, %rdx
movl 0x8(%rdx), %esi
cmpl $0x1, %esi
je 0x9e46
testl %esi, %esi
je 0x9e4b
subq %rcx, %rax
shrq $0x4, %rax
popq %rbx
retq
cmpl $0x0, (%rdx)
jne 0x9e3d
leaq 0xbb4f(%rip), %rdx      # 0x159a1
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0xaa03
leaq 0xb807(%rip), %rsi      # 0x1566f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_error
static int luaB_error(lua_State*L){
int level=luaL_optint(L,2,1);
lua_settop(L,1);
if(lua_isstring(L,1)&&level>0){
luaL_where(L,level);
lua_pushvalue(L,1);
lua_concat(L,2);
}
return lua_error(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edx
movl $0x2, %esi
callq 0xb093
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x10(%rcx), %rsi
cmpq %rsi, %rdx
jae 0x9fb2
xorl %edi, %edi
movq %rcx, %r8
subq %rdx, %r8
cmovbq %rdi, %r8
addq $0xf, %r8
movq %r8, %xmm0
shrq $0x4, %r8
addq $0x4, %r8
andq $-0x4, %r8
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
addq $0x38, %rdx
movdqa 0xb139(%rip), %xmm1     # 0x15010
movdqa 0xb141(%rip), %xmm2     # 0x15020
movdqa 0xb149(%rip), %xmm3     # 0x15030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r9d
notl %r9d
testb $0x1, %r9b
je 0x9f3b
movl $0x0, -0x30(%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %r9d
testb $0x1, %r9b
je 0x9f52
movl $0x0, -0x20(%rdx)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %r9d
testb $0x1, %r9b
je 0x9f8f
movl $0x0, -0x10(%rdx)
pextrw $0x4, %xmm5, %r9d
testb $0x1, %r9b
je 0x9fa1
movl $0x0, (%rdx)
addq $0x4, %rdi
addq $0x40, %rdx
cmpq %rdi, %r8
jne 0x9eef
movq %rsi, 0x10(%rbx)
leaq 0xb4db(%rip), %r14      # 0x15498
cmpq %r14, %rcx
je 0xa012
movl 0x8(%rcx), %ecx
addl $-0x3, %ecx
cmpl $0x2, %ecx
setb %cl
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xa012
movq %rbx, %rdi
movl %eax, %esi
callq 0xae7b
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpq %rax, %rcx
cmovbq %rcx, %r14
movq (%r14), %rcx
movq %rcx, (%rax)
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x2, %esi
callq 0xaedf
movq %rbx, %rdi
callq 0x4bb1
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %ebp
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0xb00c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xaa03
movq (%r14), %rcx
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movq %rcx, 0x8(%rdx)
leaq 0x1176(%rip), %rsi      # 0xb233
movq %rbx, %rdi
movq %rax, %rcx
callq 0xb1a8
testl %eax, %eax
je 0xa0f1
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xb16b
movl $0x2, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: 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:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0xa907
movq 0x10(%rbx), %rsi
subq 0x18(%rbx), %rsi
shrq $0x4, %rsi
decl %esi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3d39
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq 0x10(%rbx), %rax
movl %ecx, (%rax)
movl $0x1, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xb16b
movq 0x10(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x4, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
movq %rbx, %rdi
movl $0x2, %esi
callq 0xa907
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %r14
leaq 0x20(%r14), %rcx
cmpq %rcx, %rax
jae 0xa2a6
leaq 0x10(%rax), %rsi
cmpq %rsi, %rcx
cmovaq %rcx, %rsi
movq %rax, %rdx
notq %rdx
addq %rsi, %rdx
movq %rdx, %xmm0
shrq $0x4, %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
addq $0x38, %rax
xorl %esi, %esi
movdqa 0xae40(%rip), %xmm1     # 0x15010
movdqa 0xae48(%rip), %xmm2     # 0x15020
movdqa 0xae50(%rip), %xmm3     # 0x15030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0xa232
movl $0x0, -0x30(%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xa248
movl $0x0, -0x20(%rax)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0xa284
movl $0x0, -0x10(%rax)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0xa295
movl $0x0, (%rax)
addq $0x4, %rsi
addq $0x40, %rax
cmpq %rsi, %rdx
jne 0xa1e8
movq %rcx, 0x10(%rbx)
movq (%r14), %rdi
leaq 0x10(%r14), %rsi
callq 0x7876
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
movl 0x8(%rax), %eax
movl %eax, 0x18(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_setfenv
static int luaB_setfenv(lua_State*L){
luaL_checktype(L,2,5);
getfunc(L,0);
lua_pushvalue(L,2);
if(lua_isnumber(L,1)&&lua_tonumber(L,1)==0){
lua_pushthread(L);
lua_insert(L,-2);
lua_setfenv(L,-2);
return 0;
}
else if(lua_iscfunction(L,-2)||lua_setfenv(L,-2)==0)
luaL_error(L,
LUA_QL("setfenv")" cannot change environment of given object");
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl $0x2, %esi
movl $0x5, %edx
callq 0x1043a
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpq %rax, %rcx
setae %dl
leaq 0xb194(%rip), %r15      # 0x15498
cmpq %r15, %rcx
sete %sil
orb %dl, %sil
jne 0xa330
cmpl $0x6, 0x8(%rcx)
jne 0xa330
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
jmp 0xa38c
movq %rbx, %rdi
movl $0x1, %esi
callq 0xb0cc
movq %rax, %r14
testl %r14d, %r14d
js 0xa448
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0xab1c
testl %eax, %eax
je 0xa451
leaq 0xbf7b(%rip), %rsi      # 0x162e3
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xab6a
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r15, %rcx
je 0xa38c
cmpl $0x0, -0x8(%rax)
je 0xa465
movq 0x18(%rbx), %rcx
addq $0x10, %rcx
cmpq %rax, %rcx
cmovbq %rcx, %r15
movq (%r15), %rcx
movq %rcx, (%rax)
movl 0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xb13a
testl %eax, %eax
je 0xa403
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1048f
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa403
jp 0xa403
movq 0x10(%rbx), %rax
movq %rbx, (%rax)
movl $0x8, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xb16b
movq %rbx, %rdi
callq 0x104be
xorl %eax, %eax
jmp 0xa42a
movq 0x10(%rbx), %rax
cmpl $0x6, -0x18(%rax)
jne 0xa417
movq -0x20(%rax), %rax
cmpb $0x0, 0xa(%rax)
jne 0xa437
movq %rbx, %rdi
callq 0x104be
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0xa437
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb988(%rip), %rsi      # 0x15dc6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa940
leaq 0xb9ab(%rip), %rdx      # 0x15dfa
jmp 0xa458
leaq 0xb9bd(%rip), %rdx      # 0x15e15
movq %rbx, %rdi
movl $0x1, %esi
callq 0xaa6a
leaq 0xb9b7(%rip), %rsi      # 0x15e23
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_setmetatable
static int luaB_setmetatable(lua_State*L){
int t=lua_type(L,2);
luaL_checktype(L,1,5);
luaL_argcheck(L,t==0||t==5,2,
"nil or table expected");
if(luaL_getmetafield(L,1,"__metatable"))
luaL_error(L,"cannot change a protected metatable");
lua_settop(L,2);
lua_setmetatable(L,1);
return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq 0x10(%rax), %rcx
cmpq 0x10(%rdi), %rcx
jae 0xa68e
leaq 0xaffc(%rip), %r14      # 0x15498
cmpq %r14, %rcx
je 0xa68e
movl 0x18(%rax), %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
testl %ebp, %ebp
je 0xa4c7
cmpl $0x5, %ebp
jne 0xa6a0
movq %rbx, %rdi
callq 0x1054c
testl %eax, %eax
je 0xa527
leaq 0xb991(%rip), %rsi      # 0x15e6b
movl $0xb, %edx
movq %rbx, %rdi
callq 0x94a5
movq 0x10(%rbx), %r15
movq -0x20(%r15), %rdi
leaq -0x10(%r15), %rsi
callq 0x7876
movq (%rax), %rcx
movq %rcx, -0x10(%r15)
movl 0x8(%rax), %eax
movl %eax, -0x8(%r15)
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r14, %rcx
je 0xa670
cmpl $0x0, -0x8(%rax)
jne 0xa670
addq $-0x20, %rax
jmp 0xa52b
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jae 0xa64f
leaq 0x10(%rax), %rsi
cmpq %rsi, %rcx
cmovaq %rcx, %rsi
movq %rax, %rdx
notq %rdx
addq %rsi, %rdx
movq %rdx, %xmm0
shrq $0x4, %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
addq $0x38, %rax
xorl %esi, %esi
movdqa 0xaa97(%rip), %xmm1     # 0x15010
movdqa 0xaa9f(%rip), %xmm2     # 0x15020
movdqa 0xaaa7(%rip), %xmm3     # 0x15030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0xa5db
movl $0x0, -0x30(%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xa5f1
movl $0x0, -0x20(%rax)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0xa62d
movl $0x0, -0x10(%rax)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0xa63e
movl $0x0, (%rax)
addq $0x4, %rsi
addq $0x40, %rax
cmpq %rsi, %rdx
jne 0xa591
movq %rcx, 0x10(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x99cf
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x105a9
leaq 0xb7f3(%rip), %rsi      # 0x15e77
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa940
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
leaq 0xb7ae(%rip), %rdx      # 0x15e55
movq %rbx, %rdi
movl $0x2, %esi
callq 0xaa6a
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_tonumber
static int luaB_tonumber(lua_State*L){
int base=luaL_optint(L,2,10);
if(base==10){
luaL_checkany(L,1);
if(lua_isnumber(L,1)){
lua_pushnumber(L,lua_tonumber(L,1));
return 1;
}
}
else{
const char*s1=luaL_checkstring(L,1);
char*s2;
unsigned long n;
luaL_argcheck(L,2<=base&&base<=36,2,"base out of range");
n=strtoul(s1,&s2,base);
if(s1!=s2){
while(isspace((unsigned char)(*s2)))s2++;
if(*s2=='\0'){
lua_pushnumber(L,(lua_Number)n);
return 1;
}
}
}
lua_pushnil(L);
return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %edx
movl $0x2, %esi
callq 0xb093
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0xa, %r14d
jne 0xa70f
callq 0xa907
movq %rbx, %rdi
movl $0x1, %esi
callq 0xb13a
testl %eax, %eax
je 0xa75e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1048f
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0xa79c
xorl %edx, %edx
callq 0xb00c
movq %rax, %r15
leal -0x2(%r14), %eax
cmpl $0x23, %eax
jae 0xa7b9
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x3260
movq (%r12), %r12
cmpq %r12, %r15
je 0xa75e
movq %rax, %r14
callq 0x32f0
movq (%rax), %rax
movzbl (%r12), %ecx
incq %r12
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xa74b
testb %cl, %cl
je 0xa773
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
jmp 0xa7a8
movq %r14, %xmm0
punpckldq 0xa8c0(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xa8c8(%rip), %xmm0     # 0x15050
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq 0x10(%rbx), %rax
movsd %xmm1, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xb6db(%rip), %rdx      # 0x15e9b
movq %rbx, %rdi
movl $0x2, %esi
callq 0xaa6a
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaB_unpack
static int luaB_unpack(lua_State*L){
int i,e,n;
luaL_checktype(L,1,5);
i=luaL_optint(L,2,1);
e=luaL_opt(L,luaL_checkint,3,luaL_getn(L,1));
if(i>e)return 0;
n=e-i+1;
if(n<=0||!lua_checkstack(L,n))
return luaL_error(L,"too many results to unpack");
lua_rawgeti(L,1,i);
while(i++<e)
lua_rawgeti(L,1,i);
return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1043a
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0xb093
movq %rax, %r14
movq 0x18(%rbx), %rax
leaq 0x20(%rax), %rcx
cmpq 0x10(%rbx), %rcx
setae %dl
leaq 0xac38(%rip), %rsi      # 0x15498
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0xa87f
cmpl $0x0, 0x28(%rax)
jle 0xa87f
movq %rbx, %rdi
movl $0x3, %esi
callq 0xb0cc
jmp 0xa88c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x105d8
movq %rax, %r15
xorl %eax, %eax
movl %r15d, %ebp
subl %r14d, %ebp
jl 0xa8eb
js 0xa8f6
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1063b
testl %eax, %eax
je 0xa8f6
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x106bf
cmpl %r14d, %r15d
jle 0xa8e9
negl %r15d
incl %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x106bf
leal (%r15,%r14), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0xa8c6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb5b0(%rip), %rsi      # 0x15ead
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaL_error
static int luaL_error(lua_State*L,const char*fmt,...){
va_list argp;
va_start(argp,fmt);
luaL_where(L,1);
lua_pushvfstring(L,fmt,argp);
va_end(argp);
lua_concat(L,2);
return lua_error(L);
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x28(%rdi), %rax
subq 0x50(%rdi), %rax
jbe 0xaada
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
movq %rsp, %r15
movl %eax, 0x74(%r15)
leaq 0xac41(%rip), %rsi      # 0x156df
movq %r14, %rdi
movq %r15, %rdx
callq 0xab6a
movq 0x10(%r15), %rdi
leaq 0xaf24(%rip), %rsi      # 0x159d8
callq 0x3170
testl %eax, %eax
jne 0xaaf0
decl %ebp
jne 0xaaf0
movq 0x8(%rsp), %rdx
leaq 0xaf12(%rip), %rsi      # 0x159df
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xa940
leaq 0xaee1(%rip), %rsi      # 0x159c2
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xa940
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
jne 0xab06
leaq 0xaefc(%rip), %rcx      # 0x159fd
movq %rcx, 0x8(%rsp)
leaq 0xaef2(%rip), %rsi      # 0x159ff
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0xa940
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_getstack
static int lua_getstack(lua_State*L,int level,lua_Debug*ar){
int status;
CallInfo*ci;
for(ci=L->ci;level>0&&ci>L->base_ci;ci--){
level--;
if(f_isLua(ci))
level-=ci->tailcalls;
}
if(level==0&&ci>L->base_ci){
status=1;
ar->i_ci=cast_int(ci-L->base_ci);
}
else if(level<0){
status=1;
ar->i_ci=0;
}
else status=0;
return status;
}

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
callq 0xab1c
testl %eax, %eax
je 0xaec6
leaq 0xaba7(%rip), %rsi      # 0x15a3f
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xab6a
movl 0x28(%r14), %ecx
testl %ecx, %ecx
jle 0xaec6
leaq 0x38(%rsp), %rdx
leaq 0xab88(%rip), %rsi      # 0x15a42
movq %rbx, %rdi
xorl %eax, %eax
callq 0xaf5c
jmp 0xaed7
leaq 0xaa56(%rip), %rsi      # 0x15923
movq %rbx, %rdi
xorl %edx, %edx
callq 0x94a5
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_concat
static void lua_concat(lua_State*L,int n){
api_checknelems(L,n);
if(n>=2){
luaC_checkGC(L);
luaV_concat(L,n,cast_int(L->top-L->base)-1);
L->top-=(n-1);
}
else if(n==0){
setsvalue(L,L->top,luaS_newlstr(L,"",0));
api_incr_top(L);
}
}

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

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

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0xb326
movq %rbx, %rdi
callq 0x6bbf
movq (%r14), %r15
movq 0x20(%r14), %r12
leaq 0x8(%r14), %rax
movq %rax, 0x48(%rsp)
movq %r12, %rdi
callq 0x30e0
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4265
movb $0x2e, 0x58(%rsp)
movq %rbx, 0x38(%rsp)
movl $0x11f, 0x20(%rsp)      # imm = 0x11F
movq %r15, 0x40(%rsp)
movq $0x0, 0x30(%rsp)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x4(%rsp)
movq %rax, 0x50(%rsp)
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rdx
movl $0x20, %ecx
movq %rbx, %rdi
callq 0x43d1
movq %rax, 0x8(%r14)
movq $0x20, 0x18(%r14)
subq $0x1, (%r15)
jae 0xb3b1
movq %r15, %rdi
callq 0xc41c
jmp 0xb3c0
movq 0x8(%r15), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%r15)
movzbl (%rax), %eax
movq %rsp, %r14
movl %eax, (%r14)
leaq 0x60(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xb50c
movq (%r15), %rax
movb $0x2, 0x72(%rax)
movl 0x4(%r14), %eax
movl 0x20(%r14), %ecx
movl %eax, 0x8(%r14)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0xb407
leaq 0x18(%rsp), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xc46b
movl %eax, 0x10(%r14)
jmp 0xb419
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, -0x10(%rax)
movl $0x11f, (%rax)          # imm = 0x11F
movq %rsp, %r14
movq %r14, %rdi
callq 0xb65d
cmpl $0x11f, 0x10(%r14)      # imm = 0x11F
jne 0xb4ff
movq %rsp, %rdi
callq 0xc23a
movq 0x60(%rsp), %r15
movzbl 0x70(%r15), %esi
movq 0x78(%rbx), %rdx
movq %rbx, %rdi
callq 0x77ef
movq %rax, %r14
movq %r15, 0x20(%rax)
cmpb $0x0, 0x70(%r15)
je 0xb4af
xorl %r12d, %r12d
movl $0x28, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x43d1
movq 0x20(%rbx), %rcx
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x28(%rcx)
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0xa, 0x8(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x28(%r14,%r12,8)
incq %r12
movzbl 0x70(%r15), %eax
cmpq %rax, %r12
jb 0xb461
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movl $0x6, 0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0xb4e8
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
leal (%rax,%rax), %esi
testl %eax, %eax
cmovlel %ecx, %esi
movq %rbx, %rdi
callq 0x50e7
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdi
movl $0x11f, %esi            # imm = 0x11F
callq 0xfef5
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: open_func
static void open_func(LexState*ls,FuncState*fs){
lua_State*L=ls->L;
Proto*f=luaF_newproto(L);
fs->f=f;
fs->prev=ls->fs;
fs->ls=ls;
fs->L=L;
ls->fs=fs;
fs->pc=0;
fs->lasttarget=-1;
fs->jpc=(-1);
fs->freereg=0;
fs->nk=0;
fs->np=0;
fs->nlocvars=0;
fs->nactvar=0;
fs->bl=NULL;
f->source=ls->source;
f->maxstacksize=2;
fs->h=luaH_new(L,0,0);
sethvalue(L,L->top,fs->h);
incr_top(L);
setptvalue(L,L->top,f);
incr_top(L);
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %rbx
movq (%r15), %r12
movzbl 0x4a(%r15), %eax
testq %rax, %rax
je 0xc27d
movl 0x30(%r15), %ecx
movq 0x30(%r12), %rdx
movzwl 0xc2(%r15,%rax,2), %esi
shll $0x4, %esi
movl %ecx, 0xc(%rdx,%rsi)
decq %rax
jne 0xc263
movb $0x0, 0x4a(%r15)
movq 0x18(%r15), %rax
movl 0x8(%rax), %edx
movq %r15, %rdi
movl $0x80001e, %esi         # imm = 0x80001E
callq 0xe291
movslq 0x30(%r15), %rcx
cmpq $-0x1, %rcx
jl 0xc40b
movq 0x18(%r12), %rsi
movslq 0x50(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0x43d1
movq %rax, 0x18(%r12)
movslq 0x30(%r15), %rcx
movl %ecx, 0x50(%r12)
cmpq $-0x2, %rcx
jle 0xc40b
movq 0x28(%r12), %rsi
movslq 0x54(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0x43d1
movq %rax, 0x28(%r12)
movl 0x30(%r15), %eax
movl %eax, 0x54(%r12)
movslq 0x40(%r15), %rcx
cmpq $-0x2, %rcx
jle 0xc40b
movq 0x10(%r12), %rsi
movslq 0x4c(%r12), %rdx
shlq $0x4, %rdx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x43d1
movq %rax, 0x10(%r12)
movl 0x40(%r15), %eax
movl %eax, 0x4c(%r12)
movslq 0x44(%r15), %rcx
cmpq $-0x2, %rcx
jle 0xc40b
movq 0x20(%r12), %rsi
movslq 0x58(%r12), %rdx
shlq $0x3, %rdx
shlq $0x3, %rcx
movq %rbx, %rdi
callq 0x43d1
movq %rax, 0x20(%r12)
movl 0x44(%r15), %eax
movl %eax, 0x58(%r12)
movswq 0x48(%r15), %rcx
leaq 0x1(%rcx), %rax
shrq $0x3c, %rax
jne 0xc40b
movq 0x30(%r12), %rsi
movslq 0x5c(%r12), %rdx
shlq $0x4, %rdx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x43d1
movq %rax, 0x30(%r12)
movswl 0x48(%r15), %eax
movl %eax, 0x5c(%r12)
movzbl 0x70(%r12), %ecx
movq 0x38(%r12), %rsi
movslq 0x48(%r12), %rdx
shlq $0x3, %rdx
shll $0x3, %ecx
movq %rbx, %rdi
callq 0x43d1
movq %rax, 0x38(%r12)
movzbl 0x70(%r12), %eax
movl %eax, 0x48(%r12)
movq 0x10(%r15), %rax
movq %rax, 0x30(%r14)
movl $0xfffffee3, %eax       # imm = 0xFFFFFEE3
addl 0x10(%r14), %eax
cmpl $0x2, %eax
jae 0xc3fa
movq 0x18(%r14), %rsi
movq 0x10(%rsi), %rdx
addq $0x18, %rsi
movq %r14, %rdi
callq 0xd0f1
addq $-0x20, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x922f(%rip), %rsi      # 0x15641
movq %rbx, %rdi
xorl %eax, %eax
callq 0x47e0
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: inclinenumber
static void inclinenumber(LexState*ls){
int old=ls->current;
next(ls);
if(currIsNewline(ls)&&ls->current!=old)
next(ls);
if(++ls->linenumber>=(INT_MAX-2))
luaX_syntaxerror(ls,"chunk has too many lines");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq 0x40(%rdi), %rdi
subq $0x1, (%rdi)
jae 0xcc1e
callq 0xc41c
jmp 0xcc2d
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0xcc39
cmpl $0xa, %eax
jne 0xcc5f
cmpl %ebp, %eax
je 0xcc5f
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0xcc4e
callq 0xc41c
jmp 0xcc5d
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
cmpl $0x7ffffffc, %eax       # imm = 0x7FFFFFFC
jge 0xcc76
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl 0x10(%rbx), %edx
leaq 0x8e05(%rip), %rsi      # 0x15a85
movq %rbx, %rdi
callq 0xce64
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: skip_sep
static int skip_sep(LexState*ls){
int count=0;
int s=ls->current;
save_and_next(ls);
while(ls->current=='='){
save_and_next(ls);
count++;
}
return(ls->current==s)?count:(-count)-1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl (%rdi), %ebx
movl %ebx, %esi
callq 0xcf03
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xcca9
callq 0xc41c
jmp 0xccb8
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
xorl %ebp, %ebp
cmpl $0x3d, %eax
jne 0xccfb
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x3d, %esi
callq 0xcf03
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0xcce2
callq 0xc41c
jmp 0xccf1
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
incl %ebp
cmpl $0x3d, %eax
je 0xccc4
xorl %ecx, %ecx
cmpl %ebx, %eax
setne %cl
negl %ecx
xorl %ebp, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq