LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_func_exists
static int vm_builtin_func_exists(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zName;
	jx9_vm *pVm;
	int nLen;
	int res;
	if( nArg < 1 ){
		/* Missing argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Extract the function name */
	zName = jx9_value_to_string(apArg[0], &nLen);
	/* Assume the function is not defined */
	res = 0;
	/* Perform the lookup */
	if( SyHashGet(&pVm->hFunction, (const void *)zName, (sxu32)nLen) != 0 ||
		SyHashGet(&pVm->hHostFunction, (const void *)zName, (sxu32)nLen) != 0 ){
			/* Function is defined */
			res = 1;
	}
	jx9_result_bool(pCtx, res);
	return SXRET_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 0x4f670
movq 0x60(%rbx), %r14
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30577
movq %rax, %r15
movl (%r12), %edx
testl %edx, %edx
je 0x4f636
cmpl $0x0, 0x330(%r14)
je 0x4f636
leaq 0x308(%r14), %rdi
movq %r15, %rsi
callq 0x448fa
testq %rax, %rax
jne 0x4f65b
movl -0x24(%rbp), %edx
testl %edx, %edx
je 0x4f670
cmpl $0x0, 0x2f0(%r14)
je 0x4f670
addq $0x2c8, %r14            # imm = 0x2C8
movq %r14, %rdi
movq %r15, %rsi
callq 0x448fa
testq %rax, %rax
je 0x4f670
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x1, (%rbx)
jmp 0x4f683
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 $0x10, %rsp
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: vm_builtin_is_callable
static int vm_builtin_is_callable(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vm *pVm;	
	int res;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Perform the requested operation */
	res = jx9VmIsCallable(pVm, apArg[0]);
	jx9_result_bool(pCtx, res);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x4f6d1
movq 0x60(%rbx), %rdi
movq (%rdx), %rsi
callq 0x511d0
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movl %r14d, %eax
movq %rax, (%rbx)
jmp 0x4f6e4
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: vm_builtin_get_defined_func
static int vm_builtin_get_defined_func(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray;
	/* NOTE:
	 * Don't worry about freeing memory here, every allocated resource will be released
	 * automatically by the engine as soon we return from this foreign function.
	 */
	pArray = jx9_context_new_array(pCtx);
 	if( pArray == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* Return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Fill with the appropriate information */
	SyHashForEach(&pCtx->pVm->hHostFunction,VmHashFuncStep,pArray);
	/* Fill with the appropriate information */
	SyHashForEach(&pCtx->pVm->hFunction, VmHashFuncStep,pArray);
	/* Return a copy of the array array */
	jx9_result_value(pCtx, pArray);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x31231
testq %rax, %rax
je 0x4f7a3
movq %rax, %r14
movq 0x60(%rbx), %r12
cmpl $0x0, 0x2f0(%r12)
je 0x4f75c
leaq 0x2e0(%r12), %r15
xorl %r13d, %r13d
movq (%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5125a
testl %eax, %eax
jne 0x4f758
addq $0x28, %r15
incl %r13d
cmpl 0x2f0(%r12), %r13d
jb 0x4f735
movq 0x60(%rbx), %r12
cmpl $0x0, 0x330(%r12)
je 0x4f795
leaq 0x320(%r12), %r15
xorl %r13d, %r13d
movq (%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5125a
testl %eax, %eax
jne 0x4f795
addq $0x28, %r15
incl %r13d
cmpl 0x330(%r12), %r13d
jb 0x4f772
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3e19f
jmp 0x4f7ac
movq 0x8(%rbx), %rdi
callq 0x30465
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: vm_builtin_defined
static int vm_builtin_defined(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zName;
	int nLen = 0;
	int res = 0;
	if( nArg < 1 ){
		/* Missing constant name, return FALSE */
		jx9_context_throw_error(pCtx,JX9_CTX_NOTICE,"Missing constant name");
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Extract constant name */
	zName = jx9_value_to_string(apArg[0], &nLen);
	/* Perform the lookup */
	if( nLen > 0 && SyHashGet(&pCtx->pVm->hConstant, (const void *)zName, (sxu32)nLen) != 0 ){
		/* Already defined */
		res = 1;
	}
	jx9_result_bool(pCtx, res);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, -0x14(%rbp)
testl %esi, %esi
jle 0x4f828
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %edx
testl %edx, %edx
jle 0x4f814
movq 0x60(%rbx), %rdi
cmpl $0x0, 0x2b0(%rdi)
je 0x4f814
addq $0x288, %rdi            # imm = 0x288
movq %rax, %rsi
callq 0x448fa
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
jmp 0x4f817
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x4f857
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x26ace(%rip), %rcx     # 0x76308
movl $0x3, %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 $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_get_defined_constants
static int vm_builtin_get_defined_constants(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray;
	/* Create the array first*/
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* Return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Fill the array with the defined constants */
	SyHashForEach(&pCtx->pVm->hConstant, VmHashConstStep, pArray);
	/* Return the created array */
	jx9_result_value(pCtx, pArray);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x31231
testq %rax, %rax
je 0x4f938
movq %rax, %r14
movq %rbx, -0x38(%rbp)
movq 0x60(%rbx), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x2b0(%rax)
je 0x4f94c
movq -0x30(%rbp), %rax
leaq 0x2a0(%rax), %rbx
xorl %r13d, %r13d
leaq -0x80(%rbp), %r15
movq (%rbx), %rbx
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x80(%rbp)
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rcx
movups %xmm0, (%rcx)
movq %rax, -0x68(%rbp)
movl $0x1, -0x78(%rbp)
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r15, %rdi
callq 0x3edf3
testb $0x40, 0x8(%r14)
je 0x4f943
movq (%r14), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3ef1d
movl %eax, %r12d
movq %r15, %rdi
callq 0x30465
testl %r12d, %r12d
jne 0x4f94c
addq $0x28, %rbx
incl %r13d
movq -0x30(%rbp), %rax
cmpl 0x2b0(%rax), %r13d
jb 0x4f8c0
jmp 0x4f94c
movq 0x8(%rbx), %rdi
callq 0x30465
jmp 0x4f95c
leaq -0x80(%rbp), %rdi
callq 0x30465
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x3e19f
xorl %eax, %eax
addq $0x58, %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: vm_builtin_rand
static int vm_builtin_rand(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	sxu32 iNum;
	/* Generate the random number */
	iNum = jx9VmRandomNum(pCtx->pVm);
	if( nArg > 1 ){
		sxu32 iMin, iMax;
		iMin = (sxu32)jx9_value_to_int(apArg[0]);
		iMax = (sxu32)jx9_value_to_int(apArg[1]);
		if( iMin < iMax ){
			sxu32 iDiv = iMax+1-iMin;
			if( iDiv > 0 ){
				iNum = (iNum % iDiv)+iMin;
			}
		}else if(iMax > 0 ){
			iNum %= iMax;
		}
	}
	/* Return the number */
	jx9_result_int64(pCtx, (jx9_int64)iNum);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
addq 0x60(%rbx), %rdi
leaq -0x24(%rbp), %r14
movq %r14, %rsi
movl $0x4, %edx
callq 0x39bca
movl (%r14), %r14d
cmpl $0x2, %r12d
jl 0x4f9ef
movq (%r15), %r12
movq %r12, %rdi
callq 0x3f362
movl (%r12), %r12d
movq 0x8(%r15), %r15
movq %r15, %rdi
callq 0x3f362
movl (%r15), %ecx
cmpl %ecx, %r12d
jae 0x4f9e1
incl %ecx
subl %r12d, %ecx
je 0x4f9ef
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r14d
addl %r12d, %r14d
jmp 0x4f9ef
testl %ecx, %ecx
je 0x4f9ef
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r14d
movl %r14d, %r14d
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
addq $0x10, %rsp
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: vm_builtin_rand_str
static int vm_builtin_rand_str(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	char zString[1024];
	int iLen = 0x10;
	if( nArg > 0 ){
		/* Get the desired length */
		iLen = jx9_value_to_int(apArg[0]);
		if( iLen < 1 || iLen > 1024 ){
			/* Default length */
			iLen = 0x10;
		}
	}
	/* Generate the random string */
	jx9VmRandomString(pCtx->pVm, zString, iLen);
	/* Return the generated string */
	jx9_result_string(pCtx, zString, iLen); /* Will make it's own copy */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
testl %esi, %esi
jle 0x4fa59
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3f362
movl (%r14), %eax
leal -0x401(%rax), %ecx
cmpl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
movl $0x10, %r14d
cmovael %eax, %r14d
jmp 0x4fa5f
movl $0x10, %r14d
movl $0x100, %edi            # imm = 0x100
addq 0x60(%rbx), %rdi
leaq -0x410(%rbp), %rsi
movl %r14d, %edx
callq 0x39bca
movl %r14d, %ecx
xorl %edi, %edi
movabsq $0x4ec4ec4ec4ec4ec5, %r8 # imm = 0x4EC4EC4EC4EC4EC5
leaq 0x28393(%rip), %r9      # 0x77e20
movsbq -0x410(%rbp,%rdi), %rsi
movq %rsi, %rax
mulq %r8
shrq $0x3, %rdx
leaq (%rdx,%rdx,4), %rax
leaq (%rax,%rax,4), %rax
addq %rdx, %rax
subq %rax, %rsi
movb (%r9,%rsi), %al
movb %al, -0x410(%rbp,%rdi)
incq %rdi
cmpq %rdi, %rcx
jne 0x4fa8d
movq 0x8(%rbx), %rdi
leaq -0x410(%rbp), %rsi
movl %ecx, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_getrandmax
static int vm_builtin_getrandmax(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SXUNUSED(nArg); /* cc warning */
	SXUNUSED(apArg);
	jx9_result_int64(pCtx, SXU32_HIGH);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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 %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_print
static int vm_builtin_print(jx9_context *pCtx, int nArg,jx9_value **apArg)
{
	const char *zData;
	int nDataLen = 0;
	jx9_vm *pVm;
	int i, rc;
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Output */
	for( i = 0 ; i < nArg ; ++i ){
		zData = jx9_value_to_string(apArg[i], &nDataLen);
		if( nDataLen > 0 ){
			rc = pVm->sVmConsumer.xConsumer((const void *)zData, (unsigned int)nDataLen, pVm->sVmConsumer.pUserData);
			/* Increment output length */
			pVm->nOutputLen += nDataLen;
			if( rc == SXERR_ABORT ){
				/* Output consumer callback request an operation abort */
				return JX9_ABORT;
			}
		}
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, -0x2c(%rbp)
testl %esi, %esi
jle 0x4fb77
movq %rdx, %rbx
movq 0x60(%rdi), %r15
movl %esi, %r12d
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r14
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x30577
movl -0x2c(%rbp), %esi
testl %esi, %esi
jle 0x4fb6f
movq 0x500(%r15), %rdx
movq %rax, %rdi
callq *0x4f8(%r15)
movl -0x2c(%rbp), %ecx
addl %ecx, 0x4f4(%r15)
cmpl $-0xa, %eax
je 0x4fb7b
incq %r13
cmpq %r13, %r12
jne 0x4fb3c
xorl %eax, %eax
jmp 0x4fb80
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
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: vm_builtin_exit
static int vm_builtin_exit(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg > 0 ){
		if( jx9_value_is_string(apArg[0]) ){
			const char *zData;
			int iLen = 0;
			/* Print exit message */
			zData = jx9_value_to_string(apArg[0], &iLen);
			jx9_context_output(pCtx, zData, iLen);
		}else if(jx9_value_is_int(apArg[0]) ){
			sxi32 iExitStatus;
			/* Record exit status code */
			iExitStatus = jx9_value_to_int(apArg[0]);
			pCtx->pVm->iExitStatus = iExitStatus;
		}
	}
	/* Abort processing immediately */
	return JX9_ABORT;
}

// Assembly:
testl %esi, %esi
jle 0x4fbf4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %r14
movl 0x8(%r14), %eax
testb $0x1, %al
jne 0x4fbc6
testb $0x2, %al
je 0x4fbea
movq %r14, %rdi
callq 0x3f362
movl (%r14), %eax
movq 0x60(%rbx), %rcx
movl %eax, 0x560(%rcx)
jmp 0x4fbea
leaq -0x1c(%rbp), %r15
movl $0x0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x30577
movl (%r15), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30e6e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_gettype
static int vm_builtin_gettype(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zType = "null";
	if( nArg > 0 ){
		zType = jx9MemObjTypeDump(apArg[0]);
	}
	/* Return the variable type */
	jx9_result_string(pCtx, zType, -1/*Compute length automatically*/);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4fc14
movq (%rdx), %rdi
callq 0x512d1
movq %rax, %rsi
jmp 0x4fc1b
leaq 0x26ec4(%rip), %rsi     # 0x76adf
movq 0x8(%rbx), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
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: vm_builtin_get_resource_type
static int vm_builtin_get_resource_type(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE*/
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	jx9_result_string_format(pCtx, "resID_%#x", apArg[0]->x.pOther);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x4fc45
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
jne 0x4fc68
movq 0x8(%rdi), %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)
jmp 0x4fc79
movq (%rax), %rdx
leaq 0x266c3(%rip), %rsi     # 0x76335
xorl %eax, %eax
callq 0x44e00
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: vm_builtin_dump
static int vm_builtin_dump(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyBlob sDump; /* Generated dump is stored here */
	int i;
	SyBlobInit(&sDump,&pCtx->pVm->sAllocator);
	/* Dump one or more expressions */
	for( i = 0 ; i < nArg ; i++ ){
		jx9_value *pObj = apArg[i];
		/* Reset the working buffer */
		SyBlobReset(&sDump);
		/* Dump the given expression */
		jx9MemObjDump(&sDump,pObj);
		/* Output */
		if( SyBlobLength(&sDump) > 0 ){
			jx9_context_output(pCtx, (const char *)SyBlobData(&sDump), (int)SyBlobLength(&sDump));
		}
	}
	/* Release the working buffer */
	SyBlobRelease(&sDump);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, -0x50(%rbp)
movq 0x60(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movl $0x0, -0x30(%rbp)
testl %esi, %esi
jle 0x4fe4b
movq %rdx, %rbx
movl %esi, %r12d
leaq -0x48(%rbp), %r15
xorl %r14d, %r14d
movq (%rbx,%r14,8), %r13
movl $0x0, -0x38(%rbp)
movl -0x30(%rbp), %eax
testb $0x4, %al
je 0x4fce9
movq $0x0, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
andl $-0x5, %eax
movl %eax, -0x30(%rbp)
movq %r13, %rdi
callq 0x512d1
cmpb $0x0, (%rax)
movq %rax, %rdx
je 0x4fd2f
movq %rax, %rdx
addq $0x2, %rdx
cmpb $0x0, -0x1(%rdx)
je 0x4fd27
cmpb $0x0, (%rdx)
je 0x4fd2f
cmpb $0x0, 0x1(%rdx)
je 0x4fd2c
leaq 0x4(%rdx), %rcx
cmpb $0x0, 0x2(%rdx)
movq %rcx, %rdx
jne 0x4fd00
addq $-0x2, %rcx
movq %rcx, %rdx
jmp 0x4fd2f
decq %rdx
jmp 0x4fd2f
incq %rdx
subl %eax, %edx
movq %r15, %rdi
movq %rax, %rsi
callq 0x359ad
testb $0x20, 0x8(%r13)
jne 0x4fdfe
movq %r15, %rdi
leaq 0x216a3(%rip), %rsi     # 0x713f4
movl $0x1, %edx
callq 0x359ad
movl 0x8(%r13), %eax
testb $0x40, %al
jne 0x4fd74
testb $0x1, %al
jne 0x4fdad
movq %r15, %rdi
movq %r13, %rsi
callq 0x3f581
jmp 0x4fdea
movq (%r13), %rax
movl 0x2c(%rax), %edx
movq %r15, %rdi
leaq 0x265ba(%rip), %rsi     # 0x7633f
xorl %eax, %eax
callq 0x3e26d
movl $0x0, -0x58(%rbp)
movq %r15, -0x68(%rbp)
movq $0x1, -0x60(%rbp)
movq %r13, %rdi
leaq -0x68(%rbp), %rsi
callq 0x3f650
jmp 0x4fdea
movl 0x28(%r13), %edx
movq %r15, %rdi
leaq 0x26588(%rip), %rsi     # 0x76343
xorl %eax, %eax
callq 0x3e26d
movl 0x28(%r13), %edx
testl %edx, %edx
je 0x4fdd6
movq 0x20(%r13), %rsi
movq %r15, %rdi
callq 0x359ad
movq %r15, %rdi
leaq 0x26566(%rip), %rsi     # 0x76346
movl $0x1, %edx
callq 0x359ad
movq %r15, %rdi
leaq 0x21ed0(%rip), %rsi     # 0x71cc4
movl $0x1, %edx
callq 0x359ad
movq %r15, %rdi
leaq 0x284d9(%rip), %rsi     # 0x782e1
movl $0x1, %edx
callq 0x359ad
movl -0x38(%rbp), %edx
testl %edx, %edx
je 0x4fe26
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x30e6e
incq %r14
cmpq %r12, %r14
jne 0x4fcc2
testb $0x6, -0x30(%rbp)
jne 0x4fe4b
cmpl $0x0, -0x34(%rbp)
je 0x4fe4b
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3490d
xorl %eax, %eax
addq $0x48, %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: vm_builtin_extract
static int vm_builtin_extract(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	extract_aux_data sAux;
	jx9_hashmap *pMap;
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing/Invalid arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Empty map, return  0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Prepare the aux data */
	SyZero(&sAux, sizeof(extract_aux_data)-sizeof(sAux.zWorker));
	if( nArg > 1 ){
		sAux.iFlags = jx9_value_to_int(apArg[1]);
		if( nArg > 2 ){
			sAux.zPrefix = jx9_value_to_string(apArg[2], &sAux.Prefixlen);
		}
	}
	sAux.pVm = pCtx->pVm;
	/* Invoke the worker callback */
	jx9HashmapWalk(pMap, VmExtractCallback, &sAux);
	/* Number of variables successfully imported */
	jx9_result_int(pCtx, sAux.iCount);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %rdi, %rbx
testl %esi, %esi
jle 0x4ff51
movq %rdx, %r15
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x4ff51
movq (%rax), %r14
cmpl $0x0, 0x2c(%r14)
je 0x4ff51
movl %esi, %r12d
movq $-0x4, %rax
movl $0x0, -0x444(%rbp,%rax)
addq $0x4, %rax
cmpq $0x1c, %rax
jb 0x4fece
cmpl $0x1, %r12d
je 0x4ff1c
movq 0x8(%r15), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %eax
movl %eax, -0x42c(%rbp)
cmpl $0x3, %r12d
jl 0x4ff1c
movq 0x10(%r15), %rdi
leaq -0x430(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movq %rax, -0x8(%r15)
movq 0x60(%rbx), %rax
leaq -0x448(%rbp), %r15
movq %rax, (%r15)
leaq 0x150f(%rip), %rsi      # 0x51440
movq %r14, %rdi
movq %r15, %rdx
callq 0x5134a
movslq 0x8(%r15), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x4ff64
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x428, %rsp            # imm = 0x428
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: vm_builtin_utf8_decode
static int vm_builtin_utf8_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nByte, c;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nByte);
	if( nByte < 1 ){
		/* Empty string, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	zEnd = &zIn[nByte];
	/* Start the decoding process */
	while( zIn < zEnd ){
		c = jx9Utf8Read(zIn, zEnd, &zIn);
		if( c == 0x0 ){
			break;
		}
		jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x504f4
movq (%rdx), %rdi
leaq -0x34(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movq %rax, -0x30(%rbp)
movslq (%r14), %r14
testq %r14, %r14
jle 0x504f4
movq %rax, %rdi
addq %rax, %r14
leaq -0x30(%rbp), %r15
leaq -0x24(%rbp), %r12
movq %r14, %rsi
movq %r15, %rdx
callq 0x5157c
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x504fd
movq 0x8(%rbx), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x302f6
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
jb 0x504c6
jmp 0x504fd
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x20, %rsp
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: vm_builtin_include
static int vm_builtin_include(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyString sFile;
	sxi32 rc;
	if( nArg < 1 ){
		/* Nothing to evaluate, return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* File to include */
	sFile.zString = jx9_value_to_string(apArg[0], (int *)&sFile.nByte);
	if( sFile.nByte < 1 ){
		/* Empty string, return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Open, compile and execute the desired script */
	rc = VmExecIncludedFile(&(*pCtx), &sFile, FALSE);
	if( rc != SXRET_OK ){
		/* Emit a warning and return false */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, "IO error while importing: '%z'", &sFile);
		jx9_result_bool(pCtx, 0);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x50797
movq (%rdx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movq %rax, -0x8(%r14)
cmpl $0x0, (%r14)
je 0x50797
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x51ae3
testl %eax, %eax
je 0x507a0
leaq 0x25ca2(%rip), %rdx     # 0x76403
leaq -0x20(%rbp), %rcx
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)
jmp 0x507a0
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_import
static int vm_builtin_import(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyString sFile;
	sxi32 rc;
	if( nArg < 1 ){
		/* Nothing to evaluate, return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* File to include */
	sFile.zString = jx9_value_to_string(apArg[0], (int *)&sFile.nByte);
	if( sFile.nByte < 1 ){
		/* Empty string, return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Open, compile and execute the desired script */
	rc = VmExecIncludedFile(&(*pCtx), &sFile, TRUE);
	if( rc == SXERR_EXISTS ){
		/* File already included, return TRUE */
		jx9_result_bool(pCtx, 1);
		return SXRET_OK;
	}
	if( rc != SXRET_OK ){
		/* Emit a warning and return false */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, "IO error while importing: '%z'", &sFile);
		jx9_result_bool(pCtx, 0);
 	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x50805
movq (%rdx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movq %rax, -0x8(%r14)
cmpl $0x0, (%r14)
je 0x50805
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x51ae3
testl %eax, %eax
je 0x5084b
cmpl $-0xb, %eax
jne 0x50810
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x1, (%rbx)
jmp 0x5083d
movq 0x8(%rbx), %rdi
callq 0x30465
jmp 0x5084b
leaq 0x25bec(%rip), %rdx     # 0x76403
leaq -0x20(%rbp), %rcx
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 $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmJsonDequoteString
static void VmJsonDequoteString(const SyString *pStr, jx9_value *pWorker)
{
	const char *zIn = pStr->zString;
	const char *zEnd = &pStr->zString[pStr->nByte];
	const char *zCur;
	int c;
	/* Mark the value as a string */
	jx9_value_string(pWorker, "", 0); /* Empty string */
	for(;;){
		zCur = zIn;
		while( zIn < zEnd && zIn[0] != '\\' ){
			zIn++;
		}
		if( zIn > zCur ){
			/* Append chunk verbatim */
			jx9_value_string(pWorker, zCur, (int)(zIn-zCur));
		}
		zIn++;
		if( zIn >= zEnd ){
			/* End of the input reached */
			break;
		}
		c = zIn[0];
		/* Unescape the character */
		switch(c){
		case '"':  jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char)); break;
		case '\\': jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char)); break;
		case 'n':  jx9_value_string(pWorker, "\n", (int)sizeof(char)); break;
		case 'r':  jx9_value_string(pWorker, "\r", (int)sizeof(char)); break;
		case 't':  jx9_value_string(pWorker, "\t", (int)sizeof(char)); break;
		case 'f':  jx9_value_string(pWorker, "\f", (int)sizeof(char)); break;
		default:
			jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char));
			break;
		}
		/* Advance the stream cursor */
		zIn++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r13
movl %esi, %r15d
addq %rdi, %r15
leaq 0x26555(%rip), %rsi     # 0x77672
movq %rdx, %rdi
xorl %edx, %edx
callq 0x302f6
leaq -0x2c(%rbp), %r12
cmpq %r15, %r13
jae 0x51159
movq %r13, %r14
cmpb $0x5c, (%r14)
je 0x51141
incq %r14
cmpq %r15, %r14
jb 0x51133
cmpq %r13, %r14
jbe 0x5115c
movl %r14d, %edx
subl %r13d, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x302f6
jmp 0x5115c
movq %r13, %r14
leaq 0x1(%r14), %rax
cmpq %r15, %rax
jae 0x511ab
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x66, %eax
rorb %al
movq %r12, %rsi
cmpb $0x7, %al
ja 0x51195
movzbl %al, %eax
movl $0xd1, %ecx
btl %eax, %ecx
movq %r12, %rsi
jae 0x51195
leaq 0x2240a(%rip), %rcx     # 0x73598
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x302f6
addq $0x2, %r14
movq %r14, %r13
jmp 0x5112b
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: jx9VmIsCallable
JX9_PRIVATE int jx9VmIsCallable(jx9_vm *pVm, jx9_value *pValue)
{
	int res = 0;
	if( pValue->iFlags & MEMOBJ_STRING ){
		const char *zName;
		int nLen;
		/* Extract the name */
		zName = jx9_value_to_string(pValue, &nLen);
		/* Perform the lookup */
		if( SyHashGet(&pVm->hFunction, (const void *)zName, (sxu32)nLen) != 0 ||
			SyHashGet(&pVm->hHostFunction, (const void *)zName, (sxu32)nLen) != 0 ){
				/* Function is callable */
				res = 1;
		}
	}
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r15d, %r15d
testb $0x1, 0x8(%rsi)
je 0x5124c
movq %rdi, %rbx
leaq -0x1c(%rbp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x30577
movq %rax, %r14
movl (%r15), %edx
testl %edx, %edx
je 0x5121f
cmpl $0x0, 0x330(%rbx)
je 0x5121f
leaq 0x308(%rbx), %rdi
movq %r14, %rsi
callq 0x448fa
testq %rax, %rax
jne 0x51246
movl -0x1c(%rbp), %edx
xorl %r15d, %r15d
testl %edx, %edx
je 0x5124c
cmpl $0x0, 0x2f0(%rbx)
je 0x5124c
addq $0x2c8, %rbx            # imm = 0x2C8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x448fa
testq %rax, %rax
je 0x5124c
movl $0x1, %r15d
movl %r15d, %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: VmHashFuncStep
static int VmHashFuncStep(SyHashEntry *pEntry, void *pUserData)
{
	jx9_value *pArray = (jx9_value *)pUserData;
	jx9_value sName;
	sxi32 rc;
	/* Prepare the function name for insertion */
	jx9MemObjInitFromString(pArray->pVm, &sName, 0);
	jx9MemObjStringAppend(&sName, (const char *)pEntry->pKey, pEntry->nKeyLen);
	/* Perform the insertion */
	rc = jx9_array_add_elem(pArray, 0/* Automatic index assign */, &sName); /* Will make it's own copy */
	jx9MemObjRelease(&sName);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq 0x10(%rsi), %rcx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl $0x1, 0x8(%rax)
movq (%rdi), %rsi
movl 0x8(%rdi), %edx
movq %rax, %rdi
callq 0x3edf3
movl $0xffffffe8, %r14d      # imm = 0xFFFFFFE8
testb $0x40, 0x8(%rbx)
je 0x512bc
movq (%rbx), %rdi
leaq -0x50(%rbp), %rdx
xorl %esi, %esi
callq 0x3ef1d
movl %eax, %r14d
leaq -0x50(%rbp), %rdi
callq 0x30465
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjTypeDump
JX9_PRIVATE const char * jx9MemObjTypeDump(jx9_value *pVal)
{
	const char *zType = "";
	if( pVal->iFlags & MEMOBJ_NULL ){
		zType = "null";
	}else if( pVal->iFlags & MEMOBJ_INT ){
		zType = "int";
	}else if( pVal->iFlags & MEMOBJ_REAL ){
		zType = "float";
	}else if( pVal->iFlags & MEMOBJ_STRING ){
		zType = "string";
	}else if( pVal->iFlags & MEMOBJ_BOOL ){
		zType = "bool";
	}else if( pVal->iFlags & MEMOBJ_HASHMAP ){
		jx9_hashmap *pMap = (jx9_hashmap *)pVal->x.pOther;
		if( pMap->iFlags & HASHMAP_JSON_OBJECT ){
			zType = "JSON Object";
		}else{
			zType = "JSON Array";
		}
	}else if( pVal->iFlags & MEMOBJ_RES ){
		zType = "resource";
	}
	return zType;
}

// Assembly:
movl 0x8(%rdi), %eax
testb $0x20, %al
jne 0x51303
testb $0x2, %al
jne 0x5130b
testb $0x4, %al
jne 0x51313
testb $0x1, %al
jne 0x5131b
testb $0x8, %al
jne 0x51323
testb $0x40, %al
jne 0x5132b
btl $0x8, %eax
leaq 0x2637b(%rip), %rcx     # 0x77672
leaq 0x25811(%rip), %rax     # 0x76b0f
cmovaeq %rcx, %rax
retq
leaq 0x257d5(%rip), %rax     # 0x76adf
retq
leaq 0x257a9(%rip), %rax     # 0x76abb
retq
leaq 0x25786(%rip), %rax     # 0x76aa0
retq
leaq 0x25a7f(%rip), %rax     # 0x76da1
retq
leaq 0x2576e(%rip), %rax     # 0x76a98
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
testb $0x1, 0x40(%rax)
leaq 0x24fed(%rip), %rcx     # 0x7632a
leaq 0x24fda(%rip), %rax     # 0x7631e
cmoveq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9HashmapWalk
JX9_PRIVATE sxi32 jx9HashmapWalk(
	jx9_hashmap *pMap, /* Target hashmap */
	int (*xWalk)(jx9_value *, jx9_value *, void *), /* Walker callback */
	void *pUserData /* Last argument to xWalk() */
	)
{
	jx9_hashmap_node *pEntry;
	jx9_value sKey, sValue;
	sxi32 rc;
	sxu32 n;
	/* Initialize walker parameter */
	rc = SXRET_OK;
	jx9MemObjInit(pMap->pVm, &sKey);
	jx9MemObjInit(pMap->pVm, &sValue);
	n = pMap->nEntry;
	pEntry = pMap->pFirst;
	/* Start the iteration process */
	for(;;){
		if( n < 1 ){
			break;
		}
		/* Extract a copy of the key and a copy the current value */
		jx9HashmapExtractNodeKey(pEntry, &sKey);
		jx9HashmapExtractNodeValue(pEntry, &sValue, FALSE);
		/* Invoke the user callback */
		rc = xWalk(&sKey, &sValue, pUserData);
		/* Release the copy of the key and the value */
		jx9MemObjRelease(&sKey);
		jx9MemObjRelease(&sValue);
		if( rc != JX9_OK ){
			/* Callback request an operation abort */
			return SXERR_ABORT;
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
		n--;
	}
	/* All done */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq (%rdi), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movq %rax, -0xb0(%rbp)
movq %rax, -0xa8(%rbp)
movl $0x20, %ecx
movl %ecx, -0xb8(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x50(%rbp)
movq %rax, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movl %ecx, -0x78(%rbp)
movl 0x2c(%rdi), %r14d
testl %r14d, %r14d
je 0x51425
movq %rdi, %r15
addq $0x10, %r15
leaq -0xc0(%rbp), %r12
leaq -0x80(%rbp), %r13
movq (%r15), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3e2fe
movq (%r15), %rax
movl 0x38(%r15), %esi
movq (%rax), %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x43f1e
movq %r12, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
callq *-0x30(%rbp)
movl %eax, %ebx
movq %r12, %rdi
callq 0x30465
movq %r13, %rdi
callq 0x30465
testl %ebx, %ebx
jne 0x51429
addq $0x48, %r15
decl %r14d
jne 0x513d7
xorl %eax, %eax
jmp 0x5142e
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
addq $0x98, %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: jx9Utf8Read
JX9_PRIVATE int jx9Utf8Read(
  const unsigned char *z,         /* First byte of UTF-8 character */
  const unsigned char *zTerm,     /* Pretend this byte is 0x00 */
  const unsigned char **pzNext    /* Write first byte past UTF-8 char here */
){
  int c;
  READ_UTF8(z, zTerm, c);
  *pzNext = z;
  return c;
}

// Assembly:
movzbl (%rdi), %eax
incq %rdi
cmpl $0xc0, %eax
jb 0x51604
pushq %rbp
movq %rsp, %rbp
addl $0xffffff40, %eax       # imm = 0xFFFFFF40
leaq 0x218c7(%rip), %rcx     # 0x72e60
movzbl (%rax,%rcx), %ecx
cmpq %rsi, %rdi
je 0x515cf
movzbl (%rdi), %eax
movl %eax, %r8d
andl $-0x40, %r8d
cmpl $0x80, %r8d
jne 0x515cf
movl %ecx, %r8d
shll $0x6, %r8d
incq %rdi
andl $0x3f, %eax
movl %eax, %ecx
orl %r8d, %ecx
cmpq %rsi, %rdi
jne 0x515a2
movq %rsi, %rdi
movl %ecx, %eax
andl $0x7ffff800, %eax       # imm = 0x7FFFF800
movl %ecx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
cmpl $0xd800, %eax           # imm = 0xD800
movl $0xfffd, %r8d           # imm = 0xFFFD
movl %ecx, %eax
cmovel %r8d, %eax
cmpl $0x80, %ecx
cmovll %r8d, %eax
cmpl $0xfffe, %esi           # imm = 0xFFFE
cmovel %r8d, %eax
popq %rbp
movq %rdi, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmProcessLongOpt
static int VmProcessLongOpt(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
	struct getopt_long_opt *pOpt = (struct getopt_long_opt *)pUserData;
	const char *zArg, *zOpt, *zEnd;
	int need_value = 0;
	int nByte;
	/* Value must be of type string */
	if( !jx9_value_is_string(pValue) ){
		/* Simply ignore */
		return JX9_OK;
	}
	zOpt = jx9_value_to_string(pValue, &nByte);
	if( nByte < 1 ){
		/* Empty string, ignore */
		return JX9_OK;
	}
	zEnd = &zOpt[nByte - 1];
	if( zEnd[0] == ':' ){
		char *zTerm;
		/* Try to extract a value */
		need_value = 1;
		while( zEnd >= zOpt && zEnd[0] == ':' ){
			zEnd--;
		}
		if( zOpt >= zEnd ){
			/* Empty string, ignore */
			SXUNUSED(pKey);
			return JX9_OK;
		}
		zEnd++;
		zTerm = (char *)zEnd;
		zTerm[0] = 0;
	}else{
		zEnd = &zOpt[nByte];
	}
	/* Find the option */
	zArg = VmFindLongOpt(zOpt, (int)(zEnd-zOpt), pOpt->zArgIn, pOpt->zArgEnd);
	if( zArg == 0 ){
		/* No such option, return immediately */
		return JX9_OK;
	}
	/* Try to extract a value */
	VmExtractOptArgValue(pOpt->pArray, pOpt->pWorker, zArg, pOpt->zArgEnd, need_value, pOpt->pCtx, zOpt);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x40(%rbp)
testb $0x1, 0x8(%rsi)
je 0x51aa4
leaq -0x4c(%rbp), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x30577
movq %rax, %rsi
movslq (%rbx), %rax
testq %rax, %rax
jle 0x51aa4
cmpb $0x3a, -0x1(%rsi,%rax)
jne 0x519ea
leaq (%rsi,%rax), %r15
decq %r15
cmpq %rsi, %r15
jb 0x519d0
addq %rsi, %rax
addq $-0x2, %rax
movq %rax, %r15
cmpq %rsi, %rax
jb 0x519d0
leaq -0x1(%r15), %rax
cmpb $0x3a, (%r15)
je 0x519be
cmpq %r15, %rsi
jae 0x51aa4
movb $0x0, 0x1(%r15)
incq %r15
movl $0x1, -0x34(%rbp)
jmp 0x519f7
movq %rsi, %r15
addq %rax, %r15
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %r14
movq 0x8(%rax), %r12
cmpq %r12, %r14
jae 0x51aa4
subl %esi, %r15d
leaq -0x2(%r12), %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x30(%rbp)
cmpb $0x2d, (%r14)
jne 0x51a92
leaq 0x1(%r14), %rax
cmpq %r12, %rax
jae 0x51a92
cmpb $0x2d, (%rax)
jne 0x51a92
leaq 0x2(%r14), %rbx
movq %rbx, %r13
cmpq %r12, %rbx
jae 0x51a73
callq 0xc170
movq (%rax), %rax
movq -0x48(%rbp), %rcx
subq %r14, %rcx
movq %rbx, %r13
movsbq (%r13), %rdx
cmpq $0x3d, %rdx
je 0x51a6f
movzwl (%rax,%rdx,2), %edx
andl $0x2000, %edx           # imm = 0x2000
jne 0x51a6f
incq %r13
decq %rcx
jne 0x51a4d
movq %r12, %r13
movq -0x30(%rbp), %rsi
movl %r13d, %eax
subl %ebx, %eax
cmpl %r15d, %eax
jne 0x51a98
movq %rbx, %rdi
movl %r15d, %edx
callq 0x347f1
testl %eax, %eax
je 0x51ab5
movq -0x30(%rbp), %rsi
jmp 0x51a98
incq %r14
movq %r14, %r13
movq %r13, %r14
cmpq %r12, %r13
jb 0x51a1b
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r13, %r13
movq -0x30(%rbp), %rcx
je 0x51aa4
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdi
movq 0x20(%rax), %r9
movq %rcx, (%rsp)
movq %r13, %rdx
movq %r12, %rcx
movl -0x34(%rbp), %r8d
callq 0x51608
jmp 0x51aa4
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9StreamReadWholeFile
JX9_PRIVATE sxi32 jx9StreamReadWholeFile(void *pHandle, const jx9_io_stream *pStream, SyBlob *pOut)
{
	jx9_int64 nRead;
	char zBuf[8192]; /* 8K */
	int rc;
	/* Perform the requested operation */
	for(;;){
		nRead = pStream->xRead(pHandle, zBuf, sizeof(zBuf));
		if( nRead < 1 ){
			/* EOF or IO error */
			break;
		}
		/* Append contents */
		rc = SyBlobAppend(pOut, zBuf, (sxu32)nRead);
		if( rc != SXRET_OK ){
			break;
		}
	}
	return SyBlobLength(pOut) > 0 ? SXRET_OK : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x2020(%rbp), %r12
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rdi
movq %r12, %rsi
callq *0x30(%r14)
testq %rax, %rax
jle 0x5207c
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x359ad
testl %eax, %eax
je 0x52057
xorl %eax, %eax
cmpl $0x1, 0x10(%rbx)
sbbl %eax, %eax
addq $0x2000, %rsp           # imm = 0x2000
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: JX9_TIME_Const
static void JX9_TIME_Const(jx9_value *pVal, void *pUnused)
{
	Sytm sTm;
#ifdef __WINNT__
	SYSTEMTIME sOS;
	GetSystemTime(&sOS);
	SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
	struct tm *pTm;
	time_t t;
	time(&t);
	pTm = gmtime(&t);
	STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
	SXUNUSED(pUnused); /* cc warning */
	/* Expand */
	jx9_value_string_format(pVal, "%02d:%02d:%02d", sTm.tm_hour, sTm.tm_min, sTm.tm_sec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0xc820
movq %r14, %rdi
callq 0xc2f0
movl 0x8(%rax), %edx
movl (%rax), %r8d
movl 0x4(%rax), %ecx
leaq 0x223e0(%rip), %rsi     # 0x745b2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x53415
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_DATE_Const
static void JX9_DATE_Const(jx9_value *pVal, void *pUnused)
{
	Sytm sTm;
#ifdef __WINNT__
	SYSTEMTIME sOS;
	GetSystemTime(&sOS);
	SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
	struct tm *pTm;
	time_t t;
	time(&t);
	pTm = gmtime(&t);
	STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
	SXUNUSED(pUnused); /* cc warning */
	/* Expand */
	jx9_value_string_format(pVal, "%04d-%02d-%02d", sTm.tm_year, sTm.tm_mon+1, sTm.tm_mday);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0xc820
movq %r14, %rdi
callq 0xc2f0
movl 0xc(%rax), %r8d
movl 0x10(%rax), %ecx
movl $0x76c, %edx            # imm = 0x76C
addl 0x14(%rax), %edx
incl %ecx
leaq 0x24804(%rip), %rsi     # 0x76a23
movq %rbx, %rdi
xorl %eax, %eax
callq 0x53415
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_FILE_Const
static void JX9_FILE_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	SyString *pFile;
	/* Peek the top entry */
	pFile = (SyString *)SySetPeek(&pVm->aFiles);
	if( pFile == 0 ){
		/* Expand the magic word: ":MEMORY:" */
		jx9_value_string(pVal, ":MEMORY:", (int)sizeof(":MEMORY:")-1);
	}else{
		jx9_value_string(pVal, pFile->zString, pFile->nByte);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x3f8(%rsi), %eax
testl %eax, %eax
je 0x5225f
movq 0x3f0(%rsi), %rcx
testq %rcx, %rcx
je 0x5225f
decl %eax
imull 0x400(%rsi), %eax
movq (%rcx,%rax), %rsi
movl 0x8(%rcx,%rax), %edx
jmp 0x5226b
leaq 0x247cc(%rip), %rsi     # 0x76a32
movl $0x8, %edx
popq %rbp
jmp 0x302f6
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_DIR_Const
static void JX9_DIR_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	SyString *pFile;
	/* Peek the top entry */
	pFile = (SyString *)SySetPeek(&pVm->aFiles);
	if( pFile == 0 ){
		/* Expand the magic word: ":MEMORY:" */
		jx9_value_string(pVal, ":MEMORY:", (int)sizeof(":MEMORY:")-1);
	}else{
		if( pFile->nByte > 0 ){
			const char *zDir;
			int nLen;
			zDir = jx9ExtractDirName(pFile->zString, (int)pFile->nByte, &nLen);
			jx9_value_string(pVal, zDir, nLen);
		}else{
			/* Expand '.' as the current directory*/
			jx9_value_string(pVal, ".", (int)sizeof(char));
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x3f8(%rsi), %ecx
testl %ecx, %ecx
je 0x522f3
movq 0x3f0(%rsi), %rdx
testq %rdx, %rdx
je 0x522f3
decl %ecx
imull 0x400(%rsi), %ecx
movslq 0x8(%rdx,%rcx), %rax
testq %rax, %rax
je 0x52301
movq (%rdx,%rcx), %rsi
leaq (%rax,%rsi), %rdx
decq %rdx
xorl %r8d, %r8d
movq %r8, %rcx
leaq (%rdx,%r8), %r9
cmpq %rsi, %r9
jbe 0x522c2
leaq -0x1(%rcx), %r8
cmpb $0x2f, (%r9)
jne 0x522ac
movl $0x1, %edx
subq %rax, %rdx
cmpq %rcx, %rdx
jne 0x522d4
cmpb $0x2f, (%rsi)
jne 0x52301
decl %eax
addq %rcx, %rax
cmpl $0x2, %eax
movl $0x1, %edx
cmovael %eax, %edx
testl %eax, %eax
leaq 0x272bf(%rip), %rax     # 0x795ac
cmoveq %rax, %rsi
jmp 0x5230d
leaq 0x24738(%rip), %rsi     # 0x76a32
movl $0x8, %edx
jmp 0x5230d
leaq 0x233b0(%rip), %rsi     # 0x756b8
movl $0x1, %edx
popq %rbp
jmp 0x302f6
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_STDIN_Const
static void JX9_STDIN_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStdin(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d0(%rsi), %r14
testq %r14, %r14
jne 0x53135
movq %rsi, %r15
movq %rsi, %rdi
movl $0x38, %esi
callq 0x33d86
testq %rax, %rax
je 0x53132
movq %rax, %r14
leaq 0x3f2dd(%rip), %rax     # 0x923d0
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r15, 0x10(%r14)
movl $0x0, 0x28(%r14)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x534df
movq %rax, 0x8(%r14)
movq %r14, 0x4d0(%r15)
jmp 0x53135
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x8(%rbx)
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: JX9_STDOUT_Const
static void JX9_STDOUT_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStdout(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d8(%rsi), %r14
testq %r14, %r14
jne 0x531d5
movq %rsi, %r15
movq %rsi, %rdi
movl $0x38, %esi
callq 0x33d86
testq %rax, %rax
je 0x531d2
movq %rax, %r14
leaq 0x3f23d(%rip), %rax     # 0x923d0
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r15, 0x10(%r14)
movl $0x0, 0x28(%r14)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r14)
movq %r15, %rdi
movl $0x2, %esi
callq 0x534df
movq %rax, 0x8(%r14)
movq %r14, 0x4d8(%r15)
jmp 0x531d5
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x8(%rbx)
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: JX9_STDERR_Const
static void JX9_STDERR_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStderr(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4e0(%rsi), %r14
testq %r14, %r14
jne 0x53275
movq %rsi, %r15
movq %rsi, %rdi
movl $0x38, %esi
callq 0x33d86
testq %rax, %rax
je 0x53272
movq %rax, %r14
leaq 0x3f19d(%rip), %rax     # 0x923d0
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r15, 0x10(%r14)
movl $0x0, 0x28(%r14)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r14)
movq %r15, %rdi
movl $0x3, %esi
callq 0x534df
movq %rax, 0x8(%r14)
movq %r14, 0x4e0(%r15)
jmp 0x53275
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq