LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_str_repeat
static int jx9Builtin_str_repeat(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen, nMul;
	int rc;
	if( nArg < 2 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string.Return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the multiplier */
	nMul = jx9_value_to_int(apArg[1]);
	if( nMul < 1 ){
		/* Return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( nMul < 1 ){
			break;
		}
		/* Append the copy */
		rc = jx9_result_string(pCtx, zIn, nLen);
		if( rc != JX9_OK ){
			/* Out of memory, break immediately */
			break;
		}
		nMul--;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jle 0x4a833
movq %rdx, %r15
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
cmpl $0x0, (%r12)
jle 0x4a833
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x29772
testl %eax, %eax
jle 0x4a84a
movl %eax, %r15d
testl %r15d, %r15d
jle 0x4a83b
movl -0x24(%rbp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29903
decl %r15d
jmp 0x4a81b
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ce01(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
jmp 0x4a83b
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_nl2br
static int jx9Builtin_nl2br(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn, *zCur, *zEnd;
	int is_xhtml = 0;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	if( nArg > 1 ){
		is_xhtml = jx9_value_to_bool(apArg[1]);
	}
	zEnd = &zIn[nLen];
	/* Perform the requested operation */
	for(;;){
		zCur = zIn;
		/* Delimit the string */
		while( zIn < zEnd && (zIn[0] != '\n'&& zIn[0] != '\r') ){
			zIn++;
		}
		if( zCur < zIn ){
			/* Output chunk verbatim */
			jx9_result_string(pCtx, zCur, (int)(zIn-zCur));
		}
		if( zIn >= zEnd ){
			/* No more input to process */
			break;
		}
		/* Output the HTML line break */
		if( is_xhtml ){
			jx9_result_string(pCtx, "<br>", (int)sizeof("<br>")-1);
		}else{
			jx9_result_string(pCtx, "<br/>", (int)sizeof("<br/>")-1);
		}
		zCur = zIn;
		/* Append trailing line */
		while( zIn < zEnd && (zIn[0] == '\n'  || zIn[0] == '\r') ){
			zIn++;
		}
		if( zCur < zIn ){
			/* Output chunk verbatim */
			jx9_result_string(pCtx, zCur, (int)(zIn-zCur));
		}
	}
	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 0x4a945
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
movq %rax, %r14
movl (%r13), %eax
testl %eax, %eax
jle 0x4a958
movb $0x1, %r13b
cmpl $0x1, %r12d
je 0x4a8b5
movq 0x8(%r15), %rdi
callq 0x29790
testl %eax, %eax
sete %r13b
movl -0x2c(%rbp), %eax
movslq %eax, %r15
addq %r14, %r15
xorl %edx, %edx
leaq (%r14,%rdx), %r12
cmpq %r15, %r12
jae 0x4a8da
movzbl (%r12), %eax
cmpl $0xa, %eax
je 0x4a8da
cmpl $0xd, %eax
je 0x4a8da
incq %rdx
jmp 0x4a8bd
cmpq %r12, %r14
jae 0x4a8ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29903
cmpq %r15, %r12
jae 0x4a960
movq %rbx, %rdi
testb %r13b, %r13b
je 0x4a902
leaq 0x1c64a(%rip), %rsi     # 0x66f48
pushq $0x5
jmp 0x4a90b
leaq 0x16b3f(%rip), %rsi     # 0x61448
pushq $0x4
popq %rdx
callq 0x29903
xorl %edx, %edx
movq %r12, %r14
cmpq %r15, %r14
jae 0x4a930
movzbl (%r14), %eax
cmpl $0xd, %eax
je 0x4a929
cmpl $0xa, %eax
jne 0x4a930
incq %r14
incl %edx
jmp 0x4a916
cmpq %r14, %r12
jae 0x4a8bb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29903
jmp 0x4a8bb
leaq 0x1cd06(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
jmp 0x4a960
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_sprintf
static int jx9Builtin_sprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zFormat;
	int nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the string format */
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Format the string */
	jx9InputFormat(sprintfConsumer, pCtx, zFormat, nLen, nArg, apArg, 0, FALSE);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4a9ca
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x4a9ca
movl %esi, %r15d
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x4a9ca
leaq 0x3dc0(%rip), %rdi      # 0x4e771
movq %rbx, %rsi
movq %rax, %rdx
movl %r15d, %r8d
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x4db70
popq %rax
popq %rcx
jmp 0x4a9db
leaq 0x1cc81(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_printf
static int jx9Builtin_printf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_int64 nCounter = 0;
	const char *zFormat;
	int nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the string format */
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Format the string */
	jx9InputFormat(printfConsumer, pCtx, zFormat, nLen, nArg, apArg, (void *)&nCounter, FALSE);
	/* Return the length of the outputted string */
	jx9_result_int64(pCtx, nCounter);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andq $0x0, -0x28(%rbp)
testl %esi, %esi
jle 0x4aa58
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x4aa58
movl %esi, %r15d
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x4aa58
leaq -0x28(%rbp), %r12
leaq 0x3d4b(%rip), %rdi      # 0x4e77e
movq %rbx, %rsi
movq %rax, %rdx
movl %r15d, %r8d
movq %r14, %r9
pushq $0x0
pushq %r12
callq 0x4db70
popq %rax
popq %rcx
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x29897
jmp 0x4aa62
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_vprintf
static int jx9Builtin_vprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_int64 nCounter = 0;
	const char *zFormat;
	jx9_hashmap *pMap;
	SySet sArg;
	int nLen, n;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
		/* Missing/Invalid arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the string format */
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the hashmap */
	pMap = (jx9_hashmap *)apArg[1]->x.pOther;
	/* Extract arguments from the hashmap */
	n = jx9HashmapValuesToSet(pMap, &sArg);
	/* Format the string */
	jx9InputFormat(printfConsumer, pCtx, zFormat, nLen, n, (jx9_value **)SySetBasePtr(&sArg), (void *)&nCounter, TRUE);
	/* Return the length of the outputted string */
	jx9_result_int64(pCtx, nCounter);
	/* Release the container */
	SySetRelease(&sArg);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
andq $0x0, -0x30(%rbp)
cmpl $0x2, %esi
jl 0x4ab08
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x4ab08
movq 0x8(%r14), %rax
testb $0x40, 0x8(%rax)
je 0x4ab08
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
cmpl $0x0, (%r12)
jle 0x4ab08
movq %rax, %r15
movq 0x8(%r14), %rax
movq (%rax), %rdi
leaq -0x58(%rbp), %r14
movq %r14, %rsi
callq 0x4e79d
movl -0x24(%rbp), %ecx
movq 0x8(%r14), %r9
leaq -0x30(%rbp), %r12
leaq 0x3ca0(%rip), %rdi      # 0x4e77e
movq %rbx, %rsi
movq %r15, %rdx
movl %eax, %r8d
pushq $0x1
pushq %r12
callq 0x4db70
popq %rax
popq %rcx
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x29897
movq %r14, %rdi
callq 0x31feb
jmp 0x4ab12
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_vsprintf
static int jx9Builtin_vsprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zFormat;
	jx9_hashmap *pMap;
	SySet sArg;
	int nLen, n;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
		/* Missing/Invalid arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the string format */
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Point to hashmap */
	pMap = (jx9_hashmap *)apArg[1]->x.pOther;
	/* Extract arguments from the hashmap */
	n = jx9HashmapValuesToSet(pMap, &sArg);
	/* Format the string */
	jx9InputFormat(sprintfConsumer, pCtx, zFormat, nLen, n, (jx9_value **)SySetBasePtr(&sArg), 0, TRUE);
	/* Release the container */
	SySetRelease(&sArg);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x4aba3
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x4aba3
movq 0x8(%r14), %rax
testb $0x40, 0x8(%rax)
je 0x4aba3
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
cmpl $0x0, (%r12)
jle 0x4aba3
movq %rax, %r15
movq 0x8(%r14), %rax
movq (%rax), %rdi
leaq -0x50(%rbp), %r14
movq %r14, %rsi
callq 0x4e79d
movl -0x24(%rbp), %ecx
movq 0x8(%r14), %r9
leaq 0x3bec(%rip), %rdi      # 0x4e771
movq %rbx, %rsi
movq %r15, %rdx
movl %eax, %r8d
pushq $0x1
pushq $0x0
callq 0x4db70
popq %rax
popq %rcx
movq %r14, %rdi
callq 0x31feb
jmp 0x4abb4
leaq 0x1caa8(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_size_format
static int jx9Builtin_size_format(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	/*Kilo*/ /*Mega*/ /*Giga*/ /*Tera*/ /*Peta*/ /*Exa*/ /*Zeta*/
	static const char zUnit[] = {"KMGTPEZ"};
	sxi32 nRest, i_32;
	jx9_int64 iSize;
	int c = -1; /* index in zUnit[] */

	if( nArg < 1 ){
		/* Missing argument, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the given size */
	iSize = jx9_value_to_int64(apArg[0]);
	if( iSize < 100 /* Bytes */ ){
		/* Don't bother formatting, return immediately */
		jx9_result_string(pCtx, "0.1 KB", (int)sizeof("0.1 KB")-1);
		return JX9_OK;
	}
	for(;;){
		nRest = (sxi32)(iSize & 0x3FF); 
		iSize >>= 10;
		c++;
		if( (iSize & (~0 ^ 1023)) == 0 ){
			break;
		}
	}
	nRest /= 100;
	if( nRest > 9 ){
		nRest = 9;
	}
	if( iSize > 999 ){
		c++;
		nRest = 9;
		iSize = 0;
	}
	i_32 = (sxi32)iSize;
	/* Format */
	jx9_result_string_format(pCtx, "%d.%d %cB", i_32, nRest, zUnit[c]);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4abed
movq (%rdx), %rdi
callq 0x297ae
cmpq $0x64, %rax
jge 0x4ac00
leaq 0x1c371(%rip), %rsi     # 0x66f56
pushq $0x6
popq %rdx
movq %rbx, %rdi
jmp 0x4abf9
leaq 0x1ca5e(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
jmp 0x4ac6f
movq %rax, %r9
xorl %esi, %esi
movq %r9, %rdi
shrq $0xa, %r9
incl %esi
cmpq $0xfffff, %rdi          # imm = 0xFFFFF
ja 0x4ac05
movl %edi, %eax
andl $0x3fc, %eax            # imm = 0x3FC
xorl %r8d, %r8d
movw $0x64, %cx
xorl %edx, %edx
divw %cx
cmpw $0x9, %ax
pushq $0x9
popq %rdx
movl %edx, %ecx
cmovbl %eax, %ecx
movzwl %cx, %ecx
leal -0x1(%rsi), %eax
cmpq $0xfa000, %rdi          # imm = 0xFA000
cmovael %edx, %ecx
cmovael %esi, %eax
cmovael %r8d, %r9d
cltq
leaq 0x1c2f8(%rip), %rdx     # 0x66f4e
movsbl (%rax,%rdx), %r8d
leaq 0x1c2fb(%rip), %rsi     # 0x66f5d
movq %rbx, %rdi
movl %r9d, %edx
xorl %eax, %eax
callq 0x3bdad
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strip_tags
static int jx9Builtin_strip_tags(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zTaglist = 0;
	const char *zString;
	int nTaglen = 0;
	int nLen;
	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 raw string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nArg > 1 && jx9_value_is_string(apArg[1]) ){
		/* Allowed tag */
		zTaglist = jx9_value_to_string(apArg[1], &nTaglen);		
	}
	/* Process input */
	jx9StripTagsFromString(pCtx, zString, nLen, zTaglist, nTaglen);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andl $0x0, -0x28(%rbp)
testl %esi, %esi
jle 0x4addc
movq %rdx, %r15
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x4adef
leaq 0x1c86f(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
jmp 0x4ae35
movl %esi, %r12d
leaq -0x24(%rbp), %rsi
callq 0x297ed
movq %rax, %r14
cmpl $0x1, %r12d
je 0x4ae0e
movq 0x8(%r15), %rdi
testb $0x1, 0x8(%rdi)
jne 0x4ae15
xorl %r8d, %r8d
xorl %ecx, %ecx
jmp 0x4ae27
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movq %rax, %rcx
movl (%r15), %r8d
movl -0x24(%rbp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e9bd
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strpbrk
static int jx9Builtin_strpbrk(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString, *zList, *zEnd;
	int iLen, iListLen, i, c;
	sxu32 nOfft, nMax;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the haystack and the char list */
	zString = jx9_value_to_string(apArg[0], &iLen);
	zList = jx9_value_to_string(apArg[1], &iListLen);
	if( iLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the end of the string */
	zEnd = &zString[iLen];
	nOfft = nMax = SXU32_HIGH;
	/* perform the requested operation */
	for( i = 0 ; i < iListLen ; i++ ){
		c = zList[i];
		rc = SyByteFind(zString, (sxu32)iLen, c, &nMax);
		if( rc == SXRET_OK ){
			if( nMax < nOfft ){
				nOfft = nMax;
			}
		}
	}
	if( nOfft == SXU32_HIGH ){
		/* No such substring, return FALSE */
		jx9_result_bool(pCtx, 0);
	}else{
		/* Return the substring */
		jx9_result_string(pCtx, &zString[nOfft], (int)(zEnd-&zString[nOfft]));
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jle 0x4b294
movq %rdx, %r15
movq (%rdx), %rdi
leaq -0x38(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
movq %rax, %r14
movq 0x8(%r15), %rdi
leaq -0x34(%rbp), %rsi
callq 0x297ed
movq %rax, %r12
movl (%r13), %eax
testl %eax, %eax
jle 0x4b294
movl %eax, -0x30(%rbp)
movq %rbx, -0x40(%rbp)
leaq -0x2c(%rbp), %rax
orl $-0x1, (%rax)
movslq -0x34(%rbp), %r15
pushq $-0x1
popq %rbx
xorl %r13d, %r13d
cmpq %r15, %r13
jge 0x4b2af
movsbl (%r12,%r13), %edx
movl -0x38(%rbp), %esi
movq %r14, %rdi
leaq -0x2c(%rbp), %rcx
callq 0x3df83
movl -0x2c(%rbp), %ecx
cmpl %ebx, %ecx
cmovael %ebx, %ecx
testl %eax, %eax
cmovel %ecx, %ebx
incq %r13
jmp 0x4b269
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x1, %ebx
je 0x4b2cc
movl %ebx, %eax
addq %rax, %r14
movl -0x30(%rbp), %edx
subl %ebx, %edx
movq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x29903
jmp 0x4b29e
movq -0x40(%rbp), %rdi
jmp 0x4b297
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_soundex
static int jx9Builtin_soundex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn;
	char zResult[8];
	int i, j;
	static const unsigned char iCode[] = {
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
		0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 
		1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 
		0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 
		1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 
	};
	if( nArg < 1 ){
		/* Missing arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	zIn = (unsigned char *)jx9_value_to_string(apArg[0], 0);
	for(i=0; zIn[i] && zIn[i] < 0xc0 && !SyisAlpha(zIn[i]); i++){}
	if( zIn[i] ){
		unsigned char prevcode = iCode[zIn[i]&0x7f];
		zResult[0] = (char)SyToUpper(zIn[i]);
		for(j=1; j<4 && zIn[i]; i++){
			int code = iCode[zIn[i]&0x7f];
			if( code>0 ){
				if( code!=prevcode ){
					prevcode = (unsigned char)code;
					zResult[j++] = (char)code + '0';
				}
			}else{
				prevcode = 0;
			}
		}
		while( j<4 ){
			zResult[j++] = '0';
		}
		jx9_result_string(pCtx, zResult, 4);
	}else{
	  jx9_result_string(pCtx, "?000", 4);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
testl %esi, %esi
jle 0x4b31a
movq (%rdx), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x297ed
movq %rax, %r14
movzbl (%r14,%r12), %ebx
leal -0x1(%rbx), %eax
cmpb $-0x42, %al
ja 0x4b32b
callq 0xc190
movq (%rax), %rax
testb $0x4, 0x1(%rax,%rbx,2)
jne 0x4b334
incq %r12
jmp 0x4b2fa
leaq 0x1c331(%rip), %rsi     # 0x67652
movq %r15, %rdi
xorl %edx, %edx
jmp 0x4b3b7
testq %rbx, %rbx
je 0x4b3cd
movq %r15, -0x38(%rbp)
movl %ebx, %eax
andl $0x7f, %eax
leaq 0x17b6c(%rip), %r15     # 0x62eb0
movb (%rax,%r15), %r13b
callq 0xc360
movq (%rax), %rax
movb (%rax,%rbx,4), %al
movb %al, -0x30(%rbp)
movl %r12d, %eax
addq %rax, %r14
pushq $0x1
popq %rax
cmpl $0x3, %eax
jg 0x4b39a
movzbl (%r14), %ecx
testq %rcx, %rcx
je 0x4b39a
andl $0x7f, %ecx
movb (%rcx,%r15), %cl
testb %cl, %cl
je 0x4b382
cmpb %r13b, %cl
jne 0x4b386
movl %r13d, %ecx
jmp 0x4b392
xorl %ecx, %ecx
jmp 0x4b392
leal 0x30(%rcx), %edx
movslq %eax, %rsi
incl %eax
movb %dl, -0x30(%rbp,%rsi)
incq %r14
movl %ecx, %r13d
jmp 0x4b35f
cltq
movq -0x38(%rbp), %rdi
cmpq $0x3, %rax
jg 0x4b3b0
movb $0x30, -0x30(%rbp,%rax)
incq %rax
jmp 0x4b3a0
leaq -0x30(%rbp), %rsi
pushq $0x4
popq %rdx
callq 0x29903
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bb93(%rip), %rsi     # 0x66f67
pushq $0x4
popq %rdx
movq %r15, %rdi
jmp 0x4b3b7
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_wordwrap
static int jx9Builtin_wordwrap(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn, *zEnd, *zBreak;
	int iLen, iBreaklen, iChunk;
	if( nArg < 1 ){
		/* Missing arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &iLen);
	if( iLen < 1 ){
		/* Nothing to process, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Chunk length */
	iChunk = 75;
	iBreaklen = 0;
	zBreak = ""; /* cc warning */
	if( nArg > 1 ){
		iChunk = jx9_value_to_int(apArg[1]);
		if( iChunk < 1 ){
			iChunk = 75;
		}
		if( nArg > 2 ){
			zBreak = jx9_value_to_string(apArg[2], &iBreaklen);
		}
	}
	if( iBreaklen < 1 ){
		/* Set a default column break */
#ifdef __WINNT__
		zBreak = "\r\n";
		iBreaklen = (int)sizeof("\r\n")-1;
#else
		zBreak = "\n";
		iBreaklen = (int)sizeof(char);
#endif
	}
	/* Perform the requested operation */
	zEnd = &zIn[iLen];
	for(;;){
		int nMax;
		if( zIn >= zEnd ){
			/* No more input to process */
			break;
		}
		nMax = (int)(zEnd-zIn);
		if( iChunk > nMax ){
			iChunk = nMax;
		}
		/* Append the column first */
		jx9_result_string(pCtx, zIn, iChunk); /* Will make it's own copy */
		/* Advance the cursor */
		zIn += iChunk;
		if( zIn < zEnd ){
			/* Append the line break */
			jx9_result_string(pCtx, zBreak, iBreaklen);
		}
	}
	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 0x4b41f
movq %rdx, %r12
movl %esi, %r13d
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
cmpl $0x0, (%r15)
jle 0x4b41f
movq %rax, %r14
andl $0x0, -0x2c(%rbp)
cmpl $0x1, %r13d
jne 0x4b441
pushq $0x4b
popq %r15
jmp 0x4b478
leaq 0x1c22c(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r12), %rdi
callq 0x29772
testl %eax, %eax
pushq $0x4b
popq %r15
cmovgl %eax, %r15d
cmpl $0x3, %r13d
jb 0x4b478
movq 0x10(%r12), %rdi
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
cmpl $0x0, (%r13)
jle 0x4b478
movq %rax, %r12
jmp 0x4b486
movl $0x1, -0x2c(%rbp)
leaq 0x1ce3b(%rip), %r12     # 0x682c1
movslq -0x30(%rbp), %r13
addq %r14, %r13
cmpq %r13, %r14
jae 0x4b430
movl %r13d, %eax
subl %r14d, %eax
cmpl %eax, %r15d
cmovgel %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x29903
movslq %r15d, %rax
addq %rax, %r14
cmpq %r13, %r14
jae 0x4b48d
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29903
jmp 0x4b48d
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_parse_ini_string
static int jx9Builtin_parse_ini_string(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIni;
	int nByte;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE*/
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the raw INI buffer */
	zIni = jx9_value_to_string(apArg[0], &nByte);
	/* Process the INI buffer*/
	jx9ParseIniString(pCtx, zIni, (sxu32)nByte, (nArg > 1) ? jx9_value_to_bool(apArg[1]) : 0);
	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 0x4bd11
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x4bd1d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
jmp 0x4bd54
movl %esi, %r12d
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
movq %rax, %r15
movl (%r13), %r13d
xorl %ecx, %ecx
cmpl $0x1, %r12d
je 0x4bd46
movq 0x8(%r14), %rdi
callq 0x29790
movl %eax, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x4f198
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ctype_alnum
static int jx9Builtin_ctype_alnum(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn  = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* If we reach the end of the string, then the test succeeded. */
			jx9_result_bool(pCtx, 1);
			return JX9_OK;
		}
		if( !SyisAlphaNum(zIn[0]) ){
			break;
		}
		/* Point to the next character */
		zIn++;
	}
	/* The test failed, return FALSE */
	jx9_result_bool(pCtx, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4bdad
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %r15
testq %r15, %r15
jle 0x4bdad
movq %rax, %r14
addq %rax, %r15
cmpq %r15, %r14
jae 0x4bdc4
callq 0xc190
movq (%rax), %rax
movzbl (%r14), %ecx
incq %r14
testb $0x8, (%rax,%rcx,2)
jne 0x4bd93
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x4bdb2
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ctype_alpha
static int jx9Builtin_ctype_alpha(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn  = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* If we reach the end of the string, then the test succeeded. */
			jx9_result_bool(pCtx, 1);
			return JX9_OK;
		}
		if( !SyisAlpha(zIn[0]) ){
			break;
		}
		/* Point to the next character */
		zIn++;
	}
	/* The test failed, return FALSE */
	jx9_result_bool(pCtx, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4be15
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %r15
testq %r15, %r15
jle 0x4be15
movq %rax, %r14
addq %rax, %r15
cmpq %r15, %r14
jae 0x4be2c
callq 0xc190
movq (%rax), %rax
movzbl (%r14), %ecx
incq %r14
testb $0x4, 0x1(%rax,%rcx,2)
jne 0x4bdfa
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x4be1a
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ctype_cntrl
static int jx9Builtin_ctype_cntrl(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn  = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* If we reach the end of the string, then the test succeeded. */
			jx9_result_bool(pCtx, 1);
			return JX9_OK;
		}
		if( zIn[0] >= 0xc0 ){
			/* UTF-8 stream  */
			break;
		}
		if( !SyisCtrl(zIn[0]) ){
			break;
		}
		/* Point to the next character */
		zIn++;
	}
	/* The test failed, return FALSE */
	jx9_result_bool(pCtx, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4be8b
movq (%rdx), %rdi
leaq -0x24(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %r15
testq %r15, %r15
jle 0x4be8b
movq %rax, %r14
addq %rax, %r15
cmpq %r15, %r14
jae 0x4bea4
movzbl (%r14), %r12d
cmpq $0xbf, %r12
ja 0x4be8b
callq 0xc190
movq (%rax), %rax
incq %r14
testb $0x2, (%rax,%r12,2)
jne 0x4be67
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x4be90
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ctype_print
static int jx9Builtin_ctype_print(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn  = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* If we reach the end of the string, then the test succeeded. */
			jx9_result_bool(pCtx, 1);
			return JX9_OK;
		}
		if( zIn[0] >= 0xc0 ){
			/* UTF-8 stream  */
			break;
		}
		if( !SyisPrint(zIn[0]) ){
			break;
		}
		/* Point to the next character */
		zIn++;
	}
	/* The test failed, return FALSE */
	jx9_result_bool(pCtx, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4c06f
movq (%rdx), %rdi
leaq -0x24(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %r15
testq %r15, %r15
jle 0x4c06f
movq %rax, %r14
addq %rax, %r15
cmpq %r15, %r14
jae 0x4c088
movzbl (%r14), %r12d
cmpq $0xbf, %r12
ja 0x4c06f
callq 0xc190
movq (%rax), %rax
incq %r14
testb $0x40, 0x1(%rax,%r12,2)
jne 0x4c04a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x4c074
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_microtime
static int jx9Builtin_microtime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int bFloat = 0;
	sytime sTime;	
#if defined(__UNIXES__)
	struct timeval tv;
	gettimeofday(&tv, 0);
	sTime.tm_sec  = (long)tv.tv_sec;
	sTime.tm_usec = (long)tv.tv_usec;
#else
	time_t tt;
	time(&tt);
	sTime.tm_sec  = (long)tt;
	sTime.tm_usec = (long)(tt%SX_USEC_PER_SEC);
#endif /* __UNIXES__ */
	if( nArg > 0 ){
		bFloat = jx9_value_to_bool(apArg[0]);
	}
	if( bFloat ){
		/* Return as float */
		jx9_result_double(pCtx, (double)sTime.tm_sec);
	}else{
		/* Return as string */
		jx9_result_string_format(pCtx, "%ld %ld", sTime.tm_usec, sTime.tm_sec);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xc5b0
movq (%r15), %r14
movq 0x8(%r15), %r15
testl %r13d, %r13d
jle 0x4c2d1
movq (%r12), %rdi
callq 0x29790
testl %eax, %eax
je 0x4c2d1
cvtsi2sd %r14, %xmm0
movq %rbx, %rdi
callq 0x298cd
jmp 0x4c2e8
leaq 0x1568d(%rip), %rsi     # 0x61965
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3bdad
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_gettimeofday
static int jx9Builtin_gettimeofday(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int bFloat = 0;
	sytime sTime;
#if defined(__UNIXES__)
	struct timeval tv;
	gettimeofday(&tv, 0);
	sTime.tm_sec  = (long)tv.tv_sec;
	sTime.tm_usec = (long)tv.tv_usec;
#else
	time_t tt;
	time(&tt);
	sTime.tm_sec  = (long)tt;
	sTime.tm_usec = (long)(tt%SX_USEC_PER_SEC);
#endif /* __UNIXES__ */
	if( nArg > 0 ){
		bFloat = jx9_value_to_bool(apArg[0]);
	}
	if( bFloat ){
		/* Return as float */
		jx9_result_double(pCtx, (double)sTime.tm_sec);
	}else{
		/* Return an associative array */
		jx9_value *pValue, *pArray;
		/* Create a new array */
		pArray = jx9_context_new_array(pCtx);
		/* Element value */
		pValue = jx9_context_new_scalar(pCtx);
		if( pValue == 0 || pArray == 0 ){
			/* Return NULL */
			jx9_result_null(pCtx);
			return JX9_OK;
		}
		/* Fill the array */
		/* sec */
		jx9_value_int64(pValue, sTime.tm_sec);
		jx9_array_add_strkey_elem(pArray, "sec", pValue);
		/* usec */
		jx9_value_int64(pValue, sTime.tm_usec);
		jx9_array_add_strkey_elem(pArray, "usec", pValue);
		/* Return the array */
		jx9_result_value(pCtx, pArray);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc5b0
movq (%r14), %r12
movq 0x8(%r14), %r14
testl %r13d, %r13d
jle 0x4c5a9
movq (%r15), %rdi
callq 0x29790
testl %eax, %eax
je 0x4c5a9
cvtsi2sd %r12, %xmm0
movq %rbx, %rdi
callq 0x298cd
jmp 0x4c61e
movq %rbx, %rdi
callq 0x2a2b0
movq %rax, %r15
movq %rbx, %rdi
callq 0x2a26a
movq %rax, %r13
testq %rax, %rax
setne %al
testq %r15, %r15
setne %cl
testb %cl, %al
je 0x4c616
movq %r13, %rdi
movq %r12, %rsi
callq 0x294c2
leaq 0x1ab0e(%rip), %rsi     # 0x670ef
movq %r15, %rdi
movq %r13, %rdx
callq 0x29c6c
movq %r13, %rdi
movq %r14, %rsi
callq 0x294c2
leaq 0x1aa27(%rip), %rsi     # 0x67025
movq %r15, %rdi
movq %r13, %rdx
callq 0x29c6c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x299d3
jmp 0x4c61e
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_date
static int jx9Builtin_date(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zFormat;
	int nLen;
	Sytm sTm;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Don't bother processing return the empty string */
		jx9_result_string(pCtx, "", 0);
	}
	if( nArg < 2 ){
#ifdef __WINNT__
		SYSTEMTIME sOS;
		GetSystemTime(&sOS);
		SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
		struct tm *pTm;
		time_t t;
		time(&t);
		pTm = localtime(&t);
		STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
	}else{
		/* Use the given timestamp */
		time_t t;
		struct tm *pTm;
		if( jx9_value_is_int(apArg[1]) ){
			t = (time_t)jx9_value_to_int64(apArg[1]);
			pTm = localtime(&t);
			if( pTm == 0 ){
				time(&t);
			}
		}else{
			time(&t);
		}
		pTm = localtime(&t);
		STRUCT_TM_TO_SYTM(pTm, &sTm);
	}
	/* Format the given string */
	DateFormat(pCtx, zFormat, nLen, &sTm);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4c653
movq %rdx, %r15
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x4c662
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
jmp 0x4c728
movl %esi, %r12d
leaq -0x34(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
movq %rax, %r14
cmpl $0x0, (%r13)
jg 0x4c68c
leaq 0x1afd0(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
cmpl $0x1, %r12d
jne 0x4c6a3
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0xc850
movq %r15, %rdi
jmp 0x4c6d0
movq 0x8(%r15), %rdi
testb $0x2, 0x8(%rdi)
je 0x4c6c3
callq 0x297ae
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0xc7a0
testq %rax, %rax
jne 0x4c6cc
leaq -0x30(%rbp), %rdi
callq 0xc850
leaq -0x30(%rbp), %rdi
callq 0xc7a0
movl 0x8(%rax), %ecx
movl %ecx, -0x68(%rbp)
movl 0x4(%rax), %ecx
movl %ecx, -0x6c(%rbp)
movl (%rax), %ecx
movl %ecx, -0x70(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x60(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x64(%rbp)
movl $0x76c, %ecx            # imm = 0x76C
addl 0x14(%rax), %ecx
movl %ecx, -0x5c(%rbp)
movl 0x1c(%rax), %ecx
movl %ecx, -0x54(%rbp)
movl 0x18(%rax), %ecx
movl %ecx, -0x58(%rbp)
movl 0x20(%rax), %eax
movl %eax, -0x50(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x48(%rbp)
movl -0x34(%rbp), %edx
leaq -0x70(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8c8
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_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_mktime
static int jx9Builtin_mktime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zFunction;
	jx9_int64 iVal = 0;
	struct tm *pTm;
	time_t t;
	/* Extract function name */
	zFunction = jx9_function_name(pCtx);
	/* Get the current time */
	time(&t);
	if( zFunction[0] == 'g' /* gmmktime */ ){
		pTm = gmtime(&t);
	}else{
		/* localtime */
		pTm = localtime(&t);
	}
	if( nArg > 0 ){
		int iVal;
		/* Hour */
		iVal = jx9_value_to_int(apArg[0]);
		pTm->tm_hour = iVal;
		if( nArg > 1 ){
			/* Minutes */
			iVal = jx9_value_to_int(apArg[1]);
			pTm->tm_min = iVal;
			if( nArg > 2 ){
				/* Seconds */
				iVal = jx9_value_to_int(apArg[2]);
				pTm->tm_sec = iVal;
				if( nArg > 3 ){
					/* Month */
					iVal = jx9_value_to_int(apArg[3]);
					pTm->tm_mon = iVal - 1;
					if( nArg > 4 ){
						/* mday */
						iVal = jx9_value_to_int(apArg[4]);
						pTm->tm_mday = iVal;
						if( nArg > 5 ){
							/* Year */
							iVal = jx9_value_to_int(apArg[5]);
							if( iVal > 1900 ){
								iVal -= 1900;
							}
							pTm->tm_year = iVal;
							if( nArg > 6 ){
								/* is_dst */
								iVal = jx9_value_to_bool(apArg[6]);
								pTm->tm_isdst = iVal;
							}
						}
					}
				}
			}
		}
	}
	/* Make the time */
	iVal = (jx9_int64)mktime(pTm);
	/* Return the timesatmp as a 64bit integer */
	jx9_result_int64(pCtx, iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %r12
leaq -0x28(%rbp), %rdi
callq 0xc850
cmpb $0x67, (%r12)
jne 0x4d193
leaq -0x28(%rbp), %rdi
callq 0xc2f0
jmp 0x4d19c
leaq -0x28(%rbp), %rdi
callq 0xc7a0
movq %rax, %r12
testl %r15d, %r15d
jle 0x4d240
movq (%r14), %rdi
callq 0x29772
movl %eax, 0x8(%r12)
cmpl $0x1, %r15d
je 0x4d240
movq 0x8(%r14), %rdi
callq 0x29772
movl %eax, 0x4(%r12)
cmpl $0x3, %r15d
jb 0x4d240
movq 0x10(%r14), %rdi
callq 0x29772
movl %eax, (%r12)
cmpl $0x3, %r15d
je 0x4d240
movq 0x18(%r14), %rdi
callq 0x29772
decl %eax
movl %eax, 0x10(%r12)
cmpl $0x5, %r15d
jb 0x4d240
movq 0x20(%r14), %rdi
callq 0x29772
movl %eax, 0xc(%r12)
cmpl $0x5, %r15d
je 0x4d240
movq 0x28(%r14), %rdi
callq 0x29772
leal -0x76c(%rax), %ecx
cmpl $0x76d, %eax            # imm = 0x76D
cmovll %eax, %ecx
movl %ecx, 0x14(%r12)
cmpl $0x7, %r15d
jb 0x4d240
movq 0x30(%r14), %rdi
callq 0x29790
movl %eax, 0x20(%r12)
movq %r12, %rdi
callq 0xc460
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29897
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_base64_encode
static int jx9Builtin_base64_encode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the BASE64 encoding */
	SyBase64Encode(zIn, (sxu32)nLen, Consumer, 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 0x4d321
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movl (%r15), %r15d
testl %r15d, %r15d
jle 0x4d321
movq %rax, %r14
xorl %r12d, %r12d
leaq 0x1abdd(%rip), %r13     # 0x67e80
leal 0x2(%r12), %eax
movl %r12d, %ecx
cmpl %r15d, %eax
jae 0x4d32d
movzbl (%r14,%rcx), %ecx
movl %ecx, %edx
shrl $0x2, %edx
movb (%rdx,%r13), %dl
movb %dl, -0x2c(%rbp)
leal 0x1(%r12), %edx
movb (%r14,%rdx), %dl
shlb $0x4, %cl
movl %edx, %esi
shrb $0x4, %sil
orb %cl, %sil
movzbl %sil, %ecx
andl $0x3f, %ecx
movb (%rcx,%r13), %cl
movb %cl, -0x2b(%rbp)
movl %eax, %eax
movzbl (%r14,%rax), %eax
shlb $0x2, %dl
movl %eax, %ecx
shrb $0x6, %cl
orb %dl, %cl
movzbl %cl, %ecx
andl $0x3f, %ecx
movb (%rcx,%r13), %cl
movb %cl, -0x2a(%rbp)
andl $0x3f, %eax
movb (%rax,%r13), %al
movb %al, -0x29(%rbp)
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
pushq $0x4
popq %rdx
callq 0x29903
addl $0x3, %r12d
jmp 0x4d2a3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
jmp 0x4d3ab
leal 0x1(%r12), %eax
cmpl %r15d, %eax
jae 0x4d370
movzbl (%r14,%rcx), %ecx
movl %ecx, %edx
shrl $0x2, %edx
movb (%rdx,%r13), %dl
movb %dl, -0x2c(%rbp)
movl %eax, %eax
movzbl (%r14,%rax), %eax
shlb $0x4, %cl
movl %eax, %edx
shrb $0x4, %dl
orb %cl, %dl
movzbl %dl, %ecx
andl $0x3f, %ecx
movb (%rcx,%r13), %cl
movb %cl, -0x2b(%rbp)
andl $0xf, %eax
movb (%r13,%rax,4), %al
jmp 0x4d395
cmpl %r15d, %r12d
jae 0x4d3ab
movzbl (%r14,%rcx), %eax
movl %eax, %ecx
shrl $0x2, %ecx
movb (%rcx,%r13), %cl
movb %cl, -0x2c(%rbp)
shll $0x4, %eax
andl $0x30, %eax
movb (%rax,%r13), %al
movb %al, -0x2b(%rbp)
movb $0x3d, %al
leaq -0x2c(%rbp), %rsi
movb %al, 0x2(%rsi)
movb $0x3d, 0x3(%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x29903
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_base64_decode
static int jx9Builtin_base64_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the BASE64 decoding */
	SyBase64Decode(zIn, (sxu32)nLen, Consumer, pCtx);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4d401
movq (%rdx), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movq %rax, %r14
movslq (%r15), %rax
testq %rax, %rax
jle 0x4d401
movq %rax, %r15
subq $0x1, %rax
jb 0x4d410
cmpb $0x3d, -0x1(%r14,%r15)
je 0x4d3ee
jmp 0x4d413
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
jmp 0x4d545
xorl %r15d, %r15d
pushq $0x1
popq %r12
leaq 0x15b82(%rip), %r13     # 0x62fa0
leal -0x1(%r12), %ecx
leal 0x2(%r12), %edx
movl %r12d, %eax
cmpl %r15d, %edx
jae 0x4d4b4
movl %ecx, %ecx
movzbl (%r14,%rcx), %ecx
andl $0x7f, %ecx
movl (%r13,%rcx,4), %esi
movzbl (%r14,%rax), %eax
andl $0x7f, %eax
movl (%r13,%rax,4), %eax
leal 0x1(%r12), %ecx
movzbl (%r14,%rcx), %ecx
andl $0x7f, %ecx
movl (%r13,%rcx,4), %ecx
movl %edx, %edx
movzbl (%r14,%rdx), %edx
andl $0x7f, %edx
movl (%r13,%rdx,4), %edx
movl %eax, %edi
shrl $0x4, %edi
andl $0x3, %edi
leal (%rdi,%rsi,4), %esi
movb %sil, -0x32(%rbp)
shll $0x4, %eax
movl %ecx, %esi
shrl $0x2, %esi
andl $0xf, %esi
orl %eax, %esi
movb %sil, -0x31(%rbp)
shll $0x6, %ecx
andl $0x3f, %edx
orl %ecx, %edx
movb %dl, -0x30(%rbp)
movq %rbx, %rdi
leaq -0x32(%rbp), %rsi
pushq $0x3
popq %rdx
callq 0x29903
addl $0x4, %r12d
jmp 0x4d41e
leal 0x1(%r12), %edx
cmpl %r15d, %edx
jae 0x4d509
movl %ecx, %ecx
movzbl (%r14,%rcx), %ecx
andl $0x7f, %ecx
movl (%r13,%rcx,4), %ecx
movzbl (%r14,%rax), %eax
andl $0x7f, %eax
movl (%r13,%rax,4), %eax
movl %edx, %edx
movzbl (%r14,%rdx), %edx
andl $0x7f, %edx
movl (%r13,%rdx,4), %edx
movl %eax, %esi
shrl $0x4, %esi
andl $0x3, %esi
leal (%rsi,%rcx,4), %ecx
movb %cl, -0x32(%rbp)
shll $0x4, %eax
shrl $0x2, %edx
andl $0xf, %edx
orl %eax, %edx
movb %dl, -0x31(%rbp)
pushq $0x2
jmp 0x4d538
cmpl %r15d, %r12d
jae 0x4d545
movl %ecx, %ecx
movzbl (%r14,%rcx), %ecx
andl $0x7f, %ecx
movl (%r13,%rcx,4), %ecx
movzbl (%r14,%rax), %eax
andl $0x7f, %eax
movl (%r13,%rax,4), %eax
shrl $0x4, %eax
andl $0x3, %eax
leal (%rax,%rcx,4), %eax
movb %al, -0x32(%rbp)
pushq $0x1
popq %rdx
leaq -0x32(%rbp), %rsi
movq %rbx, %rdi
callq 0x29903
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_urlencode
static int jx9Builtin_urlencode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the URL encoding */
	SyUriEncode(zIn, (sxu32)nLen, Consumer, pCtx);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4d645
movq (%rdx), %rdi
leaq -0x3c(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %r13
testq %r13, %r13
jle 0x4d645
movq %rax, %r14
movq %rbx, -0x38(%rbp)
leaq -0x2c(%rbp), %rax
movb $0x0, 0x2(%rax)
movw $0x25, (%rax)
addq %r14, %r13
movabsq $0x800000000000601, %r15 # imm = 0x800000000000601
xorl %r12d, %r12d
leaq (%r14,%r12), %rax
cmpq %r13, %rax
jae 0x4d651
movzbl (%rax), %ebx
callq 0xc190
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
testb $0x8, %al
jne 0x4d5e1
movl %ebx, %eax
addl $-0x24, %eax
cmpl $0x3b, %eax
ja 0x4d5e6
btq %rax, %r15
jae 0x4d5e6
incq %r12
jmp 0x4d5b1
testq %r12, %r12
je 0x4d5fa
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x29903
cmpl $0x20, %ebx
jne 0x4d60f
movb $0x2b, -0x2e(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x2e(%rbp), %rsi
pushq $0x1
jmp 0x4d634
movl %ebx, %eax
shrl $0x4, %eax
leaq 0x16206(%rip), %rcx     # 0x63821
movb (%rax,%rcx), %al
movb %al, -0x2b(%rbp)
andl $0xf, %ebx
movb (%rbx,%rcx), %al
movb %al, -0x2a(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
pushq $0x3
popq %rdx
callq 0x29903
addq %r12, %r14
incq %r14
jmp 0x4d5ae
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
jmp 0x4d665
testq %r12, %r12
je 0x4d665
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x29903
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_urldecode
static int jx9Builtin_urldecode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the URL decoding */
	SyUriDecode(zIn, (sxu32)nLen, Consumer, pCtx, TRUE);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4d6b2
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r14), %esi
testl %esi, %esi
jle 0x4d6b2
leaq 0x25b5(%rip), %rdx      # 0x4fc5a
movq %rax, %rdi
movq %rbx, %rcx
callq 0x3dff1
jmp 0x4d6bc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq