LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_disk_total_space
static int jx9Vfs_disk_total_space(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_int64 iSize;
	jx9_vfs *pVfs;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xTotalSpace == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	iSize = pVfs->xTotalSpace(zPath);
	/* IO return value */
	jx9_result_int64(pCtx, iSize);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %r15d
testl %esi, %esi
jle 0x5f257
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x5f25c
xorl %r14d, %r14d
jmp 0x5f2ab
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5f28e
cmpq $0x0, 0x88(%r14)
je 0x5f28e
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0x88(%r14)
movq %rax, %r14
movl $0x2, %r15d
jmp 0x5f2ab
movq 0x8(%rax), %rcx
leaq 0x182c4(%rip), %rdx     # 0x7755d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_file_size
static int jx9Vfs_file_size(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_int64 iSize;
	jx9_vfs *pVfs;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xFileSize == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	iSize = pVfs->xFileSize(zPath);
	/* IO return value */
	jx9_result_int64(pCtx, iSize);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %r15d
testl %esi, %esi
jle 0x5f389
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x5f38e
xorl %r14d, %r14d
jmp 0x5f3dd
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5f3c0
cmpq $0x0, 0x90(%r14)
je 0x5f3c0
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0x90(%r14)
movq %rax, %r14
movl $0x2, %r15d
jmp 0x5f3dd
movq 0x8(%rax), %rcx
leaq 0x18192(%rip), %rdx     # 0x7755d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_file_atime
static int jx9Vfs_file_atime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_int64 iTime;
	jx9_vfs *pVfs;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xFileAtime == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	iTime = pVfs->xFileAtime(zPath);
	/* IO return value */
	jx9_result_int64(pCtx, iTime);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %r15d
testl %esi, %esi
jle 0x5f427
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x5f42c
xorl %r14d, %r14d
jmp 0x5f47b
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5f45e
cmpq $0x0, 0x98(%r14)
je 0x5f45e
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0x98(%r14)
movq %rax, %r14
movl $0x2, %r15d
jmp 0x5f47b
movq 0x8(%rax), %rcx
leaq 0x180f4(%rip), %rdx     # 0x7755d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_file_ctime
static int jx9Vfs_file_ctime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_int64 iTime;
	jx9_vfs *pVfs;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xFileCtime == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	iTime = pVfs->xFileCtime(zPath);
	/* IO return value */
	jx9_result_int64(pCtx, iTime);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %r15d
testl %esi, %esi
jle 0x5f563
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x5f568
xorl %r14d, %r14d
jmp 0x5f5b7
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5f59a
cmpq $0x0, 0xa8(%r14)
je 0x5f59a
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0xa8(%r14)
movq %rax, %r14
movl $0x2, %r15d
jmp 0x5f5b7
movq 0x8(%rax), %rcx
leaq 0x17fb8(%rip), %rdx     # 0x7755d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_is_executable
static int jx9Vfs_is_executable(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xExecutable == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	rc = pVfs->xExecutable(zPath);
	/* IO return value */
	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 0x5f8bb
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5f8bb
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5f8a1
cmpq $0x0, 0xe0(%r14)
je 0x5f8a1
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0xe0(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5f8ce
movq 0x8(%rax), %rcx
leaq 0x17cb1(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_filetype
static int jx9Vfs_filetype(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_vfs *pVfs;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return 'unknown' */
		jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xFiletype == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Set the empty string as the default return value */
	jx9_result_string(pCtx, "", 0);
	/* Perform the requested operation */
	pVfs->xFiletype(zPath, pCtx);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x5f8fd
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x5f914
movq 0x8(%rbx), %rdi
leaq 0x17cd7(%rip), %rsi     # 0x775df
movl $0x7, %edx
callq 0x302f6
jmp 0x5f990
movq (%rbx), %rax
movq 0x20(%rax), %r15
testq %r15, %r15
je 0x5f955
cmpq $0x0, 0xe8(%r15)
je 0x5f955
xorl %esi, %esi
callq 0x30577
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq 0x17d33(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
movq %r14, %rdi
movq %rbx, %rsi
callq *0xe8(%r15)
jmp 0x5f990
movq 0x8(%rax), %rcx
leaq 0x17bfd(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_stat
static int jx9Vfs_stat(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray, *pValue;
	const char *zPath;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xStat == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Create the array and the working value */
	pArray = jx9_context_new_array(pCtx);
	pValue = jx9_context_new_scalar(pCtx);
	if( pArray == 0 || pValue == 0 ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the file path */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	rc = pVfs->xStat(zPath, pArray, pValue);
	if( rc != JX9_OK ){
		/* IO error, return FALSE */
		jx9_result_bool(pCtx, 0);
	}else{
		/* Return the associative array */
		jx9_result_value(pCtx, pArray);
	}
	/* Don't worry about freeing memory here, everything will be released
	 * automatically as soon we return from this function. */
	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 0x5fa39
movq %rdx, %r14
movq (%rdx), %rax
testb $0x1, 0x8(%rax)
je 0x5fa39
movq (%rbx), %rax
movq 0x20(%rax), %r13
testq %r13, %r13
je 0x5fa1f
cmpq $0x0, 0xb0(%r13)
je 0x5fa1f
movq %rbx, %rdi
callq 0x31231
movq %rax, %r15
movq %rbx, %rdi
callq 0x311eb
movq %rax, %r12
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x5fa6b
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x168bd(%rip), %rcx     # 0x762d0
movl $0x1, %edx
callq 0x40afa
jmp 0x5fa39
movq 0x8(%rax), %rcx
leaq 0x17b33(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 (%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0xb0(%r13)
testl %eax, %eax
jne 0x5fa39
movq %rbx, %rdi
movq %r15, %rsi
callq 0x307f4
jmp 0x5fa5a
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_lstat
static int jx9Vfs_lstat(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray, *pValue;
	const char *zPath;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xlStat == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Create the array and the working value */
	pArray = jx9_context_new_array(pCtx);
	pValue = jx9_context_new_scalar(pCtx);
	if( pArray == 0 || pValue == 0 ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the file path */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	rc = pVfs->xlStat(zPath, pArray, pValue);
	if( rc != JX9_OK ){
		/* IO error, return FALSE */
		jx9_result_bool(pCtx, 0);
	}else{
		/* Return the associative array */
		jx9_result_value(pCtx, pArray);
	}
	/* Don't worry about freeing memory here, everything will be released
	 * automatically as soon we return from this function. */
	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 0x5fb32
movq %rdx, %r14
movq (%rdx), %rax
testb $0x1, 0x8(%rax)
je 0x5fb32
movq (%rbx), %rax
movq 0x20(%rax), %r13
testq %r13, %r13
je 0x5fb18
cmpq $0x0, 0xb8(%r13)
je 0x5fb18
movq %rbx, %rdi
callq 0x31231
movq %rax, %r15
movq %rbx, %rdi
callq 0x311eb
movq %rax, %r12
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x5fb64
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x167c4(%rip), %rcx     # 0x762d0
movl $0x1, %edx
callq 0x40afa
jmp 0x5fb32
movq 0x8(%rax), %rcx
leaq 0x17a3a(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 (%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0xb8(%r13)
testl %eax, %eax
jne 0x5fb32
movq %rbx, %rdi
movq %r15, %rsi
callq 0x307f4
jmp 0x5fb53
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_getenv
static int jx9Vfs_getenv(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zEnv;
	jx9_vfs *pVfs;
	int iLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xGetenv == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the environment variable */
	zEnv = jx9_value_to_string(apArg[0], &iLen);
	/* Set a boolean FALSE as the default return value */
	jx9_result_bool(pCtx, 0);
	if( iLen < 1 ){
		/* Empty string */
		return JX9_OK;
	}
	/* Perform the requested operation */
	pVfs->xGetenv(zEnv, pCtx);
	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 0x5fc2b
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5fc2b
movq (%rbx), %rax
movq 0x20(%rax), %r13
testq %r13, %r13
je 0x5fc11
cmpq $0x0, 0xf0(%r13)
je 0x5fc11
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movq %rax, %r14
movq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x30465
movq $0x0, (%r12)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%r12), %eax
orl $0x8, %eax
movl %eax, 0x8(%r12)
cmpl $0x0, (%r15)
jle 0x5fc4c
movq %r14, %rdi
movq %rbx, %rsi
callq *0xf0(%r13)
jmp 0x5fc4c
movq 0x8(%rax), %rcx
leaq 0x17941(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_touch
static int jx9Vfs_touch(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_int64 nTime, nAccess;
	const char *zFile;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xTouch == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	nTime = nAccess = -1;
	zFile = jx9_value_to_string(apArg[0], 0);
	if( nArg > 1 ){
		nTime = jx9_value_to_int64(apArg[1]);
		if( nArg > 2 ){
			nAccess = jx9_value_to_int64(apArg[1]);
		}else{
			nAccess = nTime;
		}
	}
	rc = pVfs->xTouch(zFile, nTime, nAccess);
	/* 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
testl %esi, %esi
jle 0x5fe38
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5fe38
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5fe1e
cmpq $0x0, 0x100(%r12)
je 0x5fe1e
movl %esi, %r15d
xorl %esi, %esi
callq 0x30577
movq $-0x1, %rdx
movq $-0x1, %r13
cmpl $0x1, %r15d
je 0x5fe71
movq %rax, -0x30(%rbp)
movq 0x8(%r14), %r13
movq %r13, %rdi
callq 0x3f362
movq (%r13), %r13
cmpl $0x3, %r15d
jb 0x5fe6a
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x3f362
movq (%r14), %rdx
jmp 0x5fe6d
movq 0x8(%rax), %rcx
leaq 0x17734(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 %r13, %rdx
movq -0x30(%rbp), %rax
movq %rax, %rdi
movq %r13, %rsi
callq *0x100(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5fe4b
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_link
static int jx9Vfs_link(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zTarget, *zLink;
	jx9_vfs *pVfs;
	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;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xLink == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the given arguments */
	zTarget  = jx9_value_to_string(apArg[0], 0);
	zLink = jx9_value_to_string(apArg[1], 0);
	/* Perform the requested operation */
	rc = pVfs->xLink(zTarget, zLink, 0/*Not a symbolic link */);
	/* 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 0x5ff36
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5ff36
movq 0x8(%r14), %rax
testb $0x1, 0x8(%rax)
je 0x5ff36
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5ff1c
cmpq $0x0, 0x118(%r12)
je 0x5ff1c
xorl %esi, %esi
callq 0x30577
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq *0x118(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5ff49
movq 0x8(%rax), %rcx
leaq 0x17636(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_symlink
static int jx9Vfs_symlink(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zTarget, *zLink;
	jx9_vfs *pVfs;
	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;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xLink == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the given arguments */
	zTarget  = jx9_value_to_string(apArg[0], 0);
	zLink = jx9_value_to_string(apArg[1], 0);
	/* Perform the requested operation */
	rc = pVfs->xLink(zTarget, zLink, 1/*A symbolic link */);
	/* 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 0x60002
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x60002
movq 0x8(%r14), %rax
testb $0x1, 0x8(%rax)
je 0x60002
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5ffe8
cmpq $0x0, 0x118(%r12)
je 0x5ffe8
xorl %esi, %esi
callq 0x30577
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %r15, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq *0x118(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x60015
movq 0x8(%rax), %rcx
leaq 0x1756a(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_umask
static int jx9Vfs_umask(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iOld, iNew;
	jx9_vfs *pVfs;
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xUmask == 0 ){
		/* IO routine not implemented, return -1 */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS", 
			jx9_function_name(pCtx)
			);
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	iNew = 0;
	if( nArg > 0 ){
		iNew = jx9_value_to_int(apArg[0]);
	}
	/* Perform the requested operation */
	iOld = pVfs->xUmask(iNew);
	/* Old mask */
	jx9_result_int(pCtx, iOld);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x20(%rcx), %r15
testq %r15, %r15
je 0x6006e
movq 0x120(%r15), %rax
testq %rax, %rax
je 0x6006e
testl %esi, %esi
jle 0x6009d
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3f362
movl (%r14), %edi
movq 0x120(%r15), %rax
jmp 0x6009f
movq 0x8(%rcx), %rcx
leaq 0x17531(%rip), %rdx     # 0x775aa
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
jmp 0x600b6
xorl %edi, %edi
callq *%rax
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movslq %r14d, %rax
movq %rax, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %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_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_sys_get_temp_dir
static int jx9Vfs_sys_get_temp_dir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vfs *pVfs;
	/* Set the empty string as the default return value */
	jx9_result_string(pCtx, "", 0);
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xTempDir == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* IO routine not implemented, return "" */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS", 
			jx9_function_name(pCtx)
			);		
		return JX9_OK;
	}
	/* Perform the requested operation */
	pVfs->xTempDir(pCtx);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1758d(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
movq (%rbx), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x6010b
movq 0x128(%rcx), %rcx
testq %rcx, %rcx
je 0x6010b
movq %rbx, %rdi
callq *%rcx
jmp 0x60125
movq 0x8(%rax), %rcx
leaq 0x17494(%rip), %rdx     # 0x775aa
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_get_current_user
static int jx9Vfs_get_current_user(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vfs *pVfs;
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xUsername == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* IO routine not implemented */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS", 
			jx9_function_name(pCtx)
			);		
		/* Set a dummy username */
		jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
		return JX9_OK;
	}
	/* Perform the requested operation */
	pVfs->xUsername(pCtx);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x60156
movq 0x148(%rcx), %rcx
testq %rcx, %rcx
je 0x60156
movq %rbx, %rdi
callq *%rcx
jmp 0x60185
movq 0x8(%rax), %rcx
leaq 0x17449(%rip), %rdx     # 0x775aa
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rdi
leaq 0x17464(%rip), %rsi     # 0x775df
movl $0x7, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_getmypid
static int jx9Vfs_getmypid(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_int64 nProcessId;
	jx9_vfs *pVfs;
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xProcessId == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* IO routine not implemented, return -1 */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS", 
			jx9_function_name(pCtx)
			);
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Perform the requested operation */
	nProcessId = (jx9_int64)pVfs->xProcessId();
	/* Set the result */
	jx9_result_int64(pCtx, nProcessId);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x601b7
movq 0x130(%rcx), %rcx
testq %rcx, %rcx
je 0x601b7
callq *%rcx
movl %eax, %r14d
jmp 0x601d8
movq 0x8(%rax), %rcx
leaq 0x173e8(%rip), %rdx     # 0x775aa
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq $-0x1, %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_getmyuid
static int jx9Vfs_getmyuid(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vfs *pVfs;
	int nUid;
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xUid == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* IO routine not implemented, return -1 */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS", 
			jx9_function_name(pCtx)
			);
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Perform the requested operation */
	nUid = pVfs->xUid();
	/* Set the result */
	jx9_result_int(pCtx, nUid);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x60237
movq 0x138(%rcx), %rcx
testq %rcx, %rcx
je 0x60237
callq *%rcx
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movslq %r14d, %rax
movq %rax, (%rbx)
jmp 0x60264
movq 0x8(%rax), %rcx
leaq 0x17368(%rip), %rdx     # 0x775aa
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $-0x1, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_getmygid
static int jx9Vfs_getmygid(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vfs *pVfs;
	int nGid;
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xGid == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* IO routine not implemented, return -1 */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS", 
			jx9_function_name(pCtx)
			);
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Perform the requested operation */
	nGid = pVfs->xGid();
	/* Set the result */
	jx9_result_int(pCtx, nGid);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x602b4
movq 0x140(%rcx), %rcx
testq %rcx, %rcx
je 0x602b4
callq *%rcx
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movslq %r14d, %rax
movq %rax, (%rbx)
jmp 0x602e1
movq 0x8(%rax), %rcx
leaq 0x172eb(%rip), %rdx     # 0x775aa
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $-0x1, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_dirname
static int jx9Builtin_dirname(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath, *zDir;
	int iLen, iDirlen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Point to the target path */
	zPath = jx9_value_to_string(apArg[0], &iLen);
	if( iLen < 1 ){
		/* Reuturn "." */
		jx9_result_string(pCtx, ".", sizeof(char));
		return JX9_OK;
	}
	/* Perform the requested operation */
	zDir = jx9ExtractDirName(zPath, iLen, &iDirlen);
	/* Return directory name */
	jx9_result_string(pCtx, zDir, iDirlen);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x60406
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x60415
movq 0x8(%rbx), %rdi
leaq 0x17261(%rip), %rsi     # 0x77672
xorl %edx, %edx
jmp 0x60489
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movslq (%r14), %rcx
testq %rcx, %rcx
jle 0x60479
leaq -0x1(%rax), %rdx
movl $0x1, %edi
movq %rdi, %rsi
leaq (%rdx,%rcx), %r8
cmpq %rax, %r8
jbe 0x6044b
leaq 0x1(%rsi), %rdi
decq %rdx
cmpb $0x2f, (%r8)
jne 0x60432
movq %rcx, %rdi
subq %rsi, %rdi
jne 0x60458
cmpb $0x2f, (%rax)
jne 0x60499
cmpl $0x2, %edi
movl $0x1, %edx
cmovael %edi, %edx
cmpl %esi, %ecx
leaq 0x19140(%rip), %rcx     # 0x795ac
cmoveq %rcx, %rax
movq 0x8(%rbx), %rdi
movq %rax, %rsi
jmp 0x60489
movq 0x8(%rbx), %rdi
leaq 0x15234(%rip), %rsi     # 0x756b8
movl $0x1, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15218(%rip), %rax     # 0x756b8
movl $0x1, %edx
jmp 0x60470
// File: /workspace/github_c_makefile_star2_O3/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 0x60514
movq %rdx, %r12
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x60514
movl %esi, %r13d
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movq %rax, %r14
movslq (%r15), %rax
testq %rax, %rax
jle 0x60514
incq %rax
leaq (%r14,%rax), %rcx
addq $-0x2, %rcx
decq %rax
cmpq %r14, %rcx
jbe 0x60537
cmpb $0x2f, (%rcx)
je 0x604e5
movl %eax, -0x2c(%rbp)
leaq (%r14,%rax), %r15
decq %r15
cmpb $0x2f, (%r15)
je 0x6053f
decq %r15
cmpq %r14, %r15
ja 0x60504
jmp 0x6053a
movq 0x8(%rbx), %rdi
leaq 0x17153(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, -0x2c(%rbp)
movq %r14, %r15
jmp 0x60542
incq %r15
cltq
addq %rax, %r14
cmpl $0x1, %r13d
je 0x6058a
movq 0x8(%r12), %rdi
testb $0x1, 0x8(%rdi)
je 0x6058a
leaq -0x30(%rbp), %r12
movq %r12, %rsi
callq 0x30577
movslq (%r12), %rdx
testq %rdx, %rdx
jle 0x6058a
cmpl -0x2c(%rbp), %edx
jge 0x6058a
movq %r14, %r12
subq %rdx, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x347f1
testl %eax, %eax
jne 0x6058a
movq %r12, %r14
subl %r15d, %r14d
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movl %r14d, %edx
jmp 0x60521
// File: /workspace/github_c_makefile_star2_O3/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 0x60995
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x60995
movq 0x8(%r14), %rax
testb $0x1, 0x8(%rax)
jne 0x609c3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 0x30577
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %r15, %rdi
movq %rax, %rsi
movl $0x5c, %edx
xorl %ecx, %ecx
callq 0x64114
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
xorl %eax, %eax
testl %r14d, %r14d
setne %al
movq %rax, (%rbx)
jmp 0x609a8
// File: /workspace/github_c_makefile_star2_O3/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 0x60a32
movq %rdx, %r13
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x60a32
movq 0x8(%r13), %rax
testb $0x1, 0x8(%rax)
jne 0x60a64
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 0x30577
movq %rax, -0x30(%rbp)
movq 0x8(%r13), %rdi
xorl %esi, %esi
callq 0x30577
movq %rax, %r12
movl $0x5c, %edx
cmpl $0x2, %r15d
je 0x60aba
movq 0x10(%r13), %r15
testb $0x2, 0x8(%r15)
je 0x60aba
movq %r15, %rdi
callq 0x3f362
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 0x64114
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
xorl %eax, %eax
testl %r14d, %r14d
setne %al
movq %rax, (%rbx)
jmp 0x60a45
// File: /workspace/github_c_makefile_star2_O3/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 0x60ee1
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x60ee1
movq (%rax), %r14
testq %r14, %r14
je 0x60ee1
cmpl $0xdead635a, 0x50(%r14) # imm = 0xDEAD635A
jne 0x60ee1
movq %rdi, -0x30(%rbp)
cmpl $0x0, 0x38(%r14)
je 0x60eb3
movq 0x10(%r14), %r15
movq %r14, -0x38(%rbp)
movq 0x80(%r15), %rbx
movq 0x10(%r14), %rax
cmpq %r15, %rax
jne 0x60e1a
movq 0x80(%rax), %rax
movq %rax, 0x10(%r14)
movq 0x88(%r15), %rax
movq %rbx, %rcx
testq %rax, %rax
je 0x60e37
movq %rbx, 0x80(%rax)
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x60e43
movq %rax, 0x88(%rcx)
movq (%r14), %r12
cmpl $0x0, 0x60(%r15)
je 0x60e80
movq 0x78(%r15), %r13
movq 0x50(%r13), %rsi
movq 0x78(%r13), %r14
movl $0x2661, 0xa0(%r13) # imm = 0x2661
movq %r12, %rdi
callq 0x3490d
movq %r12, %rdi
movq %r13, %rsi
callq 0x2e659
decl 0x60(%r15)
movq %r14, %r13
jne 0x60e51
movl $0x2661, 0xa0(%r15) # imm = 0x2661
movq 0x50(%r15), %rsi
movq %r12, %rdi
callq 0x3490d
movq %r12, %rdi
movq %r15, %rsi
callq 0x2e659
movq -0x38(%rbp), %r14
decl 0x38(%r14)
movq %rbx, %r15
jne 0x60dff
movq (%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x3490d
movq $0x0, 0x8(%r14)
movl $0x2626, 0x50(%r14)     # imm = 0x2626
cmpl $0x2, 0x58(%r14)
jne 0x60f0e
leaq 0x60(%r14), %rdi
callq 0x317be
jmp 0x60f28
movq (%rdi), %rsi
movq 0x60(%rdi), %rdi
addq $0x8, %rsi
leaq 0x16785(%rip), %rcx     # 0x77678
movl $0x1, %edx
callq 0x40afa
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 0x60f28
movq 0x60(%r14), %rdi
movq 0x68(%r14), %rsi
callq *%rax
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x313b9
jmp 0x60efd
// File: /workspace/github_c_makefile_star2_O3/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 0x60fa6
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x60fa6
movq (%rax), %r14
testq %r14, %r14
je 0x60fa6
cmpl $0xdead635a, 0x50(%r14) # imm = 0xDEAD635A
jne 0x60fa6
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x60ff0
movq 0x80(%r15), %rax
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 0x60fe3
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x166c0(%rip), %rcx     # 0x77678
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
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 0x10(%r14), %rax
movq %rax, 0x8(%r14)
jmp 0x60fc2