LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmProcessLongOpt
static int VmProcessLongOpt(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
	struct getopt_long_opt *pOpt = (struct getopt_long_opt *)pUserData;
	const char *zArg, *zOpt, *zEnd;
	int need_value = 0;
	int nByte;
	/* Value must be of type string */
	if( !jx9_value_is_string(pValue) ){
		/* Simply ignore */
		return JX9_OK;
	}
	zOpt = jx9_value_to_string(pValue, &nByte);
	if( nByte < 1 ){
		/* Empty string, ignore */
		return JX9_OK;
	}
	zEnd = &zOpt[nByte - 1];
	if( zEnd[0] == ':' ){
		char *zTerm;
		/* Try to extract a value */
		need_value = 1;
		while( zEnd >= zOpt && zEnd[0] == ':' ){
			zEnd--;
		}
		if( zOpt >= zEnd ){
			/* Empty string, ignore */
			SXUNUSED(pKey);
			return JX9_OK;
		}
		zEnd++;
		zTerm = (char *)zEnd;
		zTerm[0] = 0;
	}else{
		zEnd = &zOpt[nByte];
	}
	/* Find the option */
	zArg = VmFindLongOpt(zOpt, (int)(zEnd-zOpt), pOpt->zArgIn, pOpt->zArgEnd);
	if( zArg == 0 ){
		/* No such option, return immediately */
		return JX9_OK;
	}
	/* Try to extract a value */
	VmExtractOptArgValue(pOpt->pArray, pOpt->pWorker, zArg, pOpt->zArgEnd, need_value, pOpt->pCtx, zOpt);
	return JX9_OK;
}

// Assembly:
testb $0x1, 0x8(%rsi)
je 0x5323d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
leaq -0x4c(%rbp), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x30b04
movq %rax, %r14
movslq (%rbx), %rax
testq %rax, %rax
jle 0x5322f
cmpb $0x3a, -0x1(%r14,%rax)
jne 0x53127
addq %r14, %rax
decq %rax
cmpq %r14, %rax
jb 0x53136
cmpb $0x3a, (%rax)
jne 0x53136
decq %rax
jmp 0x53118
movq %r14, %rcx
addq %rax, %rcx
movl $0x0, -0x34(%rbp)
jmp 0x53156
movq %rax, %rcx
cmpq %rax, %r14
jae 0x53146
leaq 0x1(%rax), %rcx
movb $0x0, 0x1(%rax)
movl $0x1, -0x34(%rbp)
cmpq %rax, %r14
jae 0x5322f
movq (%r15), %r13
movq %r15, -0x48(%rbp)
movq 0x8(%r15), %r15
cmpq %r15, %r13
jae 0x53205
subl %r14d, %ecx
leaq -0x2(%r15), %rax
movq %rax, -0x40(%rbp)
movq %rcx, -0x30(%rbp)
cmpb $0x2d, (%r13)
jne 0x531f3
leaq 0x1(%r13), %rax
cmpq %r15, %rax
jae 0x531f3
cmpb $0x2d, (%rax)
jne 0x531f3
leaq 0x2(%r13), %r12
movq %r12, %rbx
cmpq %r15, %r12
jae 0x531d1
callq 0xc170
movq (%rax), %rax
movq -0x40(%rbp), %rcx
subq %r13, %rcx
movq %r12, %rbx
movsbq (%rbx), %rdx
cmpq $0x3d, %rdx
je 0x531cd
movzwl (%rax,%rdx,2), %edx
andl $0x2000, %edx           # imm = 0x2000
jne 0x531cd
incq %rbx
decq %rcx
jne 0x531ac
movq %r15, %rbx
movq -0x30(%rbp), %rcx
movl %ebx, %eax
subl %r12d, %eax
cmpl %ecx, %eax
jne 0x531f9
movq %r12, %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
callq 0x34ebe
movq -0x30(%rbp), %rcx
testl %eax, %eax
jne 0x531f9
jmp 0x53207
incq %r13
movq %r13, %rbx
movq %rbx, %r13
cmpq %r15, %rbx
jb 0x53179
xorl %ebx, %ebx
testq %rbx, %rbx
movq -0x48(%rbp), %rax
je 0x5322f
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdi
movq 0x20(%rax), %r9
movq %r14, (%rsp)
movq %rbx, %rdx
movq %r15, %rcx
movl -0x34(%rbp), %r8d
callq 0x52d7a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9StreamReadWholeFile
JX9_PRIVATE sxi32 jx9StreamReadWholeFile(void *pHandle, const jx9_io_stream *pStream, SyBlob *pOut)
{
	jx9_int64 nRead;
	char zBuf[8192]; /* 8K */
	int rc;
	/* Perform the requested operation */
	for(;;){
		nRead = pStream->xRead(pHandle, zBuf, sizeof(zBuf));
		if( nRead < 1 ){
			/* EOF or IO error */
			break;
		}
		/* Append contents */
		rc = SyBlobAppend(pOut, zBuf, (sxu32)nRead);
		if( rc != SXRET_OK ){
			break;
		}
	}
	return SyBlobLength(pOut) > 0 ? SXRET_OK : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x2020(%rbp), %r12
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rdi
movq %r12, %rsi
callq *0x30(%r14)
testq %rax, %rax
jle 0x537b8
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x360ae
testl %eax, %eax
je 0x53793
xorl %eax, %eax
cmpl $0x1, 0x10(%rbx)
sbbl %eax, %eax
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_TIME_Const
static void JX9_TIME_Const(jx9_value *pVal, void *pUnused)
{
	Sytm sTm;
#ifdef __WINNT__
	SYSTEMTIME sOS;
	GetSystemTime(&sOS);
	SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
	struct tm *pTm;
	time_t t;
	time(&t);
	pTm = gmtime(&t);
	STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
	SXUNUSED(pUnused); /* cc warning */
	/* Expand */
	jx9_value_string_format(pVal, "%02d:%02d:%02d", sTm.tm_hour, sTm.tm_min, sTm.tm_sec);
}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x3f8(%rsi), %ecx
testl %ecx, %ecx
je 0x539cf
decl %ecx
imull 0x400(%rsi), %ecx
addq 0x3f0(%rsi), %rcx
jmp 0x539d1
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x53a35
movslq 0x8(%rcx), %rax
testq %rax, %rax
je 0x53a43
movq (%rcx), %rsi
leaq (%rax,%rsi), %rdx
decq %rdx
xorl %r8d, %r8d
movq %r8, %rcx
leaq (%rdx,%r8), %r9
cmpq %rsi, %r9
jbe 0x53a02
leaq -0x1(%rcx), %r8
cmpb $0x2f, (%r9)
jne 0x539ec
movl $0x1, %r8d
subq %rax, %r8
cmpq %rcx, %r8
jne 0x53a16
cmpb $0x2f, (%rdx,%rcx)
jne 0x53a43
decl %eax
addq %rcx, %rax
cmpl $0x2, %eax
movl $0x1, %edx
cmovael %eax, %edx
testl %eax, %eax
leaq 0x27b7d(%rip), %rax     # 0x7b5ac
cmoveq %rax, %rsi
jmp 0x53a4f
leaq 0x24feb(%rip), %rsi     # 0x78a27
movl $0x8, %edx
jmp 0x53a4f
leaq 0x2028d(%rip), %rsi     # 0x73cd7
movl $0x1, %edx
popq %rbp
jmp 0x3087c
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_STDIN_Const
static void JX9_STDIN_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStdin(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d0(%rsi), %r14
testq %r14, %r14
jne 0x54877
movq %rsi, %r15
movq %rsi, %rdi
movl $0x38, %esi
callq 0x343ed
testq %rax, %rax
je 0x54874
movq %rax, %r14
leaq 0x3fb9b(%rip), %rax     # 0x943d0
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r15, 0x10(%r14)
movl $0x0, 0x28(%r14)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x54c28
movq %rax, 0x8(%r14)
movq %r14, 0x4d0(%r15)
jmp 0x54877
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_STDOUT_Const
static void JX9_STDOUT_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStdout(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d8(%rsi), %r14
testq %r14, %r14
jne 0x54917
movq %rsi, %r15
movq %rsi, %rdi
movl $0x38, %esi
callq 0x343ed
testq %rax, %rax
je 0x54914
movq %rax, %r14
leaq 0x3fafb(%rip), %rax     # 0x943d0
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r15, 0x10(%r14)
movl $0x0, 0x28(%r14)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r14)
movq %r15, %rdi
movl $0x2, %esi
callq 0x54c28
movq %rax, 0x8(%r14)
movq %r14, 0x4d8(%r15)
jmp 0x54917
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_STDERR_Const
static void JX9_STDERR_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStderr(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4e0(%rsi), %r14
testq %r14, %r14
jne 0x549b7
movq %rsi, %r15
movq %rsi, %rdi
movl $0x38, %esi
callq 0x343ed
testq %rax, %rax
je 0x549b4
movq %rax, %r14
leaq 0x3fa5b(%rip), %rax     # 0x943d0
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r15, 0x10(%r14)
movl $0x0, 0x28(%r14)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r14)
movq %r15, %rdi
movl $0x3, %esi
callq 0x54c28
movq %rax, 0x8(%r14)
movq %r14, 0x4e0(%r15)
jmp 0x549b7
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_value_string_format
JX9_PRIVATE int jx9_value_string_format(jx9_value *pVal, const char *zFormat, ...)
{
	va_list ap;
	int rc;
	if((pVal->iFlags & MEMOBJ_STRING) == 0 ){
		/* Invalidate any prior representation */
		jx9MemObjRelease(pVal);
		MemObjSetType(pVal, MEMOBJ_STRING);
	}
	va_start(ap, zFormat);
	rc = SyBlobFormatAp(&pVal->sBlob, zFormat, ap);
	va_end(ap);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x54bb4
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
testb $0x1, 0x8(%rdi)
jne 0x54bd1
movq %r14, %rdi
callq 0x309f2
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%r14), %eax
incl %eax
movl %eax, 0x8(%r14)
leaq -0xe0(%rbp), %rax
leaq -0x30(%rbp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
addq $0x18, %r14
leaq -0x14(%rbp), %r8
movl $0x0, (%r8)
movq %rcx, (%rsp)
movl $0x6, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x351b4
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9StreamDataInit
static jx9_stream_data * JX9StreamDataInit(jx9_vm *pVm, int iType)
{
	jx9_stream_data *pData;
	if( pVm == 0 ){
		return 0;
	}
	/* Allocate a new instance */
	pData = (jx9_stream_data *)SyMemBackendAlloc(&pVm->sAllocator, sizeof(jx9_stream_data));
	if( pData == 0 ){
		return 0;
	}
	/* Zero the structure */
	SyZero(pData, sizeof(jx9_stream_data));
	/* Initialize fields */
	pData->iType = iType;
	if( iType == JX9_IO_STREAM_OUTPUT ){
		/* Point to the default VM consumer routine. */
		pData->x.sConsumer = pVm->sVmConsumer; 
	}else{
#ifdef __WINNT__
		DWORD nChannel;
		switch(iType){
		case JX9_IO_STREAM_STDOUT:	nChannel = STD_OUTPUT_HANDLE; break;
		case JX9_IO_STREAM_STDERR:  nChannel = STD_ERROR_HANDLE; break;
		default:
			nChannel = STD_INPUT_HANDLE; 
			break;
		}
		pData->x.pHandle = GetStdHandle(nChannel);
#else
		/* Assume an UNIX system */
		int ifd = STDIN_FILENO;
		switch(iType){
		case JX9_IO_STREAM_STDOUT:  ifd = STDOUT_FILENO; break;
		case JX9_IO_STREAM_STDERR:  ifd = STDERR_FILENO; break;
		default:
			break;
		}
		pData->x.pHandle = SX_INT_TO_PTR(ifd);
#endif
	}
	pData->pVm = pVm;
	return pData;
}

// Assembly:
testq %rdi, %rdi
je 0x54c90
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x30, %esi
callq 0x343ed
testq %rax, %rax
je 0x54c93
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x2c, %rcx
jb 0x54c50
movl %r14d, 0x8(%rax)
cmpl $0x2, %r14d
je 0x54c9e
cmpl $0x3, %r14d
je 0x54c97
cmpl $0x4, %r14d
jne 0x54ca5
movups 0x4f8(%rbx), %xmm0
movups 0x508(%rbx), %xmm1
movups %xmm1, 0x20(%rax)
movups %xmm0, 0x10(%rax)
jmp 0x54cab
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x54cae
movl $0x2, %ecx
jmp 0x54ca7
movl $0x1, %ecx
jmp 0x54ca7
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9StreamData_Open
static int JX9StreamData_Open(const char *zName, int iMode, jx9_value *pResource, void ** ppHandle)
{
	jx9_stream_data *pData;
	SyString sStream;
	SyStringInitFromBuf(&sStream, zName, SyStrlen(zName));
	/* Trim leading and trailing white spaces */
	SyStringFullTrim(&sStream);
	/* Stream to open */
	if( SyStrnicmp(sStream.zString, "stdin", sizeof("stdin")-1) == 0 ){
		iMode = JX9_IO_STREAM_STDIN;
	}else if( SyStrnicmp(sStream.zString, "output", sizeof("output")-1) == 0 ){
		iMode = JX9_IO_STREAM_OUTPUT;
	}else if( SyStrnicmp(sStream.zString, "stdout", sizeof("stdout")-1) == 0 ){
		iMode = JX9_IO_STREAM_STDOUT;
	}else if( SyStrnicmp(sStream.zString, "stderr", sizeof("stderr")-1) == 0 ){
		iMode = JX9_IO_STREAM_STDERR;
	}else{
		/* unknown stream name */
		return -1;
	}
	/* Create our handle */
	pData = JX9StreamDataInit(pResource?pResource->pVm:0, iMode);
	if( pData == 0 ){
		return -1;
	}
	/* Make the handle public */
	*ppHandle = (void *)pData;
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
cmpb $0x0, (%rdi)
movq %rdi, %rax
je 0x54d05
leaq 0x2(%r15), %rax
cmpb $0x0, -0x1(%rax)
je 0x54cfd
cmpb $0x0, (%rax)
je 0x54d05
cmpb $0x0, 0x1(%rax)
je 0x54d02
leaq 0x4(%rax), %rcx
cmpb $0x0, 0x2(%rax)
movq %rcx, %rax
jne 0x54cd6
addq $-0x2, %rcx
movq %rcx, %rax
jmp 0x54d05
decq %rax
jmp 0x54d05
incq %rax
cmpl %r15d, %eax
je 0x54d32
movl %r15d, %r12d
subl %eax, %r12d
movsbq (%r15), %r13
cmpq $-0x41, %r13
ja 0x54d32
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
je 0x54d32
incq %r15
incl %r12d
jne 0x54d10
leaq 0x23c27(%rip), %rsi     # 0x78960
movq %r15, %rdi
movl $0x5, %edx
callq 0x3a837
testl %eax, %eax
je 0x54da0
leaq 0x23d32(%rip), %rsi     # 0x78a83
movq %r15, %rdi
movl $0x6, %edx
callq 0x3a837
testl %eax, %eax
je 0x54da7
leaq 0x23c04(%rip), %rsi     # 0x7896d
movq %r15, %rdi
movl $0x6, %edx
callq 0x3a837
testl %eax, %eax
je 0x54dae
leaq 0x23bfa(%rip), %rsi     # 0x7897b
movq %r15, %rdi
movl $0x6, %edx
callq 0x3a837
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x54dd6
movl $0x3, %esi
jmp 0x54db3
movl $0x1, %esi
jmp 0x54db3
movl $0x4, %esi
jmp 0x54db3
movl $0x2, %esi
testq %r14, %r14
je 0x54dbe
movq 0x10(%r14), %rdi
jmp 0x54dc0
xorl %edi, %edi
callq 0x54c28
testq %rax, %rax
je 0x54dd1
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x54dd6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_bool
static int jx9Builtin_is_bool(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_bool(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x54ead
movq (%rdx), %rax
movl 0x8(%rax), %r14d
shrl $0x3, %r14d
andl $0x1, %r14d
jmp 0x54eb0
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_float
static int jx9Builtin_is_float(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_float(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x54ef0
movq (%rdx), %rax
movl 0x8(%rax), %r14d
shrl $0x2, %r14d
andl $0x1, %r14d
jmp 0x54ef3
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_int
static int jx9Builtin_is_int(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_int(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x54f32
movq (%rdx), %rax
movl 0x8(%rax), %r14d
shrl %r14d
andl $0x1, %r14d
jmp 0x54f35
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_string
static int jx9Builtin_is_string(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_string(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x54f71
movq (%rdx), %rax
movl 0x8(%rax), %r14d
andl $0x1, %r14d
jmp 0x54f74
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_null
static int jx9Builtin_is_null(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_null(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x54fb4
movq (%rdx), %rax
movl 0x8(%rax), %r14d
shrl $0x5, %r14d
andl $0x1, %r14d
jmp 0x54fb7
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_numeric
static int jx9Builtin_is_numeric(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_numeric(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x54ff6
movq (%rdx), %rdi
callq 0x30e27
movl %eax, %r14d
jmp 0x54ff9
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_scalar
static int jx9Builtin_is_scalar(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_scalar(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x55038
movq (%rdx), %rax
xorl %r14d, %r14d
testb $0x2f, 0x8(%rax)
setne %r14b
jmp 0x5503b
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_array
static int jx9Builtin_is_array(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_json_array(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x5507b
movq (%rdx), %rax
movl 0x8(%rax), %r14d
shrl $0x6, %r14d
andl $0x1, %r14d
jmp 0x5507e
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_object
static int jx9Builtin_is_object(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_json_object(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x550b6
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x550bb
xorl %r14d, %r14d
jmp 0x550c6
movq (%rax), %rax
movl 0x40(%rax), %r14d
andl $0x1, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_resource
static int jx9Builtin_is_resource(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_resource(apArg[0]);
	}
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x55106
movq (%rdx), %rax
movl 0x8(%rax), %r14d
shrl $0x8, %r14d
andl $0x1, %r14d
jmp 0x55109
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_floatval
static int jx9Builtin_floatval(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* return 0.0 */
		jx9_result_double(pCtx, 0);
	}else{
		double dval;
		/* Perform the cast */
		dval = jx9_value_to_double(apArg[0]);
		jx9_result_double(pCtx, dval);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x55151
movq (%rdx), %r14
movq %r14, %rdi
callq 0x44891
movsd (%r14), %xmm0
jmp 0x55154
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x4, %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x44d9d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_intval
static int jx9Builtin_intval(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* return 0 */
		jx9_result_int(pCtx, 0);
	}else{
		sxi64 iVal;
		/* Perform the cast */
		iVal = jx9_value_to_int64(apArg[0]);
		jx9_result_int64(pCtx, iVal);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x551ad
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3fd5f
movq (%r14), %r14
jmp 0x551b0
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strval
static int jx9Builtin_strval(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* return NULL */
		jx9_result_null(pCtx);
	}else{
		const char *zVal;
		int iLen = 0; /* cc -O6 warning */
		/* Perform the cast */
		zVal = jx9_value_to_string(apArg[0], &iLen);
		jx9_result_string(pCtx, zVal, iLen);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x5520d
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
movq (%rdx), %rdi
movq %r14, %rsi
callq 0x30b04
movl (%r14), %edx
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x3087c
jmp 0x55216
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_empty
static int jx9Builtin_empty(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 1; /* Assume empty by default */
	if( nArg > 0 ){
		res = jx9_value_is_empty(apArg[0]);
	}
	jx9_result_bool(pCtx, res);
	return JX9_OK;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x5523c
movq (%rdx), %rdi
callq 0x30ebf
movl %eax, %r14d
jmp 0x55242
movl $0x1, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_round
static int jx9Builtin_round(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int n = 0;
	double r;
	if( nArg < 1 ){
		/* Missing argument, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the precision if available */
	if( nArg > 1 ){
		n = jx9_value_to_int(apArg[1]);
		if( n>30 ){
			n = 30;
		}
		if( n<0 ){
			n = 0;
		}
	}
	r = jx9_value_to_double(apArg[0]);
	/* If Y==0 and X will fit in a 64-bit int, 
     * handle the rounding directly.Otherwise 
	 * use our own cutsom printf [i.e:SyBufferFormat()].
     */
  if( n==0 && r>=0 && r<LARGEST_INT64-1 ){
    r = (double)((jx9_int64)(r+0.5));
  }else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){
    r = -(double)((jx9_int64)((-r)+0.5));
  }else{
	  char zBuf[256];
	  sxu32 nLen;
	  nLen = SyBufferFormat(zBuf, sizeof(zBuf), "%.*f", n, r);
	  /* Convert the string to real number */
	  SyStrToReal(zBuf, nLen, (void *)&r, 0);
  }
  /* Return thr rounded value */
  jx9_result_double(pCtx, r);
  return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
testl %esi, %esi
jle 0x552fc
movq %rdx, %r15
xorl %r14d, %r14d
cmpl $0x1, %esi
je 0x552ab
movq 0x8(%r15), %r14
movq %r14, %rdi
callq 0x3fd5f
movl (%r14), %eax
cmpl $0x1e, %eax
movl $0x1e, %ecx
cmovll %eax, %ecx
xorl %r14d, %r14d
testl %ecx, %ecx
cmovgl %ecx, %r14d
movq (%r15), %r15
movq %r15, %rdi
callq 0x44891
movsd (%r15), %xmm0
movsd %xmm0, -0x20(%rbp)
testl %r14d, %r14d
jne 0x55322
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x55322
movsd 0x20379(%rip), %xmm1    # 0x75650
ucomisd %xmm0, %xmm1
jbe 0x55322
addsd 0x2033b(%rip), %xmm0    # 0x75620
cvttsd2si %xmm0, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x55391
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
jmp 0x553c6
testl %r14d, %r14d
jne 0x55363
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x55363
ucomisd 0x20327(%rip), %xmm0    # 0x75660
jbe 0x55363
movsd 0x202dd(%rip), %xmm1    # 0x75620
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
xorpd 0x20254(%rip), %xmm0    # 0x755b0
movlpd %xmm0, -0x20(%rbp)
jmp 0x55391
leaq 0x23b58(%rip), %rdx     # 0x78ec2
leaq -0x130(%rbp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movl %r14d, %ecx
movb $0x1, %al
callq 0x350d9
leaq -0x20(%rbp), %rdx
movq %r15, %rdi
movl %eax, %esi
callq 0x3f365
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x4, %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x44d9d
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_dechex
static int jx9Builtin_dechex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iVal;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the given number */
	iVal = jx9_value_to_int(apArg[0]);
	/* Format */
	jx9_result_string_format(pCtx, "%x", iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x55405
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3fd5f
movl (%r14), %edx
leaq 0x23ace(%rip), %rsi     # 0x78ec7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45c53
jmp 0x5540e
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_decoct
static int jx9Builtin_decoct(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iVal;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the given number */
	iVal = jx9_value_to_int(apArg[0]);
	/* Format */
	jx9_result_string_format(pCtx, "%o", iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x55444
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3fd5f
movl (%r14), %edx
leaq 0x23a92(%rip), %rsi     # 0x78eca
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45c53
jmp 0x5544d
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_decbin
static int jx9Builtin_decbin(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iVal;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the given number */
	iVal = jx9_value_to_int(apArg[0]);
	/* Format */
	jx9_result_string_format(pCtx, "%B", iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x55483
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3fd5f
movl (%r14), %edx
leaq 0x23a56(%rip), %rsi     # 0x78ecd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45c53
jmp 0x5548c
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_hexdec
static int jx9Builtin_hexdec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString, *zEnd;
	jx9_int64 iVal;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	iVal = 0;
	if( jx9_value_is_string(apArg[0]) ){
		/* Extract the given string */
		zString = jx9_value_to_string(apArg[0], &nLen);
		/* Delimit the string */
		zEnd = &zString[nLen];
		/* Ignore non hex-stream */
		while( zString < zEnd ){
			if( (unsigned char)zString[0] >= 0xc0 ){
				/* UTF-8 stream */
				zString++;
				while( zString < zEnd && (((unsigned char)zString[0] & 0xc0) == 0x80) ){
					zString++;
				}
			}else{
				if( SyisHex(zString[0]) ){
					break;
				}
				/* Ignore */
				zString++;
			}
		}
		if( zString < zEnd ){
			/* Cast */
			SyHexStrToInt64(zString, (sxu32)(zEnd-zString), (void *)&iVal, 0);
		}
	}else{
		/* Extract as a 64-bit integer */
		iVal = jx9_value_to_int64(apArg[0]);
	}
	/* Return the number */
	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 %rdi, %rbx
testl %esi, %esi
jle 0x554cc
movq $0x0, -0x28(%rbp)
movq (%rdx), %r14
testb $0x1, 0x8(%r14)
jne 0x554d5
movq %r14, %rdi
callq 0x3fd5f
movq (%r14), %rax
movq %rax, -0x28(%rbp)
jmp 0x55547
movq $-0x1, %r14
jmp 0x5554b
leaq -0x2c(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x30b04
movslq (%r12), %r14
testq %r14, %r14
jle 0x55547
movq %rax, %r15
addq %rax, %r14
movsbq (%r15), %r12
cmpq $-0x40, %r12
jb 0x5551b
incq %r15
movq %r15, %rax
movq %rax, %r15
cmpq %r14, %rax
jae 0x5552e
movb (%r15), %cl
andb $-0x40, %cl
leaq 0x1(%r15), %rax
negb %cl
jo 0x55503
jmp 0x5552e
callq 0xc170
movq (%rax), %rax
testb $0x10, 0x1(%rax,%r12,2)
jne 0x55535
incq %r15
cmpq %r14, %r15
jb 0x554f3
jmp 0x55547
subl %r15d, %r14d
leaq -0x28(%rbp), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x4062c
movq -0x28(%rbp), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_bindec
static int jx9Builtin_bindec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	jx9_int64 iVal;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	iVal = 0;
	if( jx9_value_is_string(apArg[0]) ){
		/* Extract the given string */
		zString = jx9_value_to_string(apArg[0], &nLen);
		if( nLen > 0 ){
			/* Perform a binary cast */
			SyBinaryStrToInt64(zString, (sxu32)nLen, (void *)&iVal, 0);
		}
	}else{
		/* Extract as a 64-bit integer */
		iVal = jx9_value_to_int64(apArg[0]);
	}
	/* Return the number */
	jx9_result_int64(pCtx, iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x555ae
movq $0x0, -0x20(%rbp)
movq (%rdx), %r14
testb $0x1, 0x8(%r14)
jne 0x555b7
movq %r14, %rdi
callq 0x3fd5f
movq (%r14), %rax
movq %rax, -0x20(%rbp)
jmp 0x555d9
movq $-0x1, %r14
jmp 0x555dd
leaq -0x24(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30b04
movl (%r15), %esi
testl %esi, %esi
jle 0x555d9
leaq -0x20(%rbp), %rdx
movq %rax, %rdi
callq 0x40895
movq -0x20(%rbp), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_octdec
static int jx9Builtin_octdec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	jx9_int64 iVal;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	iVal = 0;
	if( jx9_value_is_string(apArg[0]) ){
		/* Extract the given string */
		zString = jx9_value_to_string(apArg[0], &nLen);
		if( nLen > 0 ){
			/* Perform the cast */
			SyOctalStrToInt64(zString, (sxu32)nLen, (void *)&iVal, 0);
		}
	}else{
		/* Extract as a 64-bit integer */
		iVal = jx9_value_to_int64(apArg[0]);
	}
	/* Return the number */
	jx9_result_int64(pCtx, iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x5563e
movq $0x0, -0x20(%rbp)
movq (%rdx), %r14
testb $0x1, 0x8(%r14)
jne 0x55647
movq %r14, %rdi
callq 0x3fd5f
movq (%r14), %rax
movq %rax, -0x20(%rbp)
jmp 0x55669
movq $-0x1, %r14
jmp 0x5566d
leaq -0x24(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30b04
movl (%r15), %esi
testl %esi, %esi
jle 0x55669
leaq -0x20(%rbp), %rdx
movq %rax, %rdi
callq 0x40a4e
movq -0x20(%rbp), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_base_convert
static int jx9Builtin_base_convert(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int nLen, iFbase, iTobase;
	const char *zNum;
	jx9_int64 iNum;
	if( nArg < 3 ){
		/* Return the empty string*/
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Base numbers */
	iFbase  = jx9_value_to_int(apArg[1]);
	iTobase = jx9_value_to_int(apArg[2]);
	if( jx9_value_is_string(apArg[0]) ){
		/* Extract the target number */
		zNum = jx9_value_to_string(apArg[0], &nLen);
		if( nLen < 1 ){
			/* Return the empty string*/
			jx9_result_string(pCtx, "", 0);
			return JX9_OK;
		}
		/* Base conversion */
		switch(iFbase){
		case 16:
			/* Hex */
			SyHexStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
			break;
		case 8:
			/* Octal */
			SyOctalStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
			break;
		case 2:
			/* Binary */
			SyBinaryStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
			break;
		default:
			/* Decimal */
			SyStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
			break;
		}
	}else{
		iNum = jx9_value_to_int64(apArg[0]);
	}
	switch(iTobase){
	case 16:
		/* Hex */
		jx9_result_string_format(pCtx, "%qx", iNum); /* Quad hex */
		break;
	case 8:
		/* Octal */
		jx9_result_string_format(pCtx, "%qo", iNum); /* Quad octal */
		break;
	case 2:
		/* Binary */
		jx9_result_string_format(pCtx, "%qB", iNum); /* Quad binary */
		break;
	default:
		/* Decimal */
		jx9_result_string_format(pCtx, "%qd", iNum); /* Quad decimal */
		break;
	}
	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 $0x2, %esi
jg 0x556c7
movq 0x8(%rbx), %rdi
leaq 0x23fac(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
jmp 0x5577d
movq %rdx, %r14
movq 0x8(%rdx), %r15
movq %r15, %rdi
callq 0x3fd5f
movl (%r15), %r13d
movq 0x10(%r14), %r15
movq %r15, %rdi
callq 0x3fd5f
movl (%r15), %r12d
movq (%r14), %r14
testb $0x1, 0x8(%r14)
jne 0x55720
movq %r14, %rdi
callq 0x3fd5f
movq (%r14), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
cmpl $0x2, %r12d
je 0x55763
cmpl $0x8, %r12d
je 0x5575a
cmpl $0x10, %r12d
jne 0x5576c
leaq 0x237b2(%rip), %rsi     # 0x78ed0
jmp 0x55773
leaq -0x34(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30b04
movl (%r15), %esi
testl %esi, %esi
jle 0x556b0
leaq -0x30(%rbp), %rdx
movq %rax, %rdi
cmpl $0x2, %r13d
je 0x55798
cmpl $0x8, %r13d
je 0x5578e
cmpl $0x10, %r13d
jne 0x557a2
callq 0x4062c
jmp 0x55701
leaq 0x23773(%rip), %rsi     # 0x78ed4
jmp 0x55773
leaq 0x2376e(%rip), %rsi     # 0x78ed8
jmp 0x55773
leaq 0x20960(%rip), %rsi     # 0x760d3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45c53
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x40a4e
jmp 0x55701
callq 0x40895
jmp 0x55701
callq 0x40c31
jmp 0x55701
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_substr
static int jx9Builtin_substr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zSource, *zOfft;
	int nOfft, nLen, nSrcLen;	
	if( nArg < 2 ){
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zSource = jx9_value_to_string(apArg[0], &nSrcLen);
	if( nSrcLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	nLen = nSrcLen; /* cc warning */
	/* Extract the offset */
	nOfft = jx9_value_to_int(apArg[1]);
	if( nOfft < 0 ){
		zOfft = &zSource[nSrcLen+nOfft]; 
		if( zOfft < zSource ){
			/* Invalid offset */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		nLen = (int)(&zSource[nSrcLen]-zOfft);
		nOfft = (int)(zOfft-zSource);
	}else if( nOfft >= nSrcLen ){
		/* Invalid offset */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}else{
		zOfft = &zSource[nOfft];
		nLen = nSrcLen - nOfft;
	}
	if( nArg > 2 ){
		/* Extract the length */
		nLen = jx9_value_to_int(apArg[2]);
		if( nLen == 0 ){
			/* Invalid length, return an empty string */
			jx9_result_string(pCtx, "", 0);
			return JX9_OK;
		}else if( nLen < 0 ){
			nLen = nSrcLen + nLen - nOfft;
			if( nLen < 1 ){
				/* Invalid  length */
				nLen = nSrcLen - nOfft;
			}
		}
		if( nLen + nOfft > nSrcLen ){
			/* Invalid length */
			nLen = nSrcLen - nOfft;
		}
	}
	/* Return the substring */
	jx9_result_string(pCtx, zOfft, nLen);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jle 0x557ff
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x30b04
cmpl $0x0, (%r13)
jle 0x557ff
movq %rax, %r14
movq 0x8(%r15), %r13
movq %r13, %rdi
callq 0x3fd5f
movl (%r13), %eax
movl -0x2c(%rbp), %edx
testl %eax, %eax
js 0x55831
movl %eax, %r13d
cmpl %eax, %edx
jg 0x5583d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl %eax, %edx
movl %edx, %r13d
movl $0x0, %edx
js 0x557ff
cmpl $0x2, %r12d
jne 0x55847
subl %eax, %edx
jmp 0x5587f
movq 0x10(%r15), %r15
movq %r15, %rdi
callq 0x3fd5f
movl (%r15), %eax
testl %eax, %eax
je 0x55893
jns 0x5586e
movl -0x2c(%rbp), %ecx
subl %r13d, %eax
addl %ecx, %eax
subl %r13d, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, %eax
leal (%rax,%r13), %ecx
movl -0x2c(%rbp), %esi
movl %esi, %edx
subl %r13d, %edx
cmpl %esi, %ecx
cmovlel %eax, %edx
movl %r13d, %eax
addq %rax, %r14
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3087c
jmp 0x55820
movq 0x8(%rbx), %rdi
leaq 0x23dc9(%rip), %rsi     # 0x79667
xorl %edx, %edx
jmp 0x5588c
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_chunk_split
static int jx9Builtin_chunk_split(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn, *zEnd, *zSep = "\r\n";
	int nSepLen, nChunkLen, nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Nothing to split, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* initialize/Extract arguments */
	nSepLen = (int)sizeof("\r\n") - 1;
	nChunkLen = 76;
	zIn = jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nArg > 1 ){
		/* Chunk length */
		nChunkLen = jx9_value_to_int(apArg[1]);
		if( nChunkLen < 1 ){
			/* Switch back to the default length */
			nChunkLen = 76;
		}
		if( nArg > 2 ){
			/* Separator */
			zSep = jx9_value_to_string(apArg[2], &nSepLen);
			if( nSepLen < 1 ){
				/* Switch back to the default separator */
				zSep = "\r\n";
				nSepLen = (int)sizeof("\r\n") - 1;
			}
		}
	}
	/* Perform the requested operation */
	if( nChunkLen > nLen ){
		/* Nothing to split, return the string and the separator */
		jx9_result_string_format(pCtx, "%.*s%.*s", nLen, zIn, nSepLen, zSep);
		return JX9_OK;
	}
	while( zIn < zEnd ){
		if( nChunkLen > (int)(zEnd-zIn) ){
			nChunkLen = (int)(zEnd - zIn);
		}
		/* Append the chunk and the separator */
		jx9_result_string_format(pCtx, "%.*s%.*s", nChunkLen, zIn, nSepLen, zSep);
		/* Point beyond the chunk */
		zIn += nChunkLen;
	}
	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 0x55be7
movq %rdx, %r13
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x55c01
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r15d
movl $0x2, -0x2c(%rbp)
leaq -0x3c(%rbp), %r12
movq %r12, %rsi
callq 0x30b04
movq %rax, %r14
movslq (%r12), %rax
movl $0x4c, %r12d
leaq 0x2475f(%rip), %r9      # 0x7a38a
cmpl $0x1, %r15d
je 0x55c84
movq %rax, -0x38(%rbp)
movq 0x8(%r13), %r12
movq %r12, %rdi
callq 0x3fd5f
movl (%r12), %eax
testl %eax, %eax
movl $0x4c, %r12d
cmovgl %eax, %r12d
cmpl $0x3, %r15d
jl 0x55c79
movq 0x10(%r13), %rdi
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
cmpl $0x0, (%r15)
jle 0x55c72
movq %rax, %r9
jmp 0x55c80
movl $0x2, -0x2c(%rbp)
leaq 0x2470a(%rip), %r9      # 0x7a38a
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %edx
cmpl %edx, %r12d
jle 0x55ca9
movl -0x2c(%rbp), %r8d
leaq 0x23245(%rip), %rsi     # 0x78edc
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x45c53
jmp 0x55bf0
testl %eax, %eax
jle 0x55bf0
movq %r14, %r13
addq %rax, %r13
movl %r13d, %eax
subl %r14d, %eax
cmpl %eax, %r12d
cmovgel %eax, %r12d
movl -0x2c(%rbp), %r8d
movq %rbx, %rdi
leaq 0x2320a(%rip), %rsi     # 0x78edc
movl %r12d, %edx
movq %r14, %rcx
movq %r9, %r15
xorl %eax, %eax
callq 0x45c53
movq %r15, %r9
movslq %r12d, %rax
addq %rax, %r14
cmpq %r13, %r14
jb 0x55cb7
jmp 0x55bf0