LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %r15d
movq %rdi, %rbx
xorl %esi, %esi
cmpl $0x2, %r15d
jl 0x52fbc
movq %rdx, %r13
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x52fbc
movq 0x8(%r13), %rax
testb $0x1, 0x8(%rax)
je 0x52fbc
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x297ed
movq %rax, -0x30(%rbp)
movq 0x8(%r13), %rdi
xorl %esi, %esi
callq 0x297ed
movq %rax, %r12
pushq $0x5c
popq %rdx
cmpl $0x2, %r15d
je 0x52fab
movq 0x10(%r13), %rdi
testb $0x2, 0x8(%rdi)
je 0x52fab
callq 0x29772
movl %eax, %r14d
xorl %eax, %eax
testb $0x1, %r14b
pushq $0x5c
popq %rdx
cmovnel %eax, %edx
shrl $0x3, %r14d
andl $0x1, %r14d
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl %r14d, %ecx
callq 0x55a7c
movl %eax, %esi
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x53348
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53348
movq (%rax), %r14
testq %r14, %r14
je 0x53348
cmpl $0xdead635a, 0x50(%r14) # imm = 0xDEAD635A
jne 0x53348
movq %rdi, -0x30(%rbp)
movq 0x10(%r14), %r15
movl 0x38(%r14), %eax
movq %r14, -0x38(%rbp)
testl %eax, %eax
je 0x53368
movq 0x80(%r15), %rbx
movq 0x10(%r14), %rax
cmpq %r15, %rax
jne 0x532a3
movq 0x80(%rax), %rax
movq %rax, 0x10(%r14)
movq 0x88(%r15), %rax
movq %rbx, %rcx
testq %rax, %rax
je 0x532c0
movq %rbx, 0x80(%rax)
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x532cc
movq %rax, 0x88(%rcx)
movq (%r14), %r12
movq 0x78(%r15), %r13
movl 0x60(%r15), %eax
testl %eax, %eax
je 0x53310
movq 0x50(%r13), %rsi
movq 0x78(%r13), %r14
movl $0x2661, 0xa0(%r13) # imm = 0x2661
movq %r12, %rdi
callq 0x2d420
movq %r12, %rdi
movq %r13, %rsi
callq 0x27bf8
movl 0x60(%r15), %eax
decl %eax
movl %eax, 0x60(%r15)
movq %r14, %r13
jmp 0x532d7
movl $0x2661, 0xa0(%r15) # imm = 0x2661
movq 0x50(%r15), %rsi
movq %r12, %rdi
callq 0x2d420
movq %r12, %rdi
movq %r15, %rsi
callq 0x27bf8
movq -0x38(%rbp), %r14
movl 0x38(%r14), %eax
decl %eax
movl %eax, 0x38(%r14)
movq %rbx, %r15
jmp 0x53280
leaq 0x14309(%rip), %rdx     # 0x67658
pushq $0x1
popq %rsi
callq 0x2a0db
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x2d420
andq $0x0, 0x8(%r14)
movl $0x2626, 0x50(%r14)     # imm = 0x2626
cmpl $0x2, 0x58(%r14)
jne 0x53397
leaq 0x60(%r14), %rdi
callq 0x2a72f
movq -0x30(%rbp), %rbx
jmp 0x533b5
movq 0x70(%r14), %rax
movq 0x110(%rax), %rax
testq %rax, %rax
movq -0x30(%rbp), %rbx
je 0x533b5
movq 0x60(%r14), %rdi
movq 0x68(%r14), %rsi
callq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a404
jmp 0x53357
// File: /workspace/github_c_makefile_star2_O2/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 0x5341a
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x5341a
movq (%rax), %r15
testq %r15, %r15
je 0x5341a
cmpl $0xdead635a, 0x50(%r15) # imm = 0xDEAD635A
jne 0x5341a
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x53443
movq 0x80(%r14), %rax
movq %rax, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29a04
addq $0x58, %r15
movq %r15, 0x98(%r14)
jmp 0x53436
leaq 0x14237(%rip), %rdx     # 0x67658
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r15), %rax
movq %rax, 0x8(%r15)
jmp 0x5342c
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %rax
movq %rdi, %rbx
leaq 0x141f8(%rip), %rdx     # 0x67658
cmpl $0x2, %esi
jl 0x534a9
movq (%rax), %rcx
testb $0x1, 0x9(%rcx)
je 0x534a9
movq 0x8(%rax), %rax
testb $0x1, 0x9(%rax)
je 0x534a9
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x534a9
cmpl $0xdead635a, 0x50(%rcx) # imm = 0xDEAD635A
jne 0x534a9
movq (%rax), %rax
leaq 0x141dd(%rip), %rdx     # 0x67670
testq %rax, %rax
je 0x534a9
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x534a9
pushq $0x1
popq %rsi
jmp 0x534b6
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
xorl %esi, %esi
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x534fa
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x534fa
movq (%rax), %rax
testq %rax, %rax
je 0x534fa
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x534fa
andl $0x0, 0x8(%rax)
pushq $0x1
popq %rsi
jmp 0x5350e
leaq 0x1416f(%rip), %rdx     # 0x67670
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
xorl %esi, %esi
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5355a
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x5355a
movq (%rax), %rax
testq %rax, %rax
je 0x5355a
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x5355a
movq 0x50(%rax), %rsi
movl 0x58(%rax), %edx
movq %rbx, %rdi
callq 0x29903
jmp 0x53576
leaq 0x1410f(%rip), %rdx     # 0x67670
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x535b5
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x535b5
movq (%rax), %rax
testq %rax, %rax
je 0x535b5
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x535b5
movl (%rax), %esi
movq %rbx, %rdi
callq 0x29897
jmp 0x535d1
leaq 0x140b4(%rip), %rdx     # 0x67670
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x53611
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53611
movq (%rax), %rax
testq %rax, %rax
je 0x53611
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x53611
movl 0x4(%rax), %esi
movq %rbx, %rdi
callq 0x29897
jmp 0x5362d
leaq 0x14058(%rip), %rdx     # 0x67670
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x536cc
movq %rdx, %rax
movq (%rdx), %rdx
testb $0x1, 0x9(%rdx)
je 0x536cc
movq (%rdx), %r14
testq %r14, %r14
je 0x536cc
cmpl $0xdead635a, 0xa0(%r14) # imm = 0xDEAD635A
jne 0x536cc
movl %esi, %ecx
movl 0x4(%r14), %edx
movl 0x8(%r14), %esi
cmpl %edx, %esi
jae 0x536de
movl $0x400, %edi            # imm = 0x400
cmpl $0x1, %ecx
je 0x5369c
movq 0x8(%rax), %rdi
callq 0x29772
testl %eax, %eax
movl $0x400, %edi            # imm = 0x400
cmovgl %eax, %edi
movl 0x4(%r14), %edx
movl 0x8(%r14), %esi
subl %esi, %edx
cmpl %edx, %edi
cmovbl %edi, %edx
movq 0x98(%r14), %rax
xorl %ecx, %ecx
cmpl $0x2, (%rax)
sete %cl
leal (%rdx,%rsi), %edi
addl 0x48(%r14), %esi
addq 0x8(%rax,%rcx,8), %rsi
movl %edi, 0x8(%r14)
movq %rbx, %rdi
callq 0x29903
jmp 0x536e8
leaq 0x13f9d(%rip), %rdx     # 0x67670
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x53722
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53722
movq (%rax), %rax
testq %rax, %rax
je 0x53722
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x53722
andl $0x0, 0x8(%rax)
pushq $0x1
popq %rsi
jmp 0x53736
leaq 0x13f47(%rip), %rdx     # 0x67670
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
xorl %esi, %esi
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x53796
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53796
movq (%rax), %rax
testq %rax, %rax
je 0x53796
cmpl $0xdead635a, 0xa0(%rax) # imm = 0xDEAD635A
jne 0x53796
movzwl 0x4c(%rax), %eax
cmpq $0x8, %rax
ja 0x537ea
leaq 0xf3de(%rip), %rcx      # 0x62b60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x13f12(%rip), %rsi     # 0x676a4
pushq $0x7
jmp 0x537df
leaq 0x13ed3(%rip), %rdx     # 0x67670
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x13461(%rip), %rsi     # 0x66c23
jmp 0x53792
leaq 0x13eca(%rip), %rsi     # 0x67695
jmp 0x53792
leaq 0x13ec9(%rip), %rsi     # 0x6769d
jmp 0x537dd
leaq 0x13eb1(%rip), %rsi     # 0x6768e
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x29903
jmp 0x537b2
leaq 0x13dce(%rip), %rsi     # 0x675bf
jmp 0x53792
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x53865
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53865
movq (%rax), %r14
testq %r14, %r14
je 0x53865
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x53865
movq (%r14), %rax
testq %rax, %rax
je 0x5388c
movq 0x68(%rax), %r12
testq %r12, %r12
je 0x53895
movq 0x8(%r14), %r15
movq 0x8(%rdx), %rdi
callq 0x297ae
movq %r15, %rdi
movq %rax, %rsi
callq *%r12
movl %eax, %r15d
testl %eax, %eax
jne 0x53857
movq %r14, %rdi
callq 0x562cb
xorl %esi, %esi
testl %r15d, %r15d
sete %sil
movq %rbx, %rdi
jmp 0x5387c
leaq 0x13e40(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13e8b(%rip), %r8      # 0x6771e
jmp 0x53898
movq (%rax), %r8
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x13e1d(%rip), %rdx     # 0x676c3
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x53877
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_fseek
static int jx9Builtin_fseek(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const jx9_io_stream *pStream;
	io_private *pDev;
	jx9_int64 iOfft;
	int whence;  
	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_int(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_int(pCtx, -1);
		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_function_name(pCtx), pStream ? pStream->zName : "null_stream"
			);
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Extract the offset */
	iOfft = jx9_value_to_int64(apArg[1]);
	whence = 0;/* SEEK_SET */
	if( nArg > 2 && jx9_value_is_int(apArg[2]) ){
		whence = jx9_value_to_int(apArg[2]);
	}
	/* Perform the requested operation */
	rc = pStream->xSeek(pDev->pHandle, iOfft, whence);
	if( rc == JX9_OK ){
		/* Ignore buffered data */
		ResetIOPrivate(pDev);
	}
	/* IO result */
	jx9_result_int(pCtx, rc == JX9_OK ? 0 : - 1);
	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 0x53952
movq %rdx, %r15
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53952
movq (%rax), %r14
testq %r14, %r14
je 0x53952
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x53952
movq (%r14), %r13
testq %r13, %r13
je 0x53980
cmpq $0x0, 0x48(%r13)
je 0x53989
movl %esi, %r12d
movq 0x8(%r15), %rdi
callq 0x297ae
xorl %edx, %edx
cmpl $0x2, %r12d
je 0x5392f
movq 0x10(%r15), %rdi
testb $0x2, 0x8(%rdi)
je 0x5392f
movq %rax, %r15
callq 0x29772
movl %eax, %edx
movq %r15, %rax
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq *0x48(%r13)
movl %eax, %r15d
testl %eax, %eax
jne 0x53949
movq %r14, %rdi
callq 0x562cb
xorl %esi, %esi
negl %r15d
sbbl %esi, %esi
jmp 0x53967
leaq 0x13d53(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x2987c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13d97(%rip), %r8      # 0x6771e
jmp 0x5398d
movq (%r13), %r8
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x13d8f(%rip), %rdx     # 0x6772a
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x53964
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x539f5
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x539f5
movq (%rax), %rax
testq %rax, %rax
je 0x539f5
cmpl $0xfeac14, 0x34(%rax)   # imm = 0xFEAC14
jne 0x539f5
movq (%rax), %rcx
testq %rcx, %rcx
je 0x53a1a
movq 0x60(%rcx), %rdx
testq %rdx, %rdx
je 0x53a23
movq 0x8(%rax), %rdi
callq *%rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29897
jmp 0x53a11
leaq 0x13cb0(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x13cfd(%rip), %r8      # 0x6771e
jmp 0x53a26
movq (%rcx), %r8
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x13c8f(%rip), %rdx     # 0x676c3
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x53a07
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x53aa7
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53aa7
movq (%rax), %r14
testq %r14, %r14
je 0x53aa7
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x53aa7
movq (%r14), %rcx
testq %rcx, %rcx
je 0x53ad0
movq 0x48(%rcx), %rax
testq %rax, %rax
je 0x53ad9
movq 0x8(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *%rax
movl %eax, %r15d
testl %eax, %eax
jne 0x53a99
movq %r14, %rdi
callq 0x562cb
xorl %esi, %esi
testl %r15d, %r15d
sete %sil
movq %rbx, %rdi
jmp 0x53abe
leaq 0x13bfe(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13c47(%rip), %r8      # 0x6771e
jmp 0x53adc
movq (%rcx), %r8
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x13bd9(%rip), %rdx     # 0x676c3
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x53ab9
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x53b44
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53b44
movq (%rax), %rax
testq %rax, %rax
je 0x53b44
cmpl $0xfeac14, 0x34(%rax)   # imm = 0xFEAC14
jne 0x53b44
movq (%rax), %rcx
testq %rcx, %rcx
je 0x53b69
movq 0x70(%rcx), %rdx
testq %rdx, %rdx
je 0x53b72
movq 0x8(%rax), %rdi
callq *%rdx
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
jmp 0x53b5b
leaq 0x13b61(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x13bae(%rip), %r8      # 0x6771e
jmp 0x53b75
movq (%rcx), %r8
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x13b40(%rip), %rdx     # 0x676c3
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x53b56
// File: /workspace/github_c_makefile_star2_O2/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 0x53c14
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53c14
movq (%rax), %r14
testq %r14, %r14
je 0x53c14
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x53c14
movq (%r14), %rax
testq %rax, %rax
je 0x53c41
movl 0x20(%r14), %ecx
xorl %esi, %esi
cmpl 0x30(%r14), %ecx
jne 0x53c29
movq 0x8(%r14), %rdi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq *0x30(%rax)
movq %rax, %r15
testq %rax, %rax
jle 0x53c09
addq $0x10, %r14
leaq -0x1020(%rbp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x2e250
xorl %esi, %esi
testq %r15, %r15
setle %sil
jmp 0x53c29
leaq 0x13a91(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x298b2
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 0x13a74(%rip), %rdx     # 0x676c3
leaq 0x13ac8(%rip), %r8      # 0x6771e
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x53c26
// File: /workspace/github_c_makefile_star2_O2/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 0x53cb3
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53cb3
movq (%rax), %rdi
testq %rdi, %rdi
je 0x53cb3
cmpl $0xfeac14, 0x34(%rdi)   # imm = 0xFEAC14
jne 0x53cb3
cmpq $0x0, (%rdi)
je 0x53cd8
leaq -0xc(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x562e8
testl %eax, %eax
jle 0x53cc5
leaq -0xc(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x29903
jmp 0x53ccf
leaq 0x139f2(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x139dd(%rip), %rdx     # 0x676c3
leaq 0x13a31(%rip), %r8      # 0x6771e
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x53cc5
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x53d39
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x53d39
movq (%rax), %r14
testq %r14, %r14
je 0x53d39
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x53d39
cmpq $0x0, (%r14)
je 0x53d60
cmpl $0x1, %esi
jne 0x53d84
pushq $-0x1
popq %rdx
jmp 0x53d90
leaq 0x1396c(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x13955(%rip), %rdx     # 0x676c3
leaq 0x139a9(%rip), %r8      # 0x6771e
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x53d4b
movq 0x8(%rdx), %rdi
callq 0x297ae
movq %rax, %rdx
leaq -0x18(%rbp), %rsi
movq %r14, %rdi
callq 0x56385
testq %rax, %rax
jle 0x53d4b
movq -0x18(%rbp), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x29903
jmp 0x53d55
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_fgetss
static int jx9Builtin_fgetss(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{
		const char *zTaglist = 0;
		int nTaglen = 0;
		if( nArg > 2 && jx9_value_is_string(apArg[2]) ){
			/* Allowed tag */
			zTaglist = jx9_value_to_string(apArg[2], &nTaglen);
		}
		/* Process data just read */
		jx9StripTagsFromString(pCtx, zLine, (int)n, zTaglist, nTaglen);
	}
	return JX9_OK;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x540a7
movq %rdx, %r14
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x540a7
movq (%rax), %r12
testq %r12, %r12
je 0x540a7
cmpl $0xfeac14, 0x34(%r12)   # imm = 0xFEAC14
jne 0x540a7
cmpq $0x0, (%r12)
je 0x540d2
movl %esi, %r15d
cmpl $0x1, %esi
jne 0x540f6
pushq $-0x1
popq %rdx
jmp 0x54102
leaq 0x135fe(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x135e3(%rip), %rdx     # 0x676c3
leaq 0x13637(%rip), %r8      # 0x6771e
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x540b9
movq 0x8(%r14), %rdi
callq 0x297ae
movq %rax, %rdx
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
callq 0x56385
testq %rax, %rax
jle 0x540b9
movq %rax, %r12
andl $0x0, -0x24(%rbp)
cmpl $0x3, %r15d
jb 0x5412a
movq 0x10(%r14), %rdi
testb $0x1, 0x8(%rdi)
jne 0x54131
xorl %r8d, %r8d
xorl %ecx, %ecx
jmp 0x54143
leaq -0x24(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movq %rax, %rcx
movl (%r14), %r8d
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0x4e9bd
jmp 0x540c3
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_readdir
static int jx9Builtin_readdir(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->xReadDir == 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;
	}
	jx9_result_bool(pCtx, 0);
	/* Perform the requested operation */
	rc = pStream->xReadDir(pDev->pHandle, pCtx);
	if( rc != JX9_OK ){
		/* Return FALSE */
		jx9_result_bool(pCtx, 0);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x541ad
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x541ad
movq (%rax), %r14
testq %r14, %r14
je 0x541ad
cmpl $0xfeac14, 0x34(%r14)   # imm = 0xFEAC14
jne 0x541ad
movq (%r14), %r15
testq %r15, %r15
je 0x541d6
cmpq $0x0, 0x38(%r15)
je 0x541df
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *0x38(%r15)
testl %eax, %eax
jne 0x541bf
jmp 0x541c9
leaq 0x134f8(%rip), %rdx     # 0x676ac
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13541(%rip), %r8      # 0x6771e
jmp 0x541e2
movq (%r15), %r8
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x134d3(%rip), %rdx     # 0x676c3
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
jmp 0x541bf