LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_basename
static int jx9Builtin_basename(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath, *zBase, *zEnd;
	int c, d, iLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	c = d = '/';
#ifdef __WINNT__
	d = '\\';
#endif
	/* Point to the target path */
	zPath = jx9_value_to_string(apArg[0], &iLen);
	if( iLen < 1 ){
		/* Empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	zEnd = &zPath[iLen - 1];
	/* Ignore trailing '/' */
	while( zEnd > zPath && ( (int)zEnd[0] == c || (int)zEnd[0] == d ) ){
		zEnd--;
	}
	iLen = (int)(&zEnd[1]-zPath);
	while( zEnd > zPath && ( (int)zEnd[0] != c && (int)zEnd[0] != d ) ){
		zEnd--;
	}
	zBase = (zEnd > zPath) ? &zEnd[1] : zPath;
	zEnd = &zPath[iLen];
	if( nArg > 1 && jx9_value_is_string(apArg[1]) ){
		const char *zSuffix;
		int nSuffix;
		/* Strip suffix */
		zSuffix = jx9_value_to_string(apArg[1], &nSuffix);
		if( nSuffix > 0 && nSuffix < iLen && SyMemcmp(&zEnd[-nSuffix], zSuffix, nSuffix) == 0 ){
			zEnd -= nSuffix;
		}
	}
	/* Store the basename */
	jx9_result_string(pCtx, zBase, (int)(zEnd-zBase));
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x61f32
movq %rdx, %r12
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x61f32
movl %esi, %r13d
leaq -0x2c(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movslq (%r14), %rcx
testq %rcx, %rcx
jle 0x61f32
leaq (%rcx,%rax), %rsi
decq %rsi
movq %rcx, %rdi
shlq $0x20, %rdi
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
movq %rsi, %r15
movq %rdi, %r14
movl %ecx, %r8d
cmpq %rax, %rsi
jbe 0x61f00
leaq -0x1(%r15), %rsi
leaq (%r14,%rdx), %rdi
leal -0x1(%r8), %ecx
cmpb $0x2f, (%r15)
je 0x61ee0
movl %r8d, -0x2c(%rbp)
cmpq %rax, %r15
seta %cl
jbe 0x61f58
cmpb $0x2f, (%r15)
je 0x61f58
decq %r15
cmpq %rax, %r15
seta %cl
jbe 0x61f55
leaq -0x1(%r15), %rdx
cmpb $0x2f, (%r15)
movq %rdx, %r15
jne 0x61f15
incq %rdx
movq %rdx, %r15
jmp 0x61f58
movq 0x8(%rbx), %rdi
leaq 0x1772a(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
incq %r15
testb %cl, %cl
cmoveq %rax, %r15
sarq $0x20, %r14
addq %rax, %r14
cmpl $0x1, %r13d
je 0x61fab
movq 0x8(%r12), %rdi
testb $0x1, 0x8(%rdi)
je 0x61fab
leaq -0x30(%rbp), %r12
movq %r12, %rsi
callq 0x30b04
movslq (%r12), %rdx
testq %rdx, %rdx
jle 0x61fab
cmpl -0x2c(%rbp), %edx
jge 0x61fab
movq %r14, %r12
subq %rdx, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x34ebe
testl %eax, %eax
jne 0x61fab
movq %r12, %r14
subl %r15d, %r14d
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movl %r14d, %edx
jmp 0x61f3f
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strglob
static int jx9Builtin_strglob(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString, *zPattern;
	int iEsc = '\\';
	int rc;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the pattern and the string */
	zPattern  = jx9_value_to_string(apArg[0], 0);
	zString = jx9_value_to_string(apArg[1], 0);
	/* Go globbing */
	rc = Glob((const unsigned char *)zPattern, (const unsigned char *)zString, iEsc, 0);
	/* Globbing result */
	jx9_result_bool(pCtx, rc);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x623b9
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x623b9
movq 0x8(%r14), %rax
testb $0x1, 0x8(%rax)
jne 0x623e7
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
callq 0x30b04
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30b04
movq %r15, %rdi
movq %rax, %rsi
movl $0x5c, %edx
xorl %ecx, %ecx
callq 0x65bcc
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
xorl %eax, %eax
testl %r14d, %r14d
setne %al
movq %rax, (%rbx)
jmp 0x623cc
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_fnmatch
static int jx9Builtin_fnmatch(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString, *zPattern;
	int iEsc = '\\';
	int noCase = 0;
	int rc;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the pattern and the string */
	zPattern  = jx9_value_to_string(apArg[0], 0);
	zString = jx9_value_to_string(apArg[1], 0);
	/* Extract the flags if avaialble */
	if( nArg > 2 && jx9_value_is_int(apArg[2]) ){
		rc = jx9_value_to_int(apArg[2]);
		if( rc & 0x01 /*FNM_NOESCAPE*/){
			iEsc = 0;
		}
		if( rc & 0x08 /*FNM_CASEFOLD*/){
			noCase = 1;
		}
	}
	/* Go globbing */
	rc = Glob((const unsigned char *)zPattern, (const unsigned char *)zString, iEsc, noCase);
	/* Globbing result */
	jx9_result_bool(pCtx, rc);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x62456
movq %rdx, %r13
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x62456
movq 0x8(%r13), %rax
testb $0x1, 0x8(%rax)
jne 0x62488
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r15d
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x30b04
movq %rax, -0x30(%rbp)
movq 0x8(%r13), %rdi
xorl %esi, %esi
callq 0x30b04
movq %rax, %r12
movl $0x5c, %edx
cmpl $0x2, %r15d
je 0x624de
movq 0x10(%r13), %r15
testb $0x2, 0x8(%r15)
je 0x624de
movq %r15, %rdi
callq 0x3fd5f
movl (%r15), %r14d
xorl %eax, %eax
testb $0x1, %r14b
movl $0x5c, %edx
cmovnel %eax, %edx
shrl $0x3, %r14d
andl $0x1, %r14d
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl %r14d, %ecx
callq 0x65bcc
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
xorl %eax, %eax
testl %r14d, %r14d
setne %al
movq %rax, (%rbx)
jmp 0x62469
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_close
static int jx9Builtin_zip_close(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchive *pArchive;
	zip_raw_data *pRaw;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
		return JX9_OK;
	}
	/* Point to the in-memory archive */
	pArchive = (SyArchive *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid ZIP archive */
	if( SXARCH_INVALID(pArchive) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
		return JX9_OK;
	}
	/* Release the archive */
	SyArchiveRelease(pArchive);
	pRaw = (zip_raw_data *)&pArchive[1];
	if( pRaw->iType == ZIP_RAW_DATA_MEMBUF ){
		SyBlobRelease(&pRaw->raw.sBlob);
	}else{
		const jx9_vfs *pVfs = pRaw->raw.mmap.pVfs;
		if( pVfs->xUnmap ){
			/* Unmap the memory view */
			pVfs->xUnmap(pRaw->raw.mmap.pMap, pRaw->raw.mmap.nSize);
		}
	}
	/* Release the memory chunk */
	jx9_context_free_chunk(pCtx, pArchive);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x62964
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62964
movq (%rax), %r14
testq %r14, %r14
je 0x62964
cmpl $0xdead635a, 0x50(%r14) # imm = 0xDEAD635A
jne 0x62964
movq %rdi, -0x30(%rbp)
cmpl $0x0, 0x38(%r14)
je 0x62936
movq 0x10(%r14), %r15
movq 0x80(%r15), %rcx
movq 0x10(%r14), %rax
cmpq %r15, %rax
jne 0x6289a
movq 0x80(%rax), %rax
movq %rax, 0x10(%r14)
movq 0x88(%r15), %rax
testq %rax, %rax
je 0x628ad
movq %rcx, 0x80(%rax)
movq %rcx, -0x38(%rbp)
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x628c4
movq %rax, 0x88(%rcx)
movq %r14, %rbx
movq (%r14), %r12
cmpl $0x0, 0x60(%r15)
je 0x62904
movq 0x78(%r15), %r13
movq 0x50(%r13), %rsi
movq 0x78(%r13), %r14
movl $0x2661, 0xa0(%r13) # imm = 0x2661
movq %r12, %rdi
callq 0x3503f
movq %r12, %rdi
movq %r13, %rsi
callq 0x2eb38
decl 0x60(%r15)
movq %r14, %r13
jne 0x628d5
movl $0x2661, 0xa0(%r15) # imm = 0x2661
movq 0x50(%r15), %rsi
movq %r12, %rdi
callq 0x3503f
movq %r12, %rdi
movq %r15, %rsi
callq 0x2eb38
movq %rbx, %r14
decl 0x38(%rbx)
movq -0x38(%rbp), %r15
jne 0x6287f
movq (%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x3503f
movq $0x0, 0x8(%r14)
movl $0x2626, 0x50(%r14)     # imm = 0x2626
cmpl $0x2, 0x58(%r14)
jne 0x62991
leaq 0x60(%r14), %rdi
callq 0x31d8f
jmp 0x629ab
movq (%rdi), %rsi
movq 0x60(%rdi), %rdi
addq $0x8, %rsi
leaq 0x16cf7(%rip), %rcx     # 0x7966d
movl $0x1, %edx
callq 0x4153c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x70(%r14), %rax
movq 0x110(%rax), %rax
testq %rax, %rax
je 0x629ab
movq 0x60(%r14), %rdi
movq 0x68(%r14), %rsi
callq *%rax
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x31975
jmp 0x62980
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_read
static int jx9Builtin_zip_read(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pNext = 0; /* cc warning */
	SyArchive *pArchive;
	sxi32 rc;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the in-memory archive */
	pArchive = (SyArchive *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid ZIP archive */
	if( SXARCH_INVALID(pArchive) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the next entry */
	rc = SyArchiveGetNextEntry(pArchive, &pNext);
	if( rc != SXRET_OK ){
		/* No more entries in the central directory, return FALSE */
		jx9_result_bool(pCtx, 0);
	}else{
		/* Return as a resource handle */
		jx9_result_resource(pCtx, pNext);
		/* Point to the ZIP raw data */
		pNext->pUserData = (void *)&pArchive[1];
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x62a33
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62a33
movq (%rax), %r14
testq %r14, %r14
je 0x62a33
cmpl $0xdead635a, 0x50(%r14) # imm = 0xDEAD635A
jne 0x62a33
movq 0x8(%r14), %r15
leaq 0x10(%r14), %rax
leaq 0x80(%r15), %rcx
testq %r15, %r15
cmoveq %rax, %rcx
movq (%rcx), %rax
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
testq %r15, %r15
je 0x62a5b
movq %r15, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x8(%rbx)
addq $0x58, %r14
movq %r14, 0x98(%r15)
jmp 0x62a70
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16c28(%rip), %rcx     # 0x7966d
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_entry_open
static int jx9Builtin_zip_entry_open(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pEntry;
	SyArchive *pArchive;
	if( nArg < 2 || !jx9_value_is_resource(apArg[0]) || !jx9_value_is_resource(apArg[1]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the in-memory archive */
	pArchive = (SyArchive *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid ZIP archive */
	if( SXARCH_INVALID(pArchive) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid ZIP archive entry */
	pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[1]);
	if( SXARCH_ENTRY_INVALID(pEntry) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* All done. Actually this function is a no-op, return TRUE */
	jx9_result_bool(pCtx, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x16bdf(%rip), %rcx     # 0x7966d
cmpl $0x2, %esi
jl 0x62ad8
movq (%rdx), %rsi
testb $0x1, 0x9(%rsi)
je 0x62ad8
movq 0x8(%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62ad8
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x62ad8
cmpl $0xdead635a, 0x50(%rdx) # imm = 0xDEAD635A
jne 0x62ad8
movq (%rax), %rax
leaq 0x16bc4(%rip), %rcx     # 0x79685
testq %rax, %rax
je 0x62ad8
movl $0x1, %r14d
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
je 0x62af0
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x4153c
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_entry_close
static int jx9Builtin_zip_entry_close(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pEntry;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid ZIP archive entry */
	pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
	if( SXARCH_ENTRY_INVALID(pEntry) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Reset the read cursor */
	pEntry->nReadCount = 0;
	/*All done. Actually this function is a no-op, return TRUE */
	jx9_result_bool(pCtx, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x62b4e
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62b4e
movq (%rax), %rax
testq %rax, %rax
je 0x62b4e
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x62b4e
movl $0x0, 0x8(%rax)
movl $0x1, %r14d
jmp 0x62b6d
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16b25(%rip), %rcx     # 0x79685
movl $0x1, %edx
callq 0x4153c
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_entry_name
static int jx9Builtin_zip_entry_name(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pEntry;
	SyString *pName;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid ZIP archive entry */
	pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
	if( SXARCH_ENTRY_INVALID(pEntry) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Return entry name */
	pName = &pEntry->sFileName;
	jx9_result_string(pCtx, pName->zString, (int)pName->nByte);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x62bcd
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62bcd
movq (%rax), %rax
testq %rax, %rax
je 0x62bcd
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x62bcd
movq 0x50(%rax), %rsi
movl 0x58(%rax), %edx
movq 0x8(%rbx), %rdi
callq 0x3087c
jmp 0x62c0a
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16aa6(%rip), %rcx     # 0x79685
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_entry_filesize
static int jx9Builtin_zip_entry_filesize(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pEntry;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid ZIP archive entry */
	pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
	if( SXARCH_ENTRY_INVALID(pEntry) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Return entry size */
	jx9_result_int64(pCtx, (jx9_int64)pEntry->nByte);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x62c4c
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62c4c
movq (%rax), %rax
testq %rax, %rax
je 0x62c4c
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x62c4c
movl (%rax), %r15d
movl $0x2, %r14d
jmp 0x62c71
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16a27(%rip), %rcx     # 0x79685
movl $0x1, %edx
callq 0x4153c
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r15, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl %r14d, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_entry_compressedsize
static int jx9Builtin_zip_entry_compressedsize(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pEntry;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid ZIP archive entry */
	pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
	if( SXARCH_ENTRY_INVALID(pEntry) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Return entry compressed size */
	jx9_result_int64(pCtx, (jx9_int64)pEntry->nByteCompr);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x62cd5
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62cd5
movq (%rax), %rax
testq %rax, %rax
je 0x62cd5
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x62cd5
movl 0x4(%rax), %r15d
movl $0x2, %r14d
jmp 0x62cfa
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x1699e(%rip), %rcx     # 0x79685
movl $0x1, %edx
callq 0x4153c
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r15, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl %r14d, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_entry_read
static int jx9Builtin_zip_entry_read(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pEntry;
	zip_raw_data *pRaw;
	const char *zData;
	int iLength;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid ZIP archive entry */
	pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
	if( SXARCH_ENTRY_INVALID(pEntry) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	zData = 0;
	if( pEntry->nReadCount >= pEntry->nByteCompr ){
		/* No more data to read, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Set a default read length */
	iLength = 1024;
	if( nArg > 1 ){
		iLength = jx9_value_to_int(apArg[1]);
		if( iLength < 1 ){
			iLength = 1024;
		}
	}
	if( (sxu32)iLength > pEntry->nByteCompr - pEntry->nReadCount ){
		iLength = (int)(pEntry->nByteCompr - pEntry->nReadCount);
	}
	/* Return the entry contents */
	pRaw = (zip_raw_data *)pEntry->pUserData;
	if( pRaw->iType == ZIP_RAW_DATA_MEMBUF ){
		zData = (const char *)SyBlobDataAt(&pRaw->raw.sBlob, (pEntry->nOfft+pEntry->nReadCount));
	}else{
		const char *zMap = (const char *)pRaw->raw.mmap.pMap;
		/* Memory mmaped chunk */
		zData = &zMap[pEntry->nOfft+pEntry->nReadCount];
	}
	/* Increment the read counter */
	pEntry->nReadCount += iLength;
	/* Return the raw data */
	jx9_result_string(pCtx, zData, iLength);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x62dbd
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62dbd
movq (%rax), %r15
testq %r15, %r15
je 0x62dbd
cmpl $0xdead635a, 0xa0(%r15) # imm = 0xDEAD635A
jne 0x62dbd
movl 0x8(%r15), %eax
cmpl 0x4(%r15), %eax
jae 0x62dd9
movl $0x400, %eax            # imm = 0x400
cmpl $0x1, %esi
je 0x62d84
movq 0x8(%rdx), %r14
movq %r14, %rdi
callq 0x3fd5f
movl (%r14), %ecx
testl %ecx, %ecx
movl $0x400, %eax            # imm = 0x400
cmovgl %ecx, %eax
movl 0x4(%r15), %edx
movl 0x8(%r15), %esi
subl %esi, %edx
cmpl %edx, %eax
cmovbl %eax, %edx
movq 0x98(%r15), %rax
xorl %ecx, %ecx
cmpl $0x2, (%rax)
sete %cl
leal (%rdx,%rsi), %edi
addl 0x48(%r15), %esi
addq 0x8(%rax,%rcx,8), %rsi
movl %edi, 0x8(%r15)
movq 0x8(%rbx), %rdi
callq 0x3087c
jmp 0x62dfa
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x168b6(%rip), %rcx     # 0x79685
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_entry_reset_cursor
static int jx9Builtin_zip_entry_reset_cursor(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pEntry;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid ZIP archive entry */
	pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
	if( SXARCH_ENTRY_INVALID(pEntry) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Reset the cursor */
	pEntry->nReadCount = 0;
	/* Return TRUE */
	jx9_result_bool(pCtx, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x62e41
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62e41
movq (%rax), %rax
testq %rax, %rax
je 0x62e41
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x62e41
movl $0x0, 0x8(%rax)
movl $0x1, %r14d
jmp 0x62e60
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16832(%rip), %rcx     # 0x79685
movl $0x1, %edx
callq 0x4153c
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_zip_entry_compressionmethod
static int jx9Builtin_zip_entry_compressionmethod(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyArchiveEntry *pEntry;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid ZIP archive entry */
	pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
	if( SXARCH_ENTRY_INVALID(pEntry) ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	switch(pEntry->nComprMeth){
	case 0:
		/* No compression;entry is stored */
		jx9_result_string(pCtx, "stored", (int)sizeof("stored")-1);
		break;
	case 8:
		/* Entry is deflated (Default compression algorithm)  */
		jx9_result_string(pCtx, "deflate", (int)sizeof("deflate")-1);
		break;
		/* Exotic compression algorithms */ 
	case 1:
		jx9_result_string(pCtx, "shrunk", (int)sizeof("shrunk")-1);
		break;
	case 2:
	case 3:
	case 4:
	case 5:
		/* Entry is reduced */
		jx9_result_string(pCtx, "reduced", (int)sizeof("reduced")-1);
		break;
	case 6:
		/* Entry is imploded */
		jx9_result_string(pCtx, "implode", (int)sizeof("implode")-1);
		break;
	default:
		jx9_result_string(pCtx, "unknown", (int)sizeof("unknown")-1);
		break;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x62ede
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x62ede
movq (%rax), %rax
testq %rax, %rax
je 0x62ede
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x62ede
movzwl 0x4c(%rax), %eax
cmpq $0x8, %rax
ja 0x62f62
leaq 0x11cad(%rip), %rcx     # 0x74b70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
leaq 0x167e2(%rip), %rsi     # 0x796b9
movl $0x7, %edx
jmp 0x62f5b
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16795(%rip), %rcx     # 0x79685
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8(%rbx), %rdi
leaq 0x15d09(%rip), %rsi     # 0x78c38
jmp 0x62ed7
movq 0x8(%rbx), %rdi
leaq 0x1676e(%rip), %rsi     # 0x796aa
jmp 0x62ed7
movq 0x8(%rbx), %rdi
leaq 0x16769(%rip), %rsi     # 0x796b2
jmp 0x62f56
movq 0x8(%rbx), %rdi
leaq 0x1674d(%rip), %rsi     # 0x796a3
movl $0x6, %edx
callq 0x3087c
jmp 0x62f1b
movq 0x8(%rbx), %rdi
leaq 0x16667(%rip), %rsi     # 0x795d4
jmp 0x62ed7
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ftruncate
static int jx9Builtin_ftruncate(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const jx9_io_stream *pStream;
	io_private *pDev;
	int rc;
	if( nArg < 2 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract our private data */
	pDev = (io_private *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid io_private instance */
	if( IO_PRIVATE_INVALID(pDev) ){
		/*Expecting an IO handle */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target IO stream device */
	pStream = pDev->pStream;
	if( pStream == 0  || pStream->xTrunc == 0){
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE", 
			jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	rc = pStream->xTrunc(pDev->pHandle, jx9_value_to_int64(apArg[1]));
	if( rc == JX9_OK ){
		/* Discard buffered data */
		ResetIOPrivate(pDev);
	}
	/* IO result */
	jx9_result_bool(pCtx, rc == JX9_OK);
	return JX9_OK;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x6303c
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x6303c
movq (%rax), %r12
testq %r12, %r12
je 0x6303c
cmpl $0xfeac14, 0x34(%r12)   # imm = 0xFEAC14
jne 0x6303c
movq (%r12), %rax
testq %rax, %rax
je 0x6308a
movq 0x68(%rax), %r13
testq %r13, %r13
je 0x6308a
movq 0x8(%r12), %r14
movq 0x8(%rdx), %r15
movq %r15, %rdi
callq 0x3fd5f
movq (%r15), %rsi
movq %r14, %rdi
callq *%r13
testl %eax, %eax
jne 0x63022
movl $0x0, 0x20(%r12)
movl 0x28(%r12), %ecx
testb $0x4, %cl
je 0x63019
movq $0x0, 0x18(%r12)
movl $0x0, 0x24(%r12)
andl $-0x5, %ecx
movl %ecx, 0x28(%r12)
movl $0x0, 0x30(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x6306b
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16673(%rip), %rcx     # 0x796c1
movl $0x2, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
testq %rax, %rax
je 0x6309b
movq (%rax), %r8
jmp 0x630a2
leaq 0x16691(%rip), %r8      # 0x79733
leaq 0x1662f(%rip), %rdx     # 0x796d8
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x63058
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ftell
static int jx9Builtin_ftell(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const jx9_io_stream *pStream;
	io_private *pDev;
	jx9_int64 iOfft;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract our private data */
	pDev = (io_private *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid io_private instance */
	if( IO_PRIVATE_INVALID(pDev) ){
		/*Expecting an IO handle */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target IO stream device */
	pStream = pDev->pStream;
	if( pStream == 0  || pStream->xTell == 0){
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE", 
			jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	iOfft = pStream->xTell(pDev->pHandle);
	/* IO result */
	jx9_result_int64(pCtx, iOfft);
	return JX9_OK;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x63276
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x63276
movq (%rax), %rax
testq %rax, %rax
je 0x63276
cmpl $0xfeac14, 0x34(%rax)   # imm = 0xFEAC14
jne 0x63276
movq (%rax), %rdx
testq %rdx, %rdx
je 0x632c5
movq 0x60(%rdx), %rcx
testq %rcx, %rcx
je 0x632c5
movq 0x8(%rax), %rdi
callq *%rcx
movq %rax, %r14
movl $0x2, %r15d
jmp 0x6329b
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16439(%rip), %rcx     # 0x796c1
movl $0x2, %edx
callq 0x4153c
movl $0x8, %r15d
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl %r15d, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rax), %rcx
testq %rdx, %rdx
je 0x632d6
movq (%rdx), %r8
jmp 0x632dd
leaq 0x16456(%rip), %r8      # 0x79733
leaq 0x163f4(%rip), %rdx     # 0x796d8
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
movl $0x8, %r15d
jmp 0x6329b
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_rewind
static int jx9Builtin_rewind(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const jx9_io_stream *pStream;
	io_private *pDev;
	int rc;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract our private data */
	pDev = (io_private *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid io_private instance */
	if( IO_PRIVATE_INVALID(pDev) ){
		/*Expecting an IO handle */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target IO stream device */
	pStream = pDev->pStream;
	if( pStream == 0  || pStream->xSeek == 0){
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE", 
			jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	rc = pStream->xSeek(pDev->pHandle, 0, 0/*SEEK_SET*/);
	if( rc == JX9_OK ){
		/* Ignore buffered data */
		ResetIOPrivate(pDev);
	}
	/* IO result */
	jx9_result_bool(pCtx, rc == JX9_OK);
	return JX9_OK;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x633a0
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x633a0
movq (%rax), %r14
testq %r14, %r14
je 0x633a0
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x633a0
movq (%r14), %rax
testq %rax, %rax
je 0x633e4
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x633e4
movq 0x8(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *%rcx
testl %eax, %eax
jne 0x63386
movl $0x0, 0x20(%r14)
movl 0x28(%r14), %ecx
testb $0x4, %cl
je 0x6337e
movq $0x0, 0x18(%r14)
movl $0x0, 0x24(%r14)
andl $-0x5, %ecx
movl %ecx, 0x28(%r14)
movl $0x0, 0x30(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x633cf
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x1630f(%rip), %rcx     # 0x796c1
movl $0x2, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
testq %rax, %rax
je 0x633f5
movq (%rax), %r8
jmp 0x633fc
leaq 0x16337(%rip), %r8      # 0x79733
leaq 0x162d5(%rip), %rdx     # 0x796d8
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x633bc
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_fflush
static int jx9Builtin_fflush(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const jx9_io_stream *pStream;
	io_private *pDev;
	int rc;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract our private data */
	pDev = (io_private *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid io_private instance */
	if( IO_PRIVATE_INVALID(pDev) ){
		/*Expecting an IO handle */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target IO stream device */
	pStream = pDev->pStream;
	if( pStream == 0 || pStream->xSync == 0){
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE", 
			jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	rc = pStream->xSync(pDev->pHandle);
	/* IO result */
	jx9_result_bool(pCtx, rc == JX9_OK);
	return JX9_OK;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x6346d
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x6346d
movq (%rax), %rax
testq %rax, %rax
je 0x6346d
cmpl $0xfeac14, 0x34(%rax)   # imm = 0xFEAC14
jne 0x6346d
movq (%rax), %rdx
testq %rdx, %rdx
je 0x634b1
movq 0x70(%rdx), %rcx
testq %rcx, %rcx
je 0x634b1
movq 0x8(%rax), %rdi
callq *%rcx
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x6349c
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16242(%rip), %rcx     # 0x796c1
movl $0x2, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rax), %rcx
testq %rdx, %rdx
je 0x634c2
movq (%rdx), %r8
jmp 0x634c9
leaq 0x1626a(%rip), %r8      # 0x79733
leaq 0x16208(%rip), %rdx     # 0x796d8
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x63489
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_feof
static int jx9Builtin_feof(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const jx9_io_stream *pStream;
	io_private *pDev;
	int rc;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 1);
		return JX9_OK;
	}
	/* Extract our private data */
	pDev = (io_private *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid io_private instance */
	if( IO_PRIVATE_INVALID(pDev) ){
		/*Expecting an IO handle */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 1);
		return JX9_OK;
	}
	/* Point to the target IO stream device */
	pStream = pDev->pStream;
	if( pStream == 0 ){
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE", 
			jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
			);
		jx9_result_bool(pCtx, 1);
		return JX9_OK;
	}
	rc = SXERR_EOF;
	/* Perform the requested operation */
	if( SyBlobLength(&pDev->sBuffer) - pDev->nOfft > 0 ){
		/* Data is available */
		rc = JX9_OK;
	}else{
		char zBuf[4096];
		jx9_int64 n;
		/* Perform a buffered read */
		n = pStream->xRead(pDev->pHandle, zBuf, sizeof(zBuf));
		if( n > 0 ){
			/* Copy buffered data */
			SyBlobAppend(&pDev->sBuffer, zBuf, (sxu32)n);
			rc = JX9_OK;
		}
	}
	/* EOF or not */
	jx9_result_bool(pCtx, rc == SXERR_EOF);
	return JX9_OK;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
testl %esi, %esi
jle 0x6356a
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x6356a
movq (%rax), %r14
testq %r14, %r14
je 0x6356a
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x6356a
movq (%r14), %rax
testq %rax, %rax
je 0x635b9
movl 0x20(%r14), %ecx
cmpl 0x30(%r14), %ecx
jne 0x635df
movq 0x8(%r14), %rdi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq *0x30(%rax)
movq %rax, %r15
testq %rax, %rax
jle 0x6355e
addq $0x10, %r14
leaq -0x1020(%rbp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x360ae
xorl %r14d, %r14d
testq %r15, %r15
setle %r14b
jmp 0x6358c
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16145(%rip), %rcx     # 0x796c1
movl $0x2, %edx
callq 0x4153c
movl $0x1, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x16111(%rip), %rdx     # 0x796d8
leaq 0x16165(%rip), %r8      # 0x79733
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x63586
xorl %r14d, %r14d
jmp 0x6358c
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_fgetc
static int jx9Builtin_fgetc(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const jx9_io_stream *pStream;
	io_private *pDev;
	int c, n;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract our private data */
	pDev = (io_private *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid io_private instance */
	if( IO_PRIVATE_INVALID(pDev) ){
		/*Expecting an IO handle */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target IO stream device */
	pStream = pDev->pStream;
	if( pStream == 0  ){
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE", 
			jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	n = (int)StreamRead(pDev, (void *)&c, sizeof(char));
	/* IO result */
	if( n < 1 ){
		/* EOF or error, return FALSE */
		jx9_result_bool(pCtx, 0);
	}else{
		/* Return the string holding the character */
		jx9_result_string(pCtx, (const char *)&c, sizeof(char));
	}
	return JX9_OK;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x6363a
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x6363a
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6363a
cmpl $0xfeac14, 0x34(%rdi)   # imm = 0xFEAC14
jne 0x6363a
cmpq $0x0, (%rdi)
je 0x63680
leaq -0xc(%rbp), %rsi
movl $0x1, %edx
callq 0x66582
movq 0x8(%rbx), %rbx
testl %eax, %eax
jle 0x6365a
leaq -0xc(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x3087c
jmp 0x63677
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x16075(%rip), %rcx     # 0x796c1
movl $0x2, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x1604a(%rip), %rdx     # 0x796d8
leaq 0x1609e(%rip), %r8      # 0x79733
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x63656
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_fgets
static int jx9Builtin_fgets(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const jx9_io_stream *pStream;
	const char *zLine;
	io_private *pDev;
	jx9_int64 n, nLen;
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract our private data */
	pDev = (io_private *)jx9_value_to_resource(apArg[0]);
	/* Make sure we are dealing with a valid io_private instance */
	if( IO_PRIVATE_INVALID(pDev) ){
		/*Expecting an IO handle */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target IO stream device */
	pStream = pDev->pStream;
	if( pStream == 0  ){
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE", 
			jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	nLen = -1;
	if( nArg > 1 ){
		/* Maximum data to read */
		nLen = jx9_value_to_int64(apArg[1]);
	}
	/* Perform the requested operation */
	n = StreamReadLine(pDev, &zLine, nLen);
	if( n < 1 ){
		/* EOF or IO error, return FALSE */
		jx9_result_bool(pCtx, 0);
	}else{
		/* Return the freshly extracted line */
		jx9_result_string(pCtx, zLine, (int)n);
	}
	return JX9_OK;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x6371c
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x6371c
movq (%rax), %r14
testq %r14, %r14
je 0x6371c
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x6371c
cmpq $0x0, (%r14)
je 0x63766
movq $-0x1, %rax
cmpl $0x1, %esi
je 0x636f7
movq 0x8(%rdx), %r15
movq %r15, %rdi
callq 0x3fd5f
movq (%r15), %rax
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x66644
testq %rax, %rax
jle 0x63738
movq -0x20(%rbp), %rsi
movq 0x8(%rbx), %rdi
movl %eax, %edx
callq 0x3087c
jmp 0x63759
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x15f93(%rip), %rcx     # 0x796c1
movl $0x2, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x15f64(%rip), %rdx     # 0x796d8
leaq 0x15fb8(%rip), %r8      # 0x79733
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x63738