LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strncasecmp
static int jx9Builtin_strncasecmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *z1, *z2;
	int res;
	int n;
	if( nArg < 3 ){
		/* Perform a standard comparison */
		return jx9Builtin_strcasecmp(pCtx, nArg, apArg);
	}
	/* Desired comparison length */
	n  = jx9_value_to_int(apArg[2]);
	if( n < 0 ){
		/* Invalid length */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Perform the comparison */
	z1 = jx9_value_to_string(apArg[0], 0);
	z2 = jx9_value_to_string(apArg[1], 0);
	res = SyStrnicmp(z1, z2, (sxu32)n);
	/* Comparison result */
	jx9_result_int(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x54fa4
movq %rbx, %rdi
movq %r14, %rdx
callq 0x54ee3
jmp 0x55016
movq 0x10(%r14), %r15
movq %r15, %rdi
callq 0x3f362
movl (%r15), %r15d
testl %r15d, %r15d
js 0x54ff5
movq (%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %rax, %r12
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %r12, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x39f3f
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movslq %r14d, %rax
movq %rax, (%rbx)
jmp 0x55008
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $-0x1, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_implode
static int jx9Builtin_implode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	struct implode_data imp_data;
	int i = 1;
	if( nArg < 1 ){
		/* Missing argument, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Prepare the implode context */
	imp_data.pCtx = pCtx;
	imp_data.bRecursive = 0;
	imp_data.bFirst = 1;
	imp_data.nRecCount = 0;
	if( !jx9_value_is_json_array(apArg[0]) ){
		imp_data.zSep = jx9_value_to_string(apArg[0], &imp_data.nSeplen);
	}else{
		imp_data.zSep = 0;
		imp_data.nSeplen = 0;
		i = 0;
	}
	jx9_result_string(pCtx, "", 0); /* Set an empty stirng */
	/* Start the 'join' process */
	while( i < nArg ){
		if( jx9_value_is_json_array(apArg[i]) ){
			/* Iterate throw array entries */
			jx9_array_walk(apArg[i], implode_callback, &imp_data);
		}else{
			const char *zData;
			int nLen;
			/* Extract the string representation of the jx9 value */
			zData = jx9_value_to_string(apArg[i], &nLen);
			if( nLen > 0 ){
				if( imp_data.nSeplen > 0 ){
					if( !imp_data.bFirst ){
						/* append the separator first */
						jx9_result_string(pCtx, imp_data.zSep, imp_data.nSeplen);
					}else{
						imp_data.bFirst = 0;
					}
				}
				jx9_result_string(pCtx, zData, nLen);
			}
		}
		i++;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
testl %esi, %esi
jle 0x5506c
movq %rdx, %rbx
movl %esi, %r15d
movq %r14, -0x58(%rbp)
movl $0x0, -0x50(%rbp)
movq $0x1, -0x3c(%rbp)
movq (%rdx), %rdi
testb $0x40, 0x8(%rdi)
jne 0x5507a
leaq -0x40(%rbp), %rsi
callq 0x30577
movl $0x1, %r12d
jmp 0x55086
movq 0x8(%r14), %rdi
callq 0x30465
jmp 0x55115
movl $0x0, -0x40(%rbp)
xorl %eax, %eax
xorl %r12d, %r12d
movq %rax, -0x48(%rbp)
movq 0x8(%r14), %rdi
leaq 0x225dd(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
cmpl %r15d, %r12d
jae 0x55115
movl %r12d, %r12d
movl %r15d, %r13d
movq (%rbx,%r12,8), %rdi
testb $0x40, 0x8(%rdi)
jne 0x550da
leaq -0x2c(%rbp), %rsi
callq 0x30577
movl -0x2c(%rbp), %edx
testl %edx, %edx
jle 0x5510d
movq %rax, %r15
movl -0x40(%rbp), %eax
testl %eax, %eax
jle 0x55101
cmpl $0x0, -0x3c(%rbp)
je 0x550ef
movl $0x0, -0x3c(%rbp)
jmp 0x55101
movq (%rdi), %rdi
leaq 0x4fe7(%rip), %rsi      # 0x5a0cb
leaq -0x58(%rbp), %rdx
callq 0x5134a
jmp 0x5510d
movq -0x48(%rbp), %rsi
movq 0x8(%r14), %rdi
movl %eax, %edx
callq 0x302f6
movl -0x2c(%rbp), %edx
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x302f6
incq %r12
cmpq %r12, %r13
jne 0x550a7
xorl %eax, %eax
addq $0x38, %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: jx9Builtin_ltrim
static int jx9Builtin_ltrim(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Start the trim process */
	if( nArg < 2 ){
		SyString sStr;
		/* Remove white spaces and NUL byte */
		SyStringInitFromBuf(&sStr, zString, nLen);
		SyStringLeftTrimSafe(&sStr);
		jx9_result_string(pCtx, sStr.zString, (int)sStr.nByte);
	}else{
		/* Char list */
		const char *zList;
		int nListlen;
		zList = jx9_value_to_string(apArg[1], &nListlen);
		if( nListlen < 1 ){
			/* Return the string unchanged */
			jx9_result_string(pCtx, zString, nLen);
		}else{
			const char *zEnd = &zString[nLen];
			const char *zCur = zString;
			const char *zPtr;
			int i;
			/* Left trim */
			for(;;){
				if( zCur >= zEnd ){
					break;
				}
				zPtr = zCur;
				for( i = 0 ; i < nListlen ; i++ ){
					if( zCur < zEnd && zCur[0] == zList[i] ){
						zCur++;
					}
				}
				if( zCur == zPtr ){
					/* No match, break immediately */
					break;
				}
			}
			if( zCur >= zEnd ){
				/* Return the empty string */
				jx9_result_string(pCtx, "", 0);
			}else{
				jx9_result_string(pCtx, zCur, (int)(zEnd-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 0x5572e
movq %rdx, %r12
movl %esi, %r13d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r15
testq %r15, %r15
jle 0x557bb
movq %rax, %r14
cmpl $0x1, %r13d
jne 0x5573c
movq %r14, %r12
addq %r15, %r12
movsbq (%r14), %r13
cmpq $-0x41, %r13
ja 0x55791
testb %r13b, %r13b
je 0x55721
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
je 0x55791
incq %r14
decl %r15d
jne 0x556fe
xorl %r15d, %r15d
jmp 0x55794
movq 0x8(%rbx), %rdi
callq 0x30465
jmp 0x557cd
movq 0x8(%r12), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %rdi
movslq -0x2c(%rbp), %rcx
testq %rdi, %rdi
jle 0x557a0
movq %r14, %rdx
addq %rcx, %rdx
cmpq %rdx, %r14
jae 0x557ab
xorl %ecx, %ecx
movq %r14, %rsi
cmpq %rdx, %rsi
jae 0x5577f
movb (%rsi), %r8b
xorl %r9d, %r9d
cmpb (%rax,%rcx), %r8b
sete %r9b
addq %r9, %rsi
incq %rcx
cmpq %rcx, %rdi
jne 0x55769
cmpq %r14, %rsi
movq %rsi, %r14
jne 0x5575f
jmp 0x557ae
movq %r14, %r12
movq 0x8(%rbx), %rdi
movq %r12, %rsi
movl %r15d, %edx
jmp 0x557c8
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl %ecx, %edx
jmp 0x557c8
movq %r14, %rsi
cmpq %rdx, %rsi
jae 0x557bb
subl %esi, %edx
movq 0x8(%rbx), %rdi
jmp 0x557c8
movq 0x8(%rbx), %rdi
leaq 0x21eac(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strtolower
static int jx9Builtin_strtolower(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString, *zCur, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	zEnd = &zString[nLen];
	for(;;){
		if( zString >= zEnd ){
			/* No more input, break immediately */
			break;
		}
		if( (unsigned char)zString[0] >= 0xc0 ){
			/* UTF-8 stream, output verbatim */
			zCur = zString;
			zString++;
			while( zString < zEnd && ((unsigned char)zString[0] & 0xc0) == 0x80){
				zString++;
			}
			/* Append UTF-8 stream */
			jx9_result_string(pCtx, zCur, (int)(zString-zCur));
		}else{
			int c = zString[0];
			if( SyisUpper(c) ){
				c = SyToLower(zString[0]);
			}
			/* Append character */
			jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
			/* Advance the cursor */
			zString++;
		}
	}
	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 0x5589d
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r12
testq %r12, %r12
jle 0x558a8
movq %rax, %r14
addq %rax, %r12
leaq -0x2c(%rbp), %r15
movsbl (%r14), %r13d
cmpl $-0x40, %r13d
jb 0x55857
movl $0x1, %eax
movq %rax, %rdx
leaq (%r14,%rax), %r13
cmpq %r12, %r13
jae 0x55846
movb (%r13), %cl
andb $-0x40, %cl
leaq 0x1(%rdx), %rax
negb %cl
jo 0x5582b
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x302f6
movq %r13, %r14
jmp 0x55896
movl %r13d, -0x2c(%rbp)
callq 0xc170
movq (%rax), %rax
movslq %r13d, %rcx
testb $0x1, 0x1(%rax,%rcx,2)
je 0x5587f
callq 0xc4a0
movq (%rax), %rax
movsbq (%r14), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x302f6
incq %r14
movq %r14, %r13
cmpq %r12, %r13
jb 0x5581c
jmp 0x558ba
movq 0x8(%rbx), %rdi
callq 0x30465
jmp 0x558ba
movq 0x8(%rbx), %rdi
leaq 0x21dbf(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ord
static int jx9Builtin_ord(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	int nLen, c;
	if( nArg < 1 ){
		/* Missing arguments, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Extract the target string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Extract the ASCII value of the first character */
	c = zString[0];
	/* Return that value */
	jx9_result_int(pCtx, c);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x559f4
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
cmpl $0x0, (%r14)
jle 0x559f4
movsbq (%rax), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x55a07
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $-0x1, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
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: jx9Builtin_chr
static int jx9Builtin_chr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int c;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the ASCII value */
	c = jx9_value_to_int(apArg[0]);
	/* Return the specified character */
	jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x55a56
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3f362
movl (%r14), %eax
leaq -0x14(%rbp), %rsi
movl %eax, (%rsi)
movq 0x8(%rbx), %rdi
movl $0x1, %edx
callq 0x302f6
jmp 0x55a5f
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: jx9Builtin_bin2hex
static int jx9Builtin_bin2hex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	SyBinToHexConsumer((const void *)zString, (sxu32)nLen, HashConsumer, 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 0x55adc
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r12
testq %r12, %r12
jle 0x55ae7
movq %rax, %r14
addq %rax, %r12
leaq 0x2239d(%rip), %r13     # 0x77e40
leaq -0x2b(%rbp), %r15
movzbl (%r14), %eax
movl %eax, %ecx
shrl $0x4, %ecx
movb (%rcx,%r13), %cl
movb %cl, -0x2b(%rbp)
andl $0xf, %eax
movb (%rax,%r13), %al
movb %al, -0x2a(%rbp)
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x302f6
incq %r14
cmpq %r12, %r14
jb 0x55aa7
jmp 0x55af9
movq 0x8(%rbx), %rdi
callq 0x30465
jmp 0x55af9
movq 0x8(%rbx), %rdi
leaq 0x21b80(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strstr
static int jx9Builtin_strstr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	ProcStringMatch xPatternMatch = SyBlobSearch; /* Case-sensitive pattern match */
	const char *zBlob, *zPattern;
	int nLen, nPatLen;
	sxu32 nOfft;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the needle and the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	zPattern = jx9_value_to_string(apArg[1], &nPatLen);
	nOfft = 0; /* cc warning */
	if( nLen > 0 && nPatLen > 0 ){
		int before = 0;
		/* Perform the lookup */
		rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
		if( rc != SXRET_OK ){
			/* Pattern not found, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the portion of the string */
		if( nArg > 2 ){
			before = jx9_value_to_int(apArg[2]);
		}
		if( before ){
			jx9_result_string(pCtx, zBlob, (int)(&zBlob[nOfft]-zBlob));
		}else{
			jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
		}
	}else{
		jx9_result_bool(pCtx, 0);
	}
	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 0x55b85
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x30(%rbp), %r13
movq %r13, %rsi
callq 0x30577
movq %rax, -0x38(%rbp)
movq 0x8(%r15), %rdi
leaq -0x3c(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl $0x0, -0x2c(%rbp)
movl (%r13), %esi
testl %esi, %esi
setg %dl
movl (%r14), %ecx
testl %ecx, %ecx
setg %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x55b85
leaq -0x2c(%rbp), %r8
movq -0x38(%rbp), %r13
movq %r13, %rdi
movq %rax, %rdx
callq 0x59e90
testl %eax, %eax
je 0x55bb7
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 $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r12d
je 0x55bd4
movq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x3f362
cmpl $0x0, (%r14)
je 0x55bd4
movl -0x2c(%rbp), %edx
jmp 0x55bdf
movl -0x2c(%rbp), %eax
addq %rax, %r13
movl -0x30(%rbp), %edx
subl %eax, %edx
movq 0x8(%rbx), %rdi
movq %r13, %rsi
callq 0x302f6
jmp 0x55ba6
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_stristr
static int jx9Builtin_stristr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	ProcStringMatch xPatternMatch = iPatternMatch; /* Case-insensitive pattern match */
	const char *zBlob, *zPattern;
	int nLen, nPatLen;
	sxu32 nOfft;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the needle and the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	zPattern = jx9_value_to_string(apArg[1], &nPatLen);
	nOfft = 0; /* cc warning */
	if( nLen > 0 && nPatLen > 0 ){
		int before = 0;
		/* Perform the lookup */
		rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
		if( rc != SXRET_OK ){
			/* Pattern not found, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the portion of the string */
		if( nArg > 2 ){
			before = jx9_value_to_int(apArg[2]);
		}
		if( before ){
			jx9_result_string(pCtx, zBlob, (int)(&zBlob[nOfft]-zBlob));
		}else{
			jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
		}
	}else{
		jx9_result_bool(pCtx, 0);
	}
	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 0x55c68
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x30(%rbp), %r13
movq %r13, %rsi
callq 0x30577
movq %rax, -0x38(%rbp)
movq 0x8(%r15), %rdi
leaq -0x3c(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl $0x0, -0x2c(%rbp)
movl (%r13), %esi
testl %esi, %esi
setg %dl
movl (%r14), %ecx
testl %ecx, %ecx
setg %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x55c68
leaq -0x2c(%rbp), %r8
movq -0x38(%rbp), %r13
movq %r13, %rdi
movq %rax, %rdx
callq 0x5a193
testl %eax, %eax
je 0x55c9a
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 $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r12d
je 0x55cb7
movq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x3f362
cmpl $0x0, (%r14)
je 0x55cb7
movl -0x2c(%rbp), %edx
jmp 0x55cc2
movl -0x2c(%rbp), %eax
addq %rax, %r13
movl -0x30(%rbp), %edx
subl %eax, %edx
movq 0x8(%rbx), %rdi
movq %r13, %rsi
callq 0x302f6
jmp 0x55c89
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strpos
static int jx9Builtin_strpos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	ProcStringMatch xPatternMatch = SyBlobSearch; /* Case-sensitive pattern match */
	const char *zBlob, *zPattern;
	int nLen, nPatLen, nStart;
	sxu32 nOfft;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the needle and the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	zPattern = jx9_value_to_string(apArg[1], &nPatLen);
	nOfft = 0; /* cc warning */
	nStart = 0;
	/* Peek the starting offset if available */
	if( nArg > 2 ){
		nStart = jx9_value_to_int(apArg[2]);
		if( nStart < 0 ){
			nStart = -nStart;
		}
		if( nStart >= nLen ){
			/* Invalid offset */
			nStart = 0;
		}else{
			zBlob += nStart;
			nLen -= nStart;
		}
	}
	if( nLen > 0 && nPatLen > 0 ){
		/* Perform the lookup */
		rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
		if( rc != SXRET_OK ){
			/* Pattern not found, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the pattern position */
		jx9_result_int64(pCtx, (jx9_int64)(nOfft+nStart));
	}else{
		jx9_result_bool(pCtx, 0);
	}
	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 0x55d80
movq %rdx, %r12
movl %esi, %r13d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x30577
movq %rax, %r14
movq 0x8(%r12), %rdi
leaq -0x34(%rbp), %rsi
callq 0x30577
movq %rax, %r15
movl $0x0, -0x30(%rbp)
cmpl $0x2, %r13d
jne 0x55d28
xorl %r12d, %r12d
movl -0x2c(%rbp), %esi
jmp 0x55d59
movq 0x10(%r12), %r12
movq %r12, %rdi
callq 0x3f362
movl (%r12), %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
movl -0x2c(%rbp), %esi
xorl %r12d, %r12d
movl %esi, %ecx
subl %eax, %ecx
jle 0x55d59
movl %eax, %edx
addq %rdx, %r14
movl %ecx, -0x2c(%rbp)
movl %ecx, %esi
movl %eax, %r12d
testl %esi, %esi
setg %al
movl -0x34(%rbp), %ecx
testl %ecx, %ecx
setg %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x55d80
leaq -0x30(%rbp), %r8
movq %r14, %rdi
movq %r15, %rdx
callq 0x59e90
testl %eax, %eax
je 0x55db6
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0x8, %eax
movl $0xfffffe90, %ecx       # imm = 0xFFFFFE90
andl 0x8(%rbx), %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl -0x30(%rbp), %r12d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r12, (%rbx)
movl $0x2, %eax
jmp 0x55d98
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_stripos
static int jx9Builtin_stripos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	ProcStringMatch xPatternMatch = iPatternMatch; /* Case-insensitive pattern match */
	const char *zBlob, *zPattern;
	int nLen, nPatLen, nStart;
	sxu32 nOfft;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the needle and the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	zPattern = jx9_value_to_string(apArg[1], &nPatLen);
	nOfft = 0; /* cc warning */
	nStart = 0;
	/* Peek the starting offset if available */
	if( nArg > 2 ){
		nStart = jx9_value_to_int(apArg[2]);
		if( nStart < 0 ){
			nStart = -nStart;
		}
		if( nStart >= nLen ){
			/* Invalid offset */
			nStart = 0;
		}else{
			zBlob += nStart;
			nLen -= nStart;
		}
	}
	if( nLen > 0 && nPatLen > 0 ){
		/* Perform the lookup */
		rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
		if( rc != SXRET_OK ){
			/* Pattern not found, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the pattern position */
		jx9_result_int64(pCtx, (jx9_int64)(nOfft+nStart));
	}else{
		jx9_result_bool(pCtx, 0);
	}
	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 0x55e80
movq %rdx, %r12
movl %esi, %r13d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x30577
movq %rax, %r14
movq 0x8(%r12), %rdi
leaq -0x34(%rbp), %rsi
callq 0x30577
movq %rax, %r15
movl $0x0, -0x30(%rbp)
cmpl $0x2, %r13d
jne 0x55e28
xorl %r12d, %r12d
movl -0x2c(%rbp), %esi
jmp 0x55e59
movq 0x10(%r12), %r12
movq %r12, %rdi
callq 0x3f362
movl (%r12), %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
movl -0x2c(%rbp), %esi
xorl %r12d, %r12d
movl %esi, %ecx
subl %eax, %ecx
jle 0x55e59
movl %eax, %edx
addq %rdx, %r14
movl %ecx, -0x2c(%rbp)
movl %ecx, %esi
movl %eax, %r12d
testl %esi, %esi
setg %al
movl -0x34(%rbp), %ecx
testl %ecx, %ecx
setg %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x55e80
leaq -0x30(%rbp), %r8
movq %r14, %rdi
movq %r15, %rdx
callq 0x5a193
testl %eax, %eax
je 0x55eb6
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0x8, %eax
movl $0xfffffe90, %ecx       # imm = 0xFFFFFE90
andl 0x8(%rbx), %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl -0x30(%rbp), %r12d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r12, (%rbx)
movl $0x2, %eax
jmp 0x55e98
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strrchr
static int jx9Builtin_strrchr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zBlob;
	int nLen, c;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	c = 0; /* cc warning */
	if( nLen > 0 ){
		sxu32 nOfft;
		sxi32 rc;
		if( jx9_value_is_string(apArg[1]) ){
			const char *zPattern;
			zPattern = jx9_value_to_string(apArg[1], 0); /* Never fail, so there is no need to check
														 * for NULL pointer.
														 */
			c = zPattern[0];
		}else{
			/* Int cast */
			c = jx9_value_to_int(apArg[1]);
		}
		/* Perform the lookup */
		rc = SyByteFind2(zBlob, (sxu32)nLen, c, &nOfft);
		if( rc != SXRET_OK ){
			/* No such entry, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the string portion */
		jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
	}else{
		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
cmpl $0x1, %esi
jle 0x56234
movq %rdx, %r15
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30577
cmpl $0x0, (%r12)
jle 0x56234
movq %rax, %r14
movq 0x8(%r15), %r15
testb $0x1, 0x8(%r15)
jne 0x561d7
movq %r15, %rdi
callq 0x3f362
movl (%r15), %eax
jmp 0x561e4
movq %r15, %rdi
xorl %esi, %esi
callq 0x30577
movsbl (%rax), %eax
movl -0x24(%rbp), %edx
leal -0x1(%rdx), %ecx
addq %r14, %rcx
decq %rcx
movsbl 0x1(%rcx), %esi
cmpl %esi, %eax
je 0x56264
cmpq %r14, %rcx
jb 0x56234
movsbl (%rcx), %esi
cmpl %esi, %eax
je 0x56267
leaq -0x1(%rcx), %rdi
cmpq %r14, %rdi
jb 0x56234
movsbl (%rdi), %esi
cmpl %esi, %eax
je 0x5626a
leaq -0x2(%rcx), %rdi
cmpq %r14, %rdi
jb 0x56234
movsbl (%rdi), %esi
cmpl %esi, %eax
je 0x5626a
leaq -0x4(%rcx), %rsi
addq $-0x3, %rcx
cmpq %r14, %rcx
movq %rsi, %rcx
jae 0x561f0
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
incq %rcx
movq %rcx, %rdi
subq %r14, %rdi
movl %edi, %esi
addq %r14, %rsi
subl %edi, %edx
movq 0x8(%rbx), %rdi
callq 0x302f6
jmp 0x56255
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strrev
static int jx9Builtin_strrev(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn, *zEnd;
	int nLen, c;
	if( nArg < 1 ){
		/* 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;
	}
	/* Perform the requested operation */
	zEnd = &zIn[nLen - 1];
	for(;;){
		if( zEnd < zIn ){
			/* No more input to process */
			break;
		}
		/* Append current character */
		c = zEnd[0];
		jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
		zEnd--;
	}
	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 0x562e2
movq (%rdx), %rdi
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movq %rax, %r14
movslq (%r15), %rax
testq %rax, %rax
jle 0x562e2
leaq (%r14,%rax), %r12
decq %r12
cmpq %r14, %r12
jb 0x562eb
leaq -0x24(%rbp), %r15
movsbl (%r12), %eax
movl %eax, -0x24(%rbp)
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x302f6
decq %r12
cmpq %r14, %r12
jae 0x562bf
jmp 0x562eb
movq 0x8(%rbx), %rdi
callq 0x30465
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: 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 0x5635e
movq %rdx, %r15
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30577
cmpl $0x0, (%r12)
jle 0x5635e
movq %rax, %r14
movq 0x8(%r15), %r15
movq %r15, %rdi
callq 0x3f362
movl (%r15), %r15d
testl %r15d, %r15d
jle 0x56376
incl %r15d
movl -0x24(%rbp), %edx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x302f6
decl %r15d
cmpl $0x1, %r15d
ja 0x56344
jmp 0x56367
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
leaq 0x212f1(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
jmp 0x56367
// File: /workspace/github_c_makefile_star2_O3/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 0x564a6
movq %rdx, %r13
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movq %rax, %r15
movl (%r14), %eax
testl %eax, %eax
jle 0x564ba
movb $0x1, -0x29(%rbp)
cmpl $0x1, %r12d
je 0x563e7
movq 0x8(%r13), %r14
movq %r14, %rdi
callq 0x438dd
cmpl $0x0, (%r14)
sete -0x29(%rbp)
movl -0x30(%rbp), %eax
movslq %eax, %r12
addq %r15, %r12
cmpq %r12, %r15
jae 0x56411
movq %r15, %r13
movzbl (%r13), %eax
cmpl $0xa, %eax
je 0x56419
cmpl $0xd, %eax
je 0x56419
incq %r13
cmpq %r12, %r13
jb 0x563f5
xorl %r14d, %r14d
jmp 0x5641c
xorl %r14d, %r14d
movq %r15, %r13
jmp 0x5641c
movb $0x1, %r14b
cmpq %r13, %r15
jae 0x56433
movl %r13d, %edx
subl %r15d, %edx
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x302f6
testb %r14b, %r14b
je 0x564c3
movq 0x8(%rbx), %rdi
cmpb $0x0, -0x29(%rbp)
je 0x56454
leaq 0x20b1b(%rip), %rsi     # 0x76f68
movl $0x5, %edx
jmp 0x56460
leaq 0x1b017(%rip), %rsi     # 0x71472
movl $0x4, %edx
callq 0x302f6
movq %r13, %r15
cmpq %r12, %r13
jae 0x56486
movq %r13, %r15
movzbl (%r15), %eax
cmpl $0xd, %eax
je 0x5647e
cmpl $0xa, %eax
jne 0x56486
incq %r15
cmpq %r12, %r15
jb 0x56470
cmpq %r15, %r13
jae 0x563ed
movl %r15d, %edx
subl %r13d, %edx
movq 0x8(%rbx), %rdi
movq %r13, %rsi
callq 0x302f6
jmp 0x563ed
movq 0x8(%rbx), %rdi
leaq 0x211c1(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
jmp 0x564c3
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: 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, %r15
testl %esi, %esi
jle 0x5652f
movq %rdx, %rbx
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5652f
movl %esi, %r14d
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30577
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x5652f
leaq 0x4bec(%rip), %rdi      # 0x5b100
movq %r15, %rsi
movq %rax, %rdx
movl %r14d, %r8d
movq %rbx, %r9
pushq $0x0
pushq $0x0
callq 0x5a243
addq $0x10, %rsp
jmp 0x56541
movq 0x8(%r15), %rdi
leaq 0x21138(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
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: 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
movq $0x0, -0x28(%rbp)
testl %esi, %esi
jle 0x565ca
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x565ca
movl %esi, %r15d
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x30577
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x565ca
leaq -0x28(%rbp), %r12
leaq 0x4b75(%rip), %rdi      # 0x5b111
movq %rbx, %rsi
movq %rax, %rdx
movl %r15d, %r8d
movq %r14, %r9
pushq $0x0
pushq %r12
callq 0x5a243
addq $0x10, %rsp
movq (%r12), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x565dd
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 $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: 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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq $0x0, -0x38(%rbp)
cmpl $0x2, %esi
jl 0x566ce
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x566ce
movq 0x8(%r14), %rax
testb $0x40, 0x8(%rax)
je 0x566ce
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
cmpl $0x0, (%r15)
jle 0x566ce
movq %rax, %r12
movq 0x8(%r14), %rax
movq (%rax), %rdi
leaq -0x60(%rbp), %r15
movq %r15, %rsi
callq 0x5b130
movl -0x2c(%rbp), %ecx
movq 0x8(%r15), %r14
leaq -0x38(%rbp), %r13
leaq 0x4a9a(%rip), %rdi      # 0x5b111
movq %rbx, %rsi
movq %r12, %rdx
movl %eax, %r8d
movq %r14, %r9
pushq $0x1
pushq %r13
callq 0x5a243
addq $0x10, %rsp
movq (%r13), %r12
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r12, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
movq (%r15), %rdi
testq %rdi, %rdi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x566ef
movq %r14, %rsi
callq 0x3490d
jmp 0x566ef
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 $0x38, %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: 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 0x567a0
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x567a0
movq 0x8(%r14), %rax
testb $0x40, 0x8(%rax)
je 0x567a0
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30577
cmpl $0x0, (%r12)
jle 0x567a0
movq %rax, %r15
movq 0x8(%r14), %rax
movq (%rax), %rdi
leaq -0x50(%rbp), %r12
movq %r12, %rsi
callq 0x5b130
movl -0x24(%rbp), %ecx
movq 0x8(%r12), %r14
leaq 0x4997(%rip), %rdi      # 0x5b100
movq %rbx, %rsi
movq %r15, %rdx
movl %eax, %r8d
movq %r14, %r9
pushq $0x1
pushq $0x0
callq 0x5a243
addq $0x10, %rsp
movq (%r12), %rdi
testq %rdi, %rdi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x567b2
movq %r14, %rsi
callq 0x3490d
jmp 0x567b2
movq 0x8(%rbx), %rdi
leaq 0x20ec7(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x30, %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: 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 %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x567f5
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3f362
movq (%r14), %rdx
cmpq $0x64, %rdx
jge 0x56809
movq 0x8(%rbx), %rdi
leaq 0x20788(%rip), %rsi     # 0x76f76
movl $0x6, %edx
jmp 0x56802
movq 0x8(%rbx), %rdi
leaq 0x20e72(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
jmp 0x56873
xorl %eax, %eax
movq %rdx, %rsi
shrq $0xa, %rdx
incl %eax
cmpq $0xfffff, %rsi          # imm = 0xFFFFF
ja 0x5680b
movl %esi, %ecx
andl $0x3fc, %ecx            # imm = 0x3FC
imull $0x290, %ecx, %ecx      # imm = 0x290
shrl $0x10, %ecx
cmpw $0x9, %cx
movl $0x9, %edi
cmovael %edi, %ecx
leal -0x1(%rax), %r8d
xorl %r9d, %r9d
cmpq $0xfa000, %rsi          # imm = 0xFA000
cmovael %edi, %ecx
cmovael %eax, %r8d
cmovael %r9d, %edx
movslq %r8d, %rax
leaq 0x20711(%rip), %rsi     # 0x76f6e
movsbl (%rax,%rsi), %r8d
leaq 0x20714(%rip), %rsi     # 0x76f7d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x44e00
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_str_getcsv
static int jx9Builtin_str_getcsv(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zInput, *zPtr;
	jx9_value *pArray;
	int delim  = ',';   /* Delimiter */
	int encl   = '"' ;  /* Enclosure */
	int escape = '\\';  /* Escape character */
	int nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the raw input */
	zInput = jx9_value_to_string(apArg[0], &nLen);
	if( nArg > 1 ){
		int i;
		if( jx9_value_is_string(apArg[1]) ){
			/* Extract the delimiter */
			zPtr = jx9_value_to_string(apArg[1], &i);
			if( i > 0 ){
				delim = zPtr[0];
			}
		}
		if( nArg > 2 ){
			if( jx9_value_is_string(apArg[2]) ){
				/* Extract the enclosure */
				zPtr = jx9_value_to_string(apArg[2], &i);
				if( i > 0 ){
					encl = zPtr[0];
				}
			}
			if( nArg > 3 ){
				if( jx9_value_is_string(apArg[3]) ){
					/* Extract the escape character */
					zPtr = jx9_value_to_string(apArg[3], &i);
					if( i > 0 ){
						escape = zPtr[0];
					}
				}
			}
		}
	}
	/* Create our array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Parse the raw input */
	jx9ProcessCsv(zInput, nLen, delim, encl, escape, jx9CsvConsumer, pArray);
	/* Return the freshly created 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 %rdi, %rbx
testl %esi, %esi
jle 0x56988
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x56988
movl %esi, %r15d
leaq -0x34(%rbp), %rsi
callq 0x30577
movq %rax, -0x40(%rbp)
cmpl $0x1, %r15d
jne 0x568d0
movl $0x5c, %r12d
movl $0x22, %r13d
movl $0x2c, %r15d
jmp 0x56936
movq 0x8(%r14), %rdi
movl $0x2c, -0x2c(%rbp)
testb $0x1, 0x8(%rdi)
je 0x568fa
leaq -0x30(%rbp), %r12
movq %r12, %rsi
callq 0x30577
cmpl $0x0, (%r12)
jle 0x568fa
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x5c, %r12d
movl $0x22, %r13d
cmpl $0x3, %r15d
jb 0x56932
movq 0x10(%r14), %rdi
testb $0x1, 0x8(%rdi)
je 0x5692c
leaq -0x30(%rbp), %rsi
callq 0x30577
leaq -0x30(%rbp), %rcx
cmpl $0x0, (%rcx)
jle 0x5692c
movsbl (%rax), %r13d
cmpl $0x3, %r15d
jne 0x569a2
movl -0x2c(%rbp), %r15d
movq %rbx, %rdi
callq 0x31231
testq %rax, %rax
je 0x5696c
movq %rax, %r14
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdi
movl %r15d, %edx
movl %r13d, %ecx
movl %r12d, %r8d
movq %rax, %r9
callq 0x5b1d6
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3e19f
jmp 0x56991
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x1f952(%rip), %rcx     # 0x762d0
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rdi
testb $0x1, 0x8(%rdi)
movl -0x2c(%rbp), %r15d
je 0x56936
leaq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x30577
cmpl $0x0, (%r14)
jle 0x56936
movsbl (%rax), %r12d
jmp 0x56936
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, -0x28(%rbp)
testl %esi, %esi
jle 0x569f8
movq %rdx, %r15
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x56a0c
movq 0x8(%rbx), %rdi
leaq 0x20c6f(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
jmp 0x56a52
movl %esi, %r12d
leaq -0x24(%rbp), %rsi
callq 0x30577
movq %rax, %r14
cmpl $0x1, %r12d
je 0x56a2b
movq 0x8(%r15), %rdi
testb $0x1, 0x8(%rdi)
jne 0x56a32
xorl %r8d, %r8d
xorl %ecx, %ecx
jmp 0x56a44
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movq %rax, %rcx
movl (%r15), %r8d
movl -0x24(%rbp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b3d9
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: 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 0x56fd0
movq %rdx, %r15
movq (%rdx), %rdi
leaq -0x38(%rbp), %r13
movq %r13, %rsi
callq 0x30577
movq %rax, %r14
movq 0x8(%r15), %rdi
leaq -0x34(%rbp), %rsi
callq 0x30577
movq %rax, %r12
movl (%r13), %eax
testl %eax, %eax
jle 0x56fd0
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movslq -0x34(%rbp), %r15
testq %r15, %r15
jle 0x56fd0
movl %eax, -0x30(%rbp)
movq %rbx, -0x40(%rbp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %ebx, %ebx
movl %ecx, %r13d
movsbl (%r12,%rbx), %edx
movl -0x38(%rbp), %esi
movq %r14, %rdi
leaq -0x2c(%rbp), %rcx
callq 0x47327
movl -0x2c(%rbp), %ecx
cmpl %r13d, %ecx
cmovael %r13d, %ecx
testl %eax, %eax
cmovnel %r13d, %ecx
incq %rbx
cmpq %r15, %rbx
jb 0x56f80
cmpl $-0x1, %ecx
movq -0x40(%rbp), %rbx
movl -0x30(%rbp), %edx
je 0x56fd0
movl %ecx, %eax
addq %rax, %r14
subl %ecx, %edx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x302f6
jmp 0x56ff1
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 $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq