LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lua_getfenv
static void lua_getfenv(lua_State*L,int idx){
StkId o;
o=index2adr(L,idx);
api_checkvalidindex(L,o);
switch(ttype(o)){
case 6:
sethvalue(L,L->top,clvalue(o)->c.env);
break;
case 7:
sethvalue(L,L->top,uvalue(o)->env);
break;
case 8:
setobj(L,L->top,gt(thvalue(o)));
break;
default:
setnilvalue(L->top);
break;
}
api_incr_top(L);
}

// 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 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x6, %eax
je 0x1c82c
jmp 0x1c813
movl 0xc(%rsp), %eax
subl $0x7, %eax
je 0x1c85f
jmp 0x1c81e
movl 0xc(%rsp), %eax
subl $0x8, %eax
je 0x1c88f
jmp 0x1c8d0
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movl $0x5, 0x8(%rax)
jmp 0x1c8e0
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movl $0x5, 0x8(%rax)
jmp 0x1c8e0
movq 0x30(%rsp), %rax
movq (%rax), %rax
addq $0x78, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x1c8e0
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: pushresult
static int pushresult(lua_State*L,int i,const char*filename){
int en=errno;
if(i){
lua_pushboolean(L,1);
return 1;
}
else{
lua_pushnil(L);
if(filename)
lua_pushfstring(L,"%s: %s",filename,strerror(en));
else
lua_pushfstring(L,"%s",strerror(en));
lua_pushinteger(L,en);
return 3;
}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
callq 0x3040
movl (%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x1c9a0
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x1a180
movl $0x1, 0x44(%rsp)
jmp 0x1ca2c
movq 0x38(%rsp), %rdi
callq 0x11870
cmpq $0x0, 0x28(%rsp)
je 0x1c9ec
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %edi
callq 0x32b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
leaq 0x6ae6(%rip), %rsi      # 0x234c9
movb $0x0, %al
callq 0x11350
jmp 0x1ca15
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %edi
callq 0x32b0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x5df1(%rip), %rsi      # 0x227ff
movb $0x0, %al
callq 0x11350
movq 0x38(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x1ab20
movl $0x3, 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: io_readline
static int io_readline(lua_State*L){
FILE*f=*(FILE**)lua_touserdata(L,lua_upvalueindex(1));
int sucess;
if(f==NULL)
luaL_error(L,"file is already closed");
sucess=read_line(L,f);
if(ferror(f))
return luaL_error(L,"%s",strerror(errno));
if(sucess)return 1;
else{
if(lua_toboolean(L,lua_upvalueindex(2))){
lua_settop(L,0);
lua_pushvalue(L,lua_upvalueindex(1));
aux_close(L);
}
return 0;
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x1c6e0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1cacb
movq 0x18(%rsp), %rdi
leaq 0x66d3(%rip), %rsi      # 0x23197
movb $0x0, %al
callq 0x10790
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1cb80
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x30a0
cmpl $0x0, %eax
je 0x1cb1d
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x3040
movl (%rax), %edi
callq 0x32b0
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x5cef(%rip), %rsi      # 0x227ff
movb $0x0, %al
callq 0x10790
movl %eax, 0x24(%rsp)
jmp 0x1cb6f
cmpl $0x0, 0xc(%rsp)
je 0x1cb2e
movl $0x1, 0x24(%rsp)
jmp 0x1cb6f
movq 0x18(%rsp), %rdi
movl $0xffffd8ec, %esi       # imm = 0xFFFFD8EC
callq 0x10720
cmpl $0x0, %eax
je 0x1cb67
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x11600
movq 0x18(%rsp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0xf7f0
movq 0x18(%rsp), %rdi
callq 0x1c5f0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: read_line
static int read_line(lua_State*L,FILE*f){
luaL_Buffer b;
luaL_buffinit(L,&b);
for(;;){
size_t l;
char*p=luaL_prepbuffer(&b);
if(fgets(p,BUFSIZ,f)==NULL){
luaL_pushresult(&b);
return(lua_objlen(L,-1)>0);
}
l=strlen(p);
if(l==0||p[l-1]!='\n')
luaL_addsize(&b,l);
else{
luaL_addsize(&b,l-1);
luaL_pushresult(&b);
return 1;
}
}
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2038(%rsp)
movq %rsi, 0x2030(%rsp)
movq 0x2038(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1b5c0
leaq 0x18(%rsp), %rdi
callq 0x1b990
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x2030(%rsp), %rdx
movl $0x2000, %esi           # imm = 0x2000
callq 0x3160
cmpq $0x0, %rax
jne 0x1cc06
leaq 0x18(%rsp), %rdi
callq 0x1b730
movq 0x2038(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1a8c0
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2044(%rsp)
jmp 0x1cc74
movq 0x8(%rsp), %rdi
callq 0x30f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1cc34
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x1cc45
movq 0x10(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x1cc6f
movq 0x10(%rsp), %rax
subq $0x1, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1b730
movl $0x1, 0x2044(%rsp)
jmp 0x1cc74
jmp 0x1cba9
movl 0x2044(%rsp), %eax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: test_eof
static int test_eof(lua_State*L,FILE*f){
int c=getc(f);
ungetc(c,f);
lua_pushlstring(L,NULL,0);
return(c!=EOF);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x32c0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x31f0
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xf860
cmpl $-0x1, 0x4(%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: read_chars
static int read_chars(lua_State*L,FILE*f,size_t n){
size_t rlen;
size_t nr;
luaL_Buffer b;
luaL_buffinit(L,&b);
rlen=BUFSIZ;
do{
char*p=luaL_prepbuffer(&b);
if(rlen>n)rlen=n;
nr=fread(p,sizeof(char),rlen,f);
luaL_addsize(&b,nr);
n-=nr;
}while(n>0&&nr==rlen);
luaL_pushresult(&b);
return(n==0||lua_objlen(L,-1)>0);
}

// Assembly:
subq $0x2058, %rsp           # imm = 0x2058
movq %rdi, 0x2050(%rsp)
movq %rsi, 0x2048(%rsp)
movq %rdx, 0x2040(%rsp)
movq 0x2050(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1b5c0
movq $0x2000, 0x2038(%rsp) # imm = 0x2000
leaq 0x18(%rsp), %rdi
callq 0x1b990
movq %rax, 0x10(%rsp)
movq 0x2038(%rsp), %rax
cmpq 0x2040(%rsp), %rax
jbe 0x1cfbe
movq 0x2040(%rsp), %rax
movq %rax, 0x2038(%rsp)
movq 0x10(%rsp), %rdi
movq 0x2038(%rsp), %rdx
movq 0x2048(%rsp), %rcx
movl $0x1, %esi
callq 0x30b0
movq %rax, 0x2030(%rsp)
movq 0x2030(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x2030(%rsp), %rcx
movq 0x2040(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x2040(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x2040(%rsp)
movb %al, 0xf(%rsp)
jbe 0x1d03a
movq 0x2030(%rsp), %rax
cmpq 0x2038(%rsp), %rax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1cf8d
leaq 0x18(%rsp), %rdi
callq 0x1b730
movb $0x1, %al
cmpq $0x0, 0x2040(%rsp)
movb %al, 0xe(%rsp)
je 0x1d07e
movq 0x2050(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1a8c0
cmpq $0x0, %rax
seta %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x2058, %rsp           # imm = 0x2058
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: read_number
static int read_number(lua_State*L,FILE*f){
lua_Number d;
if(fscanf(f,"%lf",&d)==1){
lua_pushnumber(L,d);
return 1;
}
else{
lua_pushnil(L);
return 0;
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x6135(%rip), %rsi      # 0x231df
leaq 0x8(%rsp), %rdx
movb $0x0, %al
callq 0x3080
cmpl $0x1, %eax
jne 0x1d0d5
movq 0x18(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1a870
movl $0x1, 0x24(%rsp)
jmp 0x1d0e7
movq 0x18(%rsp), %rdi
callq 0x11870
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: g_write
static int g_write(lua_State*L,FILE*f,int arg){
int nargs=lua_gettop(L)-1;
int status=1;
for(;nargs--;arg++){
if(lua_type(L,arg)==3){
status=status&&
fprintf(f,"%.14g",lua_tonumber(L,arg))>0;
}
else{
size_t l;
const char*s=luaL_checklstring(L,arg,&l);
status=status&&(fwrite(s,sizeof(char),l,f)==l);
}
}
return pushresult(L,status,NULL);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10910
subl $0x1, %eax
movl %eax, 0x30(%rsp)
movl $0x1, 0x2c(%rsp)
movl 0x30(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rsp)
cmpl $0x0, %eax
je 0x1d1fe
movq 0x40(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x10930
cmpl $0x3, %eax
jne 0x1d195
xorl %eax, %eax
cmpl $0x0, 0x2c(%rsp)
movb %al, 0x17(%rsp)
je 0x1d186
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x1a3e0
movq 0x8(%rsp), %rdi
leaq 0x56c4(%rip), %rsi      # 0x22839
movb $0x1, %al
callq 0x3190
cmpl $0x0, %eax
setg %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1d1ec
movq 0x40(%rsp), %rdi
movl 0x34(%rsp), %esi
leaq 0x20(%rsp), %rdx
callq 0x11450
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x2c(%rsp)
movb %al, 0x7(%rsp)
je 0x1d1df
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl $0x1, %esi
callq 0x32a0
cmpq 0x20(%rsp), %rax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1d1ee
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1d11b
movq 0x40(%rsp), %rdi
movl 0x2c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c960
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_lines
static int io_lines(lua_State*L){
if(lua_isnoneornil(L,1)){
lua_rawgeti(L,(-10001),1);
return f_lines(L);
}
else{
const char*filename=luaL_checkstring(L,1);
FILE**pf=newfile(L);
*pf=fopen(filename,"r");
if(*pf==NULL)
fileerror(L,1,filename);
aux_lines(L,lua_gettop(L),1);
return 1;
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x10930
cmpl $0x0, %eax
jg 0x1d2d4
movq 0x18(%rsp), %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x1, %edx
callq 0x1aaa0
movq 0x18(%rsp), %rdi
callq 0x1c4b0
movl %eax, 0x24(%rsp)
jmp 0x1d361
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1d6d0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x60d7(%rip), %rsi      # 0x233de
callq 0x3240
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1d336
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1d730
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x10910
movq (%rsp), %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x1ca40
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_open
static int io_open(lua_State*L){
const char*filename=luaL_checkstring(L,1);
const char*mode=luaL_optstring(L,2,"r");
FILE**pf=newfile(L);
*pf=fopen(filename,mode);
return(*pf==NULL)?pushresult(L,0,filename):1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x603c(%rip), %rdx      # 0x233de
xorl %eax, %eax
movl %eax, %ecx
callq 0x10880
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1d6d0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3240
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1d3fb
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
xorl %esi, %esi
callq 0x1c960
movl %eax, 0x4(%rsp)
jmp 0x1d406
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1d406
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: io_type
static int io_type(lua_State*L){
void*ud;
luaL_checkany(L,1);
ud=lua_touserdata(L,1);
lua_getfield(L,(-10000),"FILE*");
if(ud==NULL||!lua_getmetatable(L,1)||!lua_rawequal(L,-2,-1))
lua_pushnil(L);
else if(*((FILE**)ud)==NULL)
lua_pushliteral(L,"closed file");
else
lua_pushliteral(L,"file");
return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x106e0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x1c6e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x5cb3(%rip), %rdx      # 0x23160
callq 0x1c290
cmpq $0x0, 0x8(%rsp)
je 0x1d4e7
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x1a6f0
cmpl $0x0, %eax
je 0x1d4e7
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1c760
cmpl $0x0, %eax
jne 0x1d4f3
movq 0x10(%rsp), %rdi
callq 0x11870
jmp 0x1d52e
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1d516
movq 0x10(%rsp), %rdi
leaq 0x5c79(%rip), %rsi      # 0x23183
movl $0xb, %edx
callq 0xf860
jmp 0x1d52c
movq 0x10(%rsp), %rdi
leaq 0x5c68(%rip), %rsi      # 0x2318a
movl $0x4, %edx
callq 0xf860
jmp 0x1d52e
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getiofile
static FILE*getiofile(lua_State*L,int findex){
FILE*f;
lua_rawgeti(L,(-10001),findex);
f=*(FILE**)lua_touserdata(L,-1);
if(f==NULL)
luaL_error(L,"standard %s file is closed",fnames[findex-1]);
return f;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x1aaa0
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1c6e0
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1d5e5
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xb6fd(%rip), %rax      # 0x28cd0
movq (%rax,%rcx,8), %rdx
leaq 0x5c29(%rip), %rsi      # 0x23207
movb $0x0, %al
callq 0x10790
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: g_iofile
static int g_iofile(lua_State*L,int f,const char*mode){
if(!lua_isnoneornil(L,1)){
const char*filename=lua_tostring(L,1);
if(filename){
FILE**pf=newfile(L);
*pf=fopen(filename,mode);
if(*pf==NULL)
fileerror(L,1,filename);
}
else{
tofile(L);
lua_pushvalue(L,1);
}
lua_rawseti(L,(-10001),f);
}
lua_rawgeti(L,(-10001),f);
return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x10930
cmpl $0x0, %eax
jle 0x1d6ad
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3c60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1d681
movq 0x20(%rsp), %rdi
callq 0x1d6d0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3240
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1d67f
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1d730
jmp 0x1d69a
movq 0x20(%rsp), %rdi
callq 0x1c5a0
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xf7f0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x3720
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x1aaa0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: newfile
static FILE**newfile(lua_State*L){
FILE**pf=(FILE**)lua_newuserdata(L,sizeof(FILE*));
*pf=NULL;
luaL_getmetatable(L,"FILE*");
lua_setmetatable(L,-2);
return pf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x1af30
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x5a56(%rip), %rdx      # 0x23160
callq 0x1c290
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfae0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: os_pushresult
static int os_pushresult(lua_State*L,int i,const char*filename){
int en=errno;
if(i){
lua_pushboolean(L,1);
return 1;
}
else{
lua_pushnil(L);
lua_pushfstring(L,"%s: %s",filename,strerror(en));
lua_pushinteger(L,en);
return 3;
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
callq 0x3040
movl (%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1d87d
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x1a180
movl $0x1, 0x34(%rsp)
jmp 0x1d8d4
movq 0x28(%rsp), %rdi
callq 0x11870
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %edi
callq 0x32b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x5c13(%rip), %rsi      # 0x234c9
movb $0x0, %al
callq 0x11350
movq 0x28(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x1ab20
movl $0x3, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: createmetatable
static void createmetatable(lua_State*L){
lua_createtable(L,0,1);
lua_pushliteral(L,"");
lua_pushvalue(L,-2);
lua_setmetatable(L,-2);
lua_pop(L,1);
lua_pushvalue(L,-2);
lua_setfield(L,-2,"__index");
lua_pop(L,1);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x3630
movq (%rsp), %rdi
leaq 0x51d6(%rip), %rsi      # 0x22ad6
xorl %eax, %eax
movl %eax, %edx
callq 0xf860
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf7f0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfae0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x11600
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf7f0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x5074(%rip), %rdx      # 0x229c5
callq 0x3800
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x11600
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_byte
static int str_byte(lua_State*L){
size_t l;
const char*s=luaL_checklstring(L,1,&l);
ptrdiff_t posi=posrelat(luaL_optinteger(L,2,1),l);
ptrdiff_t pose=posrelat(luaL_optinteger(L,3,posi),l);
int n,i;
if(posi<=0)posi=1;
if((size_t)pose>l)pose=l;
if(posi>pose)return 0;
n=(int)(pose-posi+1);
if(posi+n<=pose)
luaL_error(L,"string slice too long");
luaL_checkstack(L,n,"string slice too long");
for(i=0;i<n;i++)
lua_pushinteger(L,uchar(s[posi+i-1]));
return n;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
callq 0x11450
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x115b0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1e7e0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0x3, %esi
callq 0x115b0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1e7e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jg 0x1d9ef
movq $0x1, 0x10(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x1da05
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jle 0x1da1e
movl $0x0, 0x34(%rsp)
jmp 0x1dab4
movq 0x8(%rsp), %rax
subq 0x10(%rsp), %rax
addq $0x1, %rax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
addq %rcx, %rax
cmpq 0x8(%rsp), %rax
jg 0x1da57
movq 0x28(%rsp), %rdi
leaq 0x581d(%rip), %rsi      # 0x2326d
movb $0x0, %al
callq 0x10790
movq 0x28(%rsp), %rdi
movl 0x4(%rsp), %esi
leaq 0x5806(%rip), %rdx      # 0x2326d
callq 0x1b9c0
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x1daac
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq (%rsp), %rdx
addq %rdx, %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
callq 0x1ab20
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1da73
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_char
static int str_char(lua_State*L){
int n=lua_gettop(L);
int i;
luaL_Buffer b;
luaL_buffinit(L,&b);
for(i=1;i<=n;i++){
int c=luaL_checkint(L,i);
luaL_argcheck(L,uchar(c)==c,i,"invalid value");
luaL_addchar(&b,uchar(c));
}
luaL_pushresult(&b);
return 1;
}

// Assembly:
subq $0x2038, %rsp           # imm = 0x2038
movq %rdi, 0x2030(%rsp)
movq 0x2030(%rsp), %rdi
callq 0x10910
movl %eax, 0x202c(%rsp)
movq 0x2030(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b5c0
movl $0x1, 0x2028(%rsp)
movl 0x2028(%rsp), %eax
cmpl 0x202c(%rsp), %eax
jg 0x1dbd0
movq 0x2030(%rsp), %rdi
movl 0x2028(%rsp), %esi
callq 0x116e0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movzbl %al, %ecx
movb $0x1, %al
cmpl 0xc(%rsp), %ecx
movb %al, 0xb(%rsp)
je 0x1db64
movq 0x2030(%rsp), %rdi
movl 0x2028(%rsp), %esi
leaq 0x572e(%rip), %rdx      # 0x23283
callq 0x10980
cmpl $0x0, %eax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
movq 0x10(%rsp), %rcx
leaq 0x10(%rsp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, 0xa(%rsp)
jb 0x1db9d
leaq 0x10(%rsp), %rdi
callq 0x1b990
cmpq $0x0, %rax
setne %al
movb %al, 0xa(%rsp)
movb 0xa(%rsp), %al
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb %cl, (%rax)
movl 0x2028(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2028(%rsp)
jmp 0x1db00
leaq 0x10(%rsp), %rdi
callq 0x1b730
movl $0x1, %eax
addq $0x2038, %rsp           # imm = 0x2038
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: gmatch
static int gmatch(lua_State*L){
luaL_checkstring(L,1);
luaL_checkstring(L,2);
lua_settop(L,2);
lua_pushinteger(L,0);
lua_pushcclosure(L,gmatch_aux,3);
return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq (%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x11600
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1ab20
movq (%rsp), %rdi
leaq 0x2151(%rip), %rsi      # 0x20270
movl $0x3, %edx
callq 0xf340
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_lower
static int str_lower(lua_State*L){
size_t l;
size_t i;
luaL_Buffer b;
const char*s=luaL_checklstring(L,1,&l);
luaL_buffinit(L,&b);
for(i=0;i<l;i++)
luaL_addchar(&b,tolower(uchar(s[i])));
luaL_pushresult(&b);
return 1;
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2040(%rsp)
movq 0x2040(%rsp), %rdi
movl $0x1, %esi
leaq 0x2038(%rsp), %rdx
callq 0x11450
movq %rax, 0x10(%rsp)
movq 0x2040(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1b5c0
movq $0x0, 0x2030(%rsp)
movq 0x2030(%rsp), %rax
cmpq 0x2038(%rsp), %rax
jae 0x1e51b
movq 0x18(%rsp), %rcx
leaq 0x18(%rsp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, 0xf(%rsp)
jb 0x1e4d3
leaq 0x18(%rsp), %rdi
callq 0x1b990
cmpq $0x0, %rax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rax
movq 0x2030(%rsp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x31d0
movb %al, %cl
movq 0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movb %cl, (%rax)
movq 0x2030(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x2030(%rsp)
jmp 0x1e48c
leaq 0x18(%rsp), %rdi
callq 0x1b730
movl $0x1, %eax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_rep
static int str_rep(lua_State*L){
size_t l;
luaL_Buffer b;
const char*s=luaL_checklstring(L,1,&l);
int n=luaL_checkint(L,2);
luaL_buffinit(L,&b);
while(n-->0)
luaL_addlstring(&b,s,l);
luaL_pushresult(&b);
return 1;
}

// Assembly:
subq $0x2038, %rsp           # imm = 0x2038
movq %rdi, 0x2030(%rsp)
movq 0x2030(%rsp), %rdi
movl $0x1, %esi
leaq 0x2028(%rsp), %rdx
callq 0x11450
movq %rax, 0x8(%rsp)
movq 0x2030(%rsp), %rdi
movl $0x2, %esi
callq 0x116e0
movl %eax, 0x4(%rsp)
movq 0x2030(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b5c0
movl 0x4(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rsp)
cmpl $0x0, %eax
jle 0x1e5e1
movq 0x8(%rsp), %rsi
movq 0x2028(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0x1b690
jmp 0x1e5b6
leaq 0x10(%rsp), %rdi
callq 0x1b730
movl $0x1, %eax
addq $0x2038, %rsp           # imm = 0x2038
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_sub
static int str_sub(lua_State*L){
size_t l;
const char*s=luaL_checklstring(L,1,&l);
ptrdiff_t start=posrelat(luaL_checkinteger(L,2),l);
ptrdiff_t end=posrelat(luaL_optinteger(L,3,-1),l);
if(start<1)start=1;
if(end>(ptrdiff_t)l)end=(ptrdiff_t)l;
if(start<=end)
lua_pushlstring(L,s+start-1,end-start+1);
else lua_pushliteral(L,"");
return 1;
}

// 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
movl $0x2, %esi
callq 0x116e0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x1e7e0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x115b0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x1e7e0
movq %rax, (%rsp)
cmpq $0x1, 0x8(%rsp)
jge 0x1e67b
movq $0x1, 0x8(%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jle 0x1e68f
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jg 0x1e6c1
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq 0x8(%rsp), %rsi
addq $-0x1, %rsi
movq (%rsp), %rdx
subq 0x8(%rsp), %rdx
addq $0x1, %rdx
callq 0xf860
jmp 0x1e6d6
movq 0x20(%rsp), %rdi
leaq 0x4409(%rip), %rsi      # 0x22ad6
xorl %eax, %eax
movl %eax, %edx
callq 0xf860
movl $0x1, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: str_upper
static int str_upper(lua_State*L){
size_t l;
size_t i;
luaL_Buffer b;
const char*s=luaL_checklstring(L,1,&l);
luaL_buffinit(L,&b);
for(i=0;i<l;i++)
luaL_addchar(&b,toupper(uchar(s[i])));
luaL_pushresult(&b);
return 1;
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2040(%rsp)
movq 0x2040(%rsp), %rdi
movl $0x1, %esi
leaq 0x2038(%rsp), %rdx
callq 0x11450
movq %rax, 0x10(%rsp)
movq 0x2040(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1b5c0
movq $0x0, 0x2030(%rsp)
movq 0x2030(%rsp), %rax
cmpq 0x2038(%rsp), %rax
jae 0x1e7bb
movq 0x18(%rsp), %rcx
leaq 0x18(%rsp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, 0xf(%rsp)
jb 0x1e773
leaq 0x18(%rsp), %rdi
callq 0x1b990
cmpq $0x0, %rax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rax
movq 0x2030(%rsp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x3090
movb %al, %cl
movq 0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movb %cl, (%rax)
movq 0x2030(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x2030(%rsp)
jmp 0x1e72c
leaq 0x18(%rsp), %rdi
callq 0x1b730
movl $0x1, %eax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lmemfind
static const char*lmemfind(const char*s1,size_t l1,
const char*s2,size_t l2){
if(l2==0)return s1;
else if(l2>l1)return NULL;
else{
const char*init;
l2--;
l1=l1-l2;
while(l1>0&&(init=(const char*)memchr(s1,*s2,l1))!=NULL){
init++;
if(memcmp(init,s2+1,l2)==0)
return init-1;
else{
l1-=init-s1;
s1=init;
}
}
return NULL;
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1ebaf
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1ec92
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x1ebc9
movq $0x0, 0x30(%rsp)
jmp 0x1ec92
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
subq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x20(%rsp)
movb %al, 0x7(%rsp)
jbe 0x1ec1b
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movsbl (%rax), %esi
movq 0x20(%rsp), %rdx
callq 0x3140
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1ec25
jmp 0x1ec89
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
movq 0x10(%rsp), %rdx
callq 0x3150
cmpl $0x0, %eax
jne 0x1ec60
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1ec92
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
subq %rax, %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x1ebe6
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: push_captures
static int push_captures(MatchState*ms,const char*s,const char*e){
int i;
int nlevels=(ms->level==0&&s)?1:ms->level;
luaL_checkstack(ms->L,nlevels,"too many captures");
for(i=0;i<nlevels;i++)
push_onecapture(ms,i,s,e);
return nlevels;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x1f121
cmpq $0x0, 0x18(%rsp)
je 0x1f121
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1f12d
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x8(%rsp), %esi
leaq 0x4176(%rip), %rdx      # 0x232bf
callq 0x1b9c0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x1f185
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x1fbf0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1f156
movl 0x8(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: start_capture
static const char*start_capture(MatchState*ms,const char*s,
const char*p,int what){
const char*res;
int level=ms->level;
if(level>=32)luaL_error(ms->L,"too many captures");
ms->capture[level].init=s;
ms->capture[level].len=what;
ms->level=level+1;
if((res=match(ms,s,p))==NULL)
ms->level--;
return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x20, 0xc(%rsp)
jl 0x1f1d1
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x40f5(%rip), %rsi      # 0x232bf
movb $0x0, %al
callq 0x10790
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
addq $0x20, %rax
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movslq 0x1c(%rsp), %rcx
movq 0x30(%rsp), %rax
addq $0x20, %rax
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1eca0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x1f248
movq 0x30(%rsp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rsp), %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: end_capture
static const char*end_capture(MatchState*ms,const char*s,
const char*p){
int l=capture_to_close(ms);
const char*res;
ms->capture[l].len=s-ms->capture[l].init;
if((res=match(ms,s,p))==NULL)
ms->capture[l].len=(-1);
return res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f930
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
addq $0x20, %rax
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rax), %rax
subq %rax, %rcx
movq 0x20(%rsp), %rax
addq $0x20, %rax
movslq 0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1eca0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x1f2f5
movq 0x20(%rsp), %rax
addq $0x20, %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $-0x1, 0x8(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: matchbalance
static const char*matchbalance(MatchState*ms,const char*s,
const char*p){
if(*p==0||*(p+1)==0)
luaL_error(ms->L,"unbalanced pattern");
if(*s!=*p)return NULL;
else{
int b=*p;
int e=*(p+1);
int cont=1;
while(++s<ms->src_end){
if(*s==e){
if(--cont==0)return s+1;
}
else if(*s==b)cont++;
}
}
return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1f32e
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x1f345
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x3fab(%rip), %rsi      # 0x232e9
movb $0x0, %al
callq 0x10790
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
movq 0x18(%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x1f367
movq $0x0, 0x30(%rsp)
jmp 0x1f3f9
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
movl %eax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1f3ee
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rsp), %eax
jne 0x1f3d1
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jne 0x1f3cf
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1f3f9
jmp 0x1f3ec
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x1f3ea
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1f3ec
jmp 0x1f388
jmp 0x1f3f0
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %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: classend
static const char*classend(MatchState*ms,const char*p){
switch(*p++){
case'%':{
if(*p=='\0')
luaL_error(ms->L,"malformed pattern (ends with "LUA_QL("%%")")");
return p+1;
}
case'[':{
if(*p=='^')p++;
do{
if(*p=='\0')
luaL_error(ms->L,"malformed pattern (missing "LUA_QL("]")")");
if(*(p++)=='%'&&*p!='\0')
p++;
}while(*p!=']');
return p+1;
}
default:{
return p;
}
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x10(%rsp)
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x25, %eax
je 0x1f44a
jmp 0x1f43c
movl 0xc(%rsp), %eax
subl $0x5b, %eax
je 0x1f481
jmp 0x1f515
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1f46e
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x3e95(%rip), %rsi      # 0x232fc
movb $0x0, %al
callq 0x10790
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1f51f
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x1f49c
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1f49e
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1f4c2
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x3e64(%rip), %rsi      # 0x2331f
movb $0x0, %al
callq 0x10790
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x1f4f6
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1f4f6
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1f4f8
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x1f49e
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1f51f
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: matchbracketclass
static int matchbracketclass(int c,const char*p,const char*ec){
int sig=1;
if(*(p+1)=='^'){
sig=0;
p++;
}
while(++p<ec){
if(*p=='%'){
p++;
if(match_class(c,uchar(*p)))
return sig;
}
else if((*(p+1)=='-')&&(p+2<ec)){
p+=2;
if(uchar(*(p-2))<=c&&c<=uchar(*p))
return sig;
}
else if(uchar(*p)==c)return sig;
}
return!sig;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5e, %eax
jne 0x1f56e
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1f570
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
cmpq 0x10(%rsp), %rax
jae 0x1f641
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x1f5c9
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rax
movzbl (%rax), %esi
callq 0x1f9b0
cmpl $0x0, %eax
je 0x1f5c7
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1f654
jmp 0x1f63c
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2d, %eax
jne 0x1f620
movq 0x18(%rsp), %rax
addq $0x2, %rax
cmpq 0x10(%rsp), %rax
jae 0x1f620
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl -0x2(%rax), %eax
cmpl 0x20(%rsp), %eax
jg 0x1f61e
movl 0x20(%rsp), %eax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jg 0x1f61e
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1f654
jmp 0x1f63a
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl 0x20(%rsp), %eax
jne 0x1f638
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1f654
jmp 0x1f63a
jmp 0x1f63c
jmp 0x1f570
cmpl $0x0, 0xc(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: match_capture
static const char*match_capture(MatchState*ms,const char*s,int l){
size_t len;
l=check_capture(ms,l);
len=ms->capture[l].len;
if((size_t)(ms->src_end-s)>=len&&
memcmp(ms->capture[l].init,s,len)==0)
return s+len;
else return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1fb70
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
addq $0x20, %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
cmpq (%rsp), %rax
jb 0x1f6f3
movq 0x18(%rsp), %rax
addq $0x20, %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
callq 0x3150
cmpl $0x0, %eax
jne 0x1f6f3
movq 0x10(%rsp), %rax
addq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1f6fc
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: singlematch
static int singlematch(int c,const char*p,const char*ep){
switch(*p){
case'.':return 1;
case'%':return match_class(c,uchar(*(p+1)));
case'[':return matchbracketclass(c,p,ep-1);
default:return(uchar(*p)==c);
}
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x25, %eax
je 0x1f755
jmp 0x1f735
movl 0xc(%rsp), %eax
subl $0x2e, %eax
je 0x1f74b
jmp 0x1f740
movl 0xc(%rsp), %eax
subl $0x5b, %eax
je 0x1f76d
jmp 0x1f78a
movl $0x1, 0x24(%rsp)
jmp 0x1f7a2
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rax
movzbl 0x1(%rax), %esi
callq 0x1f9b0
movl %eax, 0x24(%rsp)
jmp 0x1f7a2
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $-0x1, %rdx
callq 0x1f530
movl %eax, 0x24(%rsp)
jmp 0x1f7a2
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl 0x20(%rsp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: max_expand
static const char*max_expand(MatchState*ms,const char*s,
const char*p,const char*ep){
ptrdiff_t i=0;
while((s+i)<ms->src_end&&singlematch(uchar(*(s+i)),p,ep))
i++;
while(i>=0){
const char*res=match(ms,(s+i),ep+1);
if(res)return res;
i--;
}
return NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rcx
addq 0x18(%rsp), %rcx
movq 0x38(%rsp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0xf(%rsp)
jae 0x1f813
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1f710
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1f81d
jmp 0x1f82d
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1f7d1
jmp 0x1f82f
cmpq $0x0, 0x18(%rsp)
jl 0x1f87d
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x1, %rdx
callq 0x1eca0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1f86d
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1f886
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1f82f
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: min_expand
static const char*min_expand(MatchState*ms,const char*s,
const char*p,const char*ep){
for(;;){
const char*res=match(ms,s,ep+1);
if(res!=NULL)
return res;
else if(s<ms->src_end&&singlematch(uchar(*s),p,ep))
s++;
else return NULL;
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $0x1, %rdx
callq 0x1eca0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1f8d9
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1f924
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1f915
movq 0x20(%rsp), %rax
movzbl (%rax), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1f710
cmpl $0x0, %eax
je 0x1f915
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1f920
movq $0x0, 0x30(%rsp)
jmp 0x1f924
jmp 0x1f922
jmp 0x1f8a8
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: capture_to_close
static int capture_to_close(MatchState*ms){
int level=ms->level;
for(level--;level>=0;level--)
if(ms->capture[level].len==(-1))return level;
return luaL_error(ms->L,"invalid pattern capture");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x1f98c
movq 0x8(%rsp), %rax
addq $0x20, %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $-0x1, 0x8(%rax)
jne 0x1f97d
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x1f9a7
jmp 0x1f97f
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1f950
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x3935(%rip), %rsi      # 0x232d1
movb $0x0, %al
callq 0x10790
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: match_class
static int match_class(int c,int cl){
int res;
switch(tolower(cl)){
case'a':res=isalpha(c);break;
case'c':res=iscntrl(c);break;
case'd':res=isdigit(c);break;
case'l':res=islower(c);break;
case'p':res=ispunct(c);break;
case's':res=isspace(c);break;
case'u':res=isupper(c);break;
case'w':res=isalnum(c);break;
case'x':res=isxdigit(c);break;
case'z':res=(c==0);break;
default:return(cl==c);
}
return(islower(cl)?res:!res);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
callq 0x31d0
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x19, %eax
ja 0x1fb05
movq 0x10(%rsp), %rax
leaq 0x2b8c(%rip), %rcx      # 0x22570
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4, %eax
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
callq 0x32d0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
cmpl $0x0, 0x20(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x18(%rsp)
jmp 0x1fb1b
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x1fb5b
callq 0x32d0
movq (%rax), %rax
movslq 0x1c(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x1fb40
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x1fb53
cmpl $0x0, 0x18(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: check_capture
static int check_capture(MatchState*ms,int l){
l-='1';
if(l<0||l>=ms->level||ms->capture[l].len==(-1))
return luaL_error(ms->L,"invalid capture index");
return l;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl 0x4(%rsp), %eax
subl $0x31, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x1fbb9
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x1fbb9
movq 0x8(%rsp), %rax
addq $0x20, %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $-0x1, 0x8(%rax)
jne 0x1fbd6
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x3776(%rip), %rsi      # 0x2333f
movb $0x0, %al
callq 0x10790
movl %eax, 0x14(%rsp)
jmp 0x1fbde
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)