LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmGetNextLine
static sxi32 VmGetNextLine(SyString *pCursor, SyString *pCurrent)
{ 
  	const char *zIn;
  	sxu32 nPos; 
	/* Jump leading white spaces */
	SyStringLeftTrim(pCursor);
	if( pCursor->nByte < 1 ){
		SyStringInitFromBuf(pCurrent, 0, 0);
		return SXERR_EOF; /* End of input */
	}
	zIn = SyStringData(pCursor);
	if( SXRET_OK != SyByteListFind(pCursor->zString, pCursor->nByte, "\r\n", &nPos) ){
		/* Line not found, tell the caller to read more input from source */
		SyStringDupPtr(pCurrent, pCursor);
		return SXERR_MORE;
	}
  	pCurrent->zString = zIn;
  	pCurrent->nByte	= nPos;	
  	/* advance the cursor so we can call this routine again */
  	pCursor->zString = &zIn[nPos];
  	pCursor->nByte -= nPos;
  	return SXRET_OK;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
je 0x3db3a
movq (%r14), %r15
movsbq (%r15), %r13
cmpq $-0x41, %r13
ja 0x3dad8
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
je 0x3dad8
decq %r12
movl %r12d, 0x8(%r14)
incq %r15
movq %r15, (%r14)
jmp 0x3daa3
leaq (%r15,%r12), %rdx
leaq 0x3(%r15), %rax
leaq -0x3(%rax), %rcx
cmpq %rdx, %rcx
jae 0x3db46
movzbl (%rcx), %esi
cmpl $0xa, %esi
je 0x3db55
cmpl $0xd, %esi
je 0x3db55
leaq -0x2(%rax), %rcx
cmpq %rdx, %rcx
jae 0x3db46
movzbl (%rcx), %esi
cmpl $0xa, %esi
je 0x3db55
cmpl $0xd, %esi
je 0x3db55
leaq -0x1(%rax), %rcx
cmpq %rdx, %rcx
jae 0x3db46
movzbl (%rcx), %esi
cmpl $0xa, %esi
je 0x3db55
cmpl $0xd, %esi
je 0x3db55
cmpq %rdx, %rax
jae 0x3db46
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x3db52
cmpl $0xd, %ecx
je 0x3db52
addq $0x4, %rax
jmp 0x3dae0
andq $0x0, (%rbx)
andl $0x0, 0x8(%rbx)
pushq $-0x12
jmp 0x3db4f
movq %r15, (%rbx)
movl %r12d, 0x8(%rbx)
pushq $-0x8
popq %rax
jmp 0x3db6c
movq %rax, %rcx
subq %r15, %rcx
movq %r15, (%rbx)
movl %ecx, 0x8(%rbx)
movl %ecx, %eax
addq %r15, %rax
movq %rax, (%r14)
subl %ecx, 0x8(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyByteFind
JX9_PRIVATE sxi32 SyByteFind(const char *zStr, sxu32 nLen, sxi32 c, sxu32 *pPos)
{
	const char *zIn = zStr;
	const char *zEnd;
	
	zEnd = &zIn[nLen];
	for(;;){
		if( zIn >= zEnd ){ break; }if( zIn[0] == c ){ if( pPos ){ *pPos = (sxu32)(zIn - zStr); } return SXRET_OK; } zIn++;
		if( zIn >= zEnd ){ break; }if( zIn[0] == c ){ if( pPos ){ *pPos = (sxu32)(zIn - zStr); } return SXRET_OK; } zIn++;
		if( zIn >= zEnd ){ break; }if( zIn[0] == c ){ if( pPos ){ *pPos = (sxu32)(zIn - zStr); } return SXRET_OK; } zIn++;
		if( zIn >= zEnd ){ break; }if( zIn[0] == c ){ if( pPos ){ *pPos = (sxu32)(zIn - zStr); } return SXRET_OK; } zIn++;
	}
	return SXERR_NOTFOUND;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %esi
addq %rdi, %rsi
leaq 0x3(%rdi), %r8
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
leaq -0x3(%r8), %r9
cmpq %rsi, %r9
jae 0x3dfef
movsbl (%r9), %r10d
cmpl %edx, %r10d
je 0x3dfe2
leaq -0x2(%r8), %r9
cmpq %rsi, %r9
jae 0x3dfef
movsbl (%r9), %r10d
cmpl %edx, %r10d
je 0x3dfe2
leaq -0x1(%r8), %r9
cmpq %rsi, %r9
jae 0x3dfef
movsbl (%r9), %r10d
cmpl %edx, %r10d
je 0x3dfe2
cmpq %rsi, %r8
jae 0x3dfef
movsbl (%r8), %r9d
cmpl %edx, %r9d
je 0x3dfdf
addq $0x4, %r8
jmp 0x3df95
movq %r8, %r9
testq %rcx, %rcx
je 0x3dfed
subl %edi, %r9d
movl %r9d, (%rcx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyAsciiToHex
static sxi32 SyAsciiToHex(sxi32 c)
{
	if( c >= 'a' && c <= 'f' ){
		c += 10 - 'a';
		return c;
	}
	if( c >= '0' && c <= '9' ){
		c -= '0';
		return c;
	}
	if( c >= 'A' && c <= 'F') {
		c += 10 - 'A';
		return c;
	}		
	return 0; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x61(%rdi), %eax
cmpl $0x5, %eax
ja 0x3e1d0
addl $-0x57, %edi
movl %edi, %eax
jmp 0x3e1e6
leal -0x30(%rdi), %eax
cmpl $0xa, %eax
jb 0x3e1e6
leal -0x41(%rdi), %ecx
addl $-0x37, %edi
xorl %eax, %eax
cmpl $0x6, %ecx
cmovbl %edi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9VmPushFilePath
JX9_PRIVATE sxi32 jx9VmPushFilePath(jx9_vm *pVm, const char *zPath, int nLen, sxu8 bMain, sxi32 *pNew)
{
	SyString sPath;
	char *zDup;
#ifdef __WINNT__
	char *zCur;
#endif
	sxi32 rc;
	if( nLen < 0 ){
		nLen = SyStrlen(zPath);
	}
	/* Duplicate the file path first */
	zDup = SyMemBackendStrDup(&pVm->sAllocator, zPath, nLen);
	if( zDup == 0 ){
		return SXERR_MEM;
	}
#ifdef __WINNT__
	/* Normalize path on windows
	 * Example:
	 *    Path/To/File.jx9
	 * becomes
	 *   path\to\file.jx9
	 */
	zCur = zDup;
	while( zCur[0] != 0 ){
		if( zCur[0] == '/' ){
			zCur[0] = '\\';
		}else if( (unsigned char)zCur[0] < 0xc0 && SyisUpper(zCur[0]) ){
			int c = SyToLower(zCur[0]);
			zCur[0] = (char)c; /* MSVC stupidity */
		}
		zCur++;
	}
#endif
	/* Install the file path */
	SyStringInitFromBuf(&sPath, zDup, nLen);
	if( !bMain ){
		if( VmIsIncludedFile(&(*pVm), &sPath) ){
			/* Already included */
			*pNew = 0;
		}else{
			/* Insert in the corresponding container */
			rc = SySetPut(&pVm->aIncluded, (const void *)&sPath);
			if( rc != SXRET_OK ){
				SyMemBackendFree(&pVm->sAllocator, zDup);
				return rc;
			}
			*pNew = 1;
		}
	}
	SySetPut(&pVm->aFiles, (const void *)&sPath);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %r13d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
testl %edx, %edx
jns 0x3ea22
movq %r12, %rdi
callq 0x28e24
movl %eax, %r15d
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x35732
testq %rax, %rax
je 0x3eaf0
movq %rax, %r12
movq %rax, -0x48(%rbp)
movl %r15d, -0x40(%rbp)
testb %r13b, %r13b
jne 0x3eadd
movq %r14, -0x30(%rbp)
movq 0x440(%rbx), %r13
movq %rbx, -0x38(%rbp)
movl 0x448(%rbx), %r14d
shlq $0x4, %r14
addq $0x10, %r14
xorl %ecx, %ecx
leaq 0x10(%rcx), %rbx
cmpq %rbx, %r14
je 0x3eaa3
movl %r15d, %eax
subl 0x8(%r13,%rcx), %eax
jne 0x3ea90
movq (%r13,%rcx), %rsi
movq %r12, %rdi
movl %r15d, %edx
callq 0x2d30e
movq %rbx, %rcx
testl %eax, %eax
jne 0x3ea6d
xorl %eax, %eax
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %rcx
jmp 0x3eadb
movq -0x38(%rbp), %rbx
leaq 0x438(%rbx), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2be00
testl %eax, %eax
movq -0x30(%rbp), %rcx
je 0x3ead8
movq %rbx, %rdi
movq %r12, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d420
pushq $0x1
popq %rax
movl %eax, (%rcx)
addq $0x3e8, %rbx            # imm = 0x3E8
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x2be00
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileScript
JX9_PRIVATE sxi32 jx9CompileScript(
	jx9_vm *pVm,        /* Generate JX9 bytecodes for this Virtual Machine */
	SyString *pScript,  /* Script to compile */
	sxi32 iFlags        /* Compile flags */
	)
{
	jx9_gen_state *pGen;
	SySet aToken;
	sxi32 rc;
	if( pScript->nByte < 1 ){
		/* Nothing to compile */
		return JX9_OK;
	}
	/* Initialize the tokens containers */
	SySetInit(&aToken, &pVm->sAllocator, sizeof(SyToken));
	SySetAlloc(&aToken, 0xc0);
	pGen = &pVm->sCodeGen;
	rc = JX9_OK;
	/* Tokenize the JX9 chunk first */
	jx9Tokenize(pScript->zString,pScript->nByte,&aToken);
	if( SySetUsed(&aToken) < 1 ){
		return SXERR_EMPTY;
	}
	/* Point to the head and tail of the token stream. */
	pGen->pIn  = (SyToken *)SySetBasePtr(&aToken);
	pGen->pEnd = &pGen->pIn[SySetUsed(&aToken)];
	/* Compile the chunk */
	rc = GenStateCompileChunk(pGen,iFlags);
	/* Cleanup */
	SySetRelease(&aToken);
	return rc;
}

// Assembly:
cmpl $0x0, 0x8(%rsi)
je 0x3eba7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x2000000000, %rax     # imm = 0x2000000000
leaq -0x40(%rbp), %r15
movq %rax, 0x14(%r15)
andl $0x0, 0x10(%r15)
andl $0x0, 0x1c(%r15)
movq %rdi, (%r15)
andq $0x0, 0x8(%r15)
andq $0x0, 0x20(%r15)
movq %r15, %rdi
movl $0xc0, %esi
callq 0x3eba8
movq (%r14), %rdi
movl 0x8(%r14), %esi
movq %r15, %rdx
callq 0x3f009
movl 0x10(%r15), %eax
testq %rax, %rax
je 0x3eb9d
leaq 0x568(%rbx), %rdi
leaq -0x40(%rbp), %r14
movq 0x8(%r14), %rcx
movq %rcx, 0x6c0(%rbx)
shlq $0x5, %rax
addq %rcx, %rax
movq %rax, 0x6c8(%rbx)
xorl %esi, %esi
callq 0x3f05e
movq %r14, %rdi
callq 0x31feb
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SySetAlloc
JX9_PRIVATE sxi32 SySetAlloc(SySet *pSet, sxi32 nItem)
{
	if( pSet->nSize > 0 ){
		return SXERR_LOCKED;
	}
	if( nItem < 8 ){
		nItem = 8;
	}
	pSet->pBase = SyMemBackendAlloc(pSet->pAllocator, pSet->eSize * nItem);
	if( pSet->pBase == 0 ){
		return SXERR_MEM;
	}
	pSet->nSize = nItem;
	return SXRET_OK;
}

// Assembly:
cmpl $0x0, 0x14(%rdi)
je 0x3ebaf
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
movl 0x18(%r14), %esi
imull %ebx, %esi
callq 0x2ca19
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x3ebd7
movl %ebx, 0x14(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9VmReserveConstObj
JX9_PRIVATE jx9_value * jx9VmReserveConstObj(jx9_vm *pVm, sxu32 *pIndex)
{
	jx9_value *pObj;
	sxi32 rc;
	if( pIndex ){
		/* Object index in the object table */
		*pIndex = SySetUsed(&pVm->aLitObj);
	}
	/* Reserve a slot for the new object */
	rc = SySetPut(&pVm->aLitObj, (const void *)zDummy);
	if( rc != SXRET_OK ){
		/* If the supplied memory subsystem is so sick that we are unable to allocate
		 * a tiny chunk of memory, there is no much we can do here.
		 */
		return 0;
	}
	pObj = (jx9_value *)SySetPeek(&pVm->aLitObj);
	return pObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3ebf2
movl 0x240(%rbx), %eax
movl %eax, (%rsi)
leaq 0x230(%rbx), %rdi
leaq 0x24010(%rip), %rsi     # 0x62c10
callq 0x2be00
testl %eax, %eax
je 0x3ec0d
xorl %eax, %eax
jmp 0x3ec27
movl 0x240(%rbx), %eax
testl %eax, %eax
je 0x3ec09
decl %eax
imull 0x248(%rbx), %eax
addq 0x238(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjInitFromBool
JX9_PRIVATE sxi32 jx9MemObjInitFromBool(jx9_vm *pVm, jx9_value *pObj, sxi32 iVal)
{
	/* Zero the structure */
	SyZero(pObj, sizeof(jx9_value));
	/* Initialize fields */
	pObj->pVm = pVm;
	SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
	/* Set the desired type */
	pObj->x.iVal = iVal ? 1 : 0;
	pObj->iFlags = MEMOBJ_BOOL;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x27aea
movq %r15, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq %r15, 0x18(%r14)
andl $0x0, 0x30(%r14)
xorl %eax, %eax
testl %ebx, %ebx
setne %al
movq %rax, (%r14)
movl $0x8, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9ResetCodeGenerator
JX9_PRIVATE sxi32 jx9ResetCodeGenerator(
	jx9_vm *pVm,       /* Target VM */
	ProcConsumer xErr, /* Error log consumer callabck  */
	void *pErrData     /* Last argument to xErr() */
	)
{
	jx9_gen_state *pGen = &pVm->sCodeGen;
	GenBlock *pBlock, *pParent;
	/* Point to the global scope */
	pBlock = pGen->pCurrent;
	while( pBlock->pParent != 0 ){
		pParent = pBlock->pParent;
		GenStateFreeBlock(pBlock);
		pBlock = pParent;
	}
	pGen->xErr = xErr;
	pGen->pErrData = pErrData;
	pGen->pCurrent = &pGen->sGlobal;
	pGen->pIn = pGen->pEnd = 0;
	pGen->nErr = 0;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x630(%rdi), %rdi
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x3ede9
callq 0x3efdb
movq %r12, %rdi
jmp 0x3edd6
movq %r15, 0x6b0(%rbx)
movq %r14, 0x6b8(%rbx)
leaq 0x638(%rbx), %rax
movq %rax, 0x630(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x6c0(%rbx)
andl $0x0, 0x6d0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateInitBlock
static void GenStateInitBlock(
	jx9_gen_state *pGen, /* Code generator state */
	GenBlock *pBlock,    /* Target block */
	sxi32 iType,         /* Block type [i.e: loop, conditional, function body, etc.]*/
	sxu32 nFirstInstr,   /* First instruction to compile */
	void *pUserData      /* Upper layer private data */
	)
{
	/* Initialize block fields */
	pBlock->nFirstInstr = nFirstInstr;
	pBlock->pUserData   = pUserData;
	pBlock->pGen        = pGen;
	pBlock->iFlags      = iType;
	pBlock->pParent     = 0;
	pBlock->bPostContinue = 0;
	SySetInit(&pBlock->aJumpFix, &pGen->pVm->sAllocator, sizeof(JumpFixup));
	SySetInit(&pBlock->aPostContFix, &pGen->pVm->sAllocator, sizeof(JumpFixup));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %ecx, 0x10(%rsi)
movq %r8, 0x40(%rsi)
movq %rdi, (%rsi)
movl %edx, 0x14(%rsi)
andq $0x0, 0x8(%rsi)
movb $0x0, 0x48(%rsi)
movq (%rdi), %rax
movaps 0x247dd(%rip), %xmm0    # 0x63620
movups %xmm0, 0x28(%rsi)
movq %rax, 0x18(%rsi)
andq $0x0, 0x20(%rsi)
andq $0x0, 0x38(%rsi)
movq $0x8, 0x68(%rsi)
movq %rax, 0x50(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsi)
andq $0x0, 0x70(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9VmEmitInstr
JX9_PRIVATE sxi32 jx9VmEmitInstr(
	jx9_vm *pVm,  /* Target VM */
	sxi32 iOp,    /* Operation to perform */
	sxi32 iP1,    /* First operand */
	sxu32 iP2,    /* Second operand */
	void *p3,     /* Third operand */
	sxu32 *pIndex /* Instruction index. NULL otherwise */
	)
{
	VmInstr sInstr;
	sxi32 rc;
	/* Fill the VM instruction */
	sInstr.iOp = (sxu8)iOp; 
	sInstr.iP1 = iP1; 
	sInstr.iP2 = iP2; 
	sInstr.p3  = p3;  
	if( pIndex ){
		/* Instruction index in the bytecode array */
		*pIndex = SySetUsed(pVm->pByteContainer);
	}
	/* Finally, record the instruction */
	rc = SySetPut(pVm->pByteContainer, (const void *)&sInstr);
	if( rc != SXRET_OK ){
		jx9GenCompileError(&pVm->sCodeGen, E_ERROR, 1, "Fatal, Cannot emit instruction due to a memory failure");
		/* Fall throw */
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb %sil, -0x28(%rbp)
movl %edx, -0x24(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x18(%rbp)
movq 0xf0(%rdi), %rdi
testq %r9, %r9
je 0x3ee9d
movl 0x10(%rdi), %eax
movl %eax, (%r9)
leaq -0x28(%rbp), %rsi
callq 0x2be00
movl %eax, %r14d
testl %eax, %eax
je 0x3eeca
addq $0x568, %rbx            # imm = 0x568
leaq 0x2671f(%rip), %rcx     # 0x655da
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
xorl %eax, %eax
callq 0x3eed6
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9GenCompileError
JX9_PRIVATE sxi32 jx9GenCompileError(jx9_gen_state *pGen,sxi32 nErrType,sxu32 nLine,const char *zFormat,...)
{
	SyBlob *pWorker = &pGen->pVm->pEngine->xConf.sErrConsumer;
	const char *zErr = "Error";
	va_list ap;
	if( nErrType == E_ERROR ){
		/* Increment the error counter */
		pGen->nErr++;
		if( pGen->nErr > 15 ){
			/* Error count limit reached */
			SyBlobFormat(pWorker, "%u Error count limit reached, JX9 is aborting compilation\n", nLine);	
			/* Abort immediately */
			return SXERR_ABORT;
		}
	}
	switch(nErrType){
	case E_WARNING: zErr = "Warning";     break;
	case E_PARSE:   zErr = "Parse error"; break;
	case E_NOTICE:  zErr = "Notice";      break;
	default:
		break;
	}
	/* Format the error message */
	SyBlobFormat(pWorker, "%u %s: ", nLine, zErr);
	va_start(ap, zFormat);
	SyBlobFormatAp(pWorker, zFormat, ap);
	va_end(ap);
	/* Append a new line */
	SyBlobAppend(pWorker, (const void *)"\n", sizeof(char));
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r14
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x3ef24
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)
movq (%rdi), %rax
movl $0xd0, %ebx
addq 0xc0(%rax), %rbx
cmpl $0x2, %esi
je 0x3ef6e
leaq 0x2987d(%rip), %rcx     # 0x687bc
cmpl $0x1, %esi
jne 0x3ef75
movl 0x168(%rdi), %eax
incl %eax
movl %eax, 0x168(%rdi)
cmpl $0x10, %eax
jb 0x3ef75
leaq 0x266b3(%rip), %rsi     # 0x65611
movq %rbx, %rdi
xorl %eax, %eax
callq 0x35d7b
pushq $-0xa
popq %r15
jmp 0x3efca
leaq 0x266d7(%rip), %rcx     # 0x6564c
leaq 0x266d8(%rip), %rsi     # 0x65654
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x35d7b
leaq -0xe0(%rbp), %rax
leaq -0x30(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x296e2
leaq 0x29302(%rip), %rsi     # 0x682c1
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x2e250
movl %r15d, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateFreeBlock
static void GenStateFreeBlock(GenBlock *pBlock)
{
	jx9_gen_state *pGen = pBlock->pGen;
	GenStateReleaseBlock(&(*pBlock));
	/* Free the instance */
	SyMemBackendPoolFree(&pGen->pVm->sAllocator, pBlock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
addq $0x50, %rdi
callq 0x31feb
leaq 0x18(%rbx), %rdi
callq 0x31feb
movq (%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x27bf8
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Tokenize
JX9_PRIVATE sxi32 jx9Tokenize(const char *zInput,sxu32 nLen,SySet *pOut)
{
	SyLex sLexer;
	sxi32 rc;
	/* Initialize the lexer */
	rc = SyLexInit(&sLexer, &(*pOut),jx9TokenizeInput,0);
	if( rc != SXRET_OK ){
		return rc;
	}
	/* Tokenize input */
	rc = SyLexTokenizeInput(&sLexer, zInput, nLen, 0, 0, 0);
	/* Release the lexer */
	SyLexRelease(&sLexer);
	/* Tokenization result */
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %esi, %eax
movq %rdi, %rsi
andq $0x0, -0x8(%rbp)
testq %rdx, %rdx
je 0x3f02a
cmpl $0x20, 0x18(%rdx)
jne 0x3f058
movq %rdx, -0x8(%rbp)
leaq 0x148(%rip), %rcx       # 0x3f179
leaq -0x40(%rbp), %rdi
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq $0x1, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rdx, 0x20(%rdi)
movl %eax, %edx
callq 0x3ff6e
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyLexTokenizeInput
JX9_PRIVATE sxi32 SyLexTokenizeInput(SyLex *pLex, const char *zInput, sxu32 nLen, void *pCtxData, ProcSort xSort, ProcCmp xCmp)
{
	const unsigned char *zCur;
	SyStream *pStream;
	SyToken sToken;
	sxi32 rc;
#if defined (UNTRUST)
	if ( INVALID_LEXER(pLex) || zInput == 0 ){
		return SXERR_CORRUPT;
	}
#endif
	pStream = &pLex->sStream;
	/* Point to the head of the input */
	pStream->zText = pStream->zInput = (const unsigned char *)zInput;
	/* Point to the end of the input */
	pStream->zEnd = &pStream->zInput[nLen];
	for(;;){
		if( pStream->zText >= pStream->zEnd ){
			/* End of the input reached */
			break;
		}
		zCur = pStream->zText;
		/* Call the tokenizer callback */
		rc = pLex->xTokenizer(pStream, &sToken, pLex->pUserData, pCtxData);
		if( rc != SXRET_OK && rc != SXERR_CONTINUE ){
			/* Tokenizer callback request an operation abort */
			if( rc == SXERR_ABORT ){
				return SXERR_ABORT;
			}
			break;
		}
		if( rc == SXERR_CONTINUE ){
			/* Request to ignore this token */
			pStream->nIgn++;
		}else if( pLex->pTokenSet  ){
			/* Put the token in the set */
			rc = SySetPut(pLex->pTokenSet, (const void *)&sToken);
			if( rc != SXRET_OK ){
				break;
			}
		}
		if( zCur >= pStream->zText ){
			/* Automatic advance of the stream cursor */
			pStream->zText = &zCur[1];
		}
	}
	if( xSort &&  pLex->pTokenSet ){
		SyToken *aToken = (SyToken *)SySetBasePtr(pLex->pTokenSet);
		/* Sort the extrated tokens */
		if( xCmp == 0 ){
			/* Use a default comparison function */
			xCmp = SyMemcmp;
		}
		xSort(aToken, SySetUsed(pLex->pTokenSet), sizeof(SyToken), xCmp);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
movl %edx, %eax
addq %rsi, %rax
movq %rax, 0x10(%rdi)
leaq -0x40(%rbp), %r15
cmpq %rax, %r14
jae 0x3ffed
movq 0x30(%rbx), %rdx
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq *0x28(%rbx)
cmpl $-0x19, %eax
je 0x3ffce
testl %eax, %eax
jne 0x3fff2
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3ffd1
movq %r15, %rsi
callq 0x2be00
testl %eax, %eax
je 0x3ffd1
jmp 0x3fffa
incl 0x1c(%rbx)
movq 0x8(%rbx), %rcx
cmpq %rcx, %r14
jb 0x3ffe4
incq %r14
movq %r14, 0x8(%rbx)
movq %r14, %rcx
movq 0x10(%rbx), %rax
movq %rcx, %r14
jmp 0x3ff97
xorl %r12d, %r12d
jmp 0x3fffa
cmpl $-0xa, %eax
jne 0x3fffa
movl %eax, %r12d
movl %r12d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9ExprExtractOperator
JX9_PRIVATE const jx9_expr_op *  jx9ExprExtractOperator(SyString *pStr, SyToken *pLast)
{
	sxu32 n = 0;
	sxi32 rc;
	/* Do a linear lookup on the operators table */
	for(;;){
		if( n >= SX_ARRAYSIZE(aOpTable) ){
			break;
		}
		rc = SyStringCmp(pStr, &aOpTable[n].sOp, SyMemcmp);		
		if( rc == 0 ){
			if( aOpTable[n].sOp.nByte != sizeof(char) || (aOpTable[n].iOp != EXPR_OP_UMINUS && aOpTable[n].iOp != EXPR_OP_UPLUS) || pLast == 0 ){
				if( aOpTable[n].iOp == EXPR_OP_SUBSCRIPT && (pLast == 0 || (pLast->nType & (JX9_TK_ID|JX9_TK_CSB/*]*/|JX9_TK_RPAREN/*)*/)) == 0) ){
					/* JSON Array not subscripting, return NULL  */
					return 0;
				}
				/* There is no ambiguity here, simply return the first operator seen */
				return &aOpTable[n];
			}
			/* Handle ambiguity */
			if( pLast->nType & (JX9_TK_LPAREN/*'('*/|JX9_TK_OCB/*'{'*/|JX9_TK_OSB/*'['*/|JX9_TK_COLON/*:*/|JX9_TK_COMMA/*, '*/) ){
				/* Unary opertors have prcedence here over binary operators */
				return &aOpTable[n];
			}
			if( pLast->nType & JX9_TK_OP ){
				const jx9_expr_op *pOp = (const jx9_expr_op *)pLast->pUserData;
				/* Ticket 1433-31: Handle the '++', '--' operators case */
				if( pOp->iOp != EXPR_OP_INCR && pOp->iOp != EXPR_OP_DECR ){
					/* Unary opertors have prcedence here over binary operators */
					return &aOpTable[n];
				}
			
			}
		}
		++n; /* Next operator in the table */
	}
	/* No such operator */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x442f7(%rip), %r15     # 0x84320
xorl %r13d, %r13d
cmpq $0x640, %r12            # imm = 0x640
je 0x400b9
movl 0x8(%r14), %edx
movl 0x8(%r12,%r15), %ebx
movl %edx, %eax
subl %ebx, %eax
jne 0x40054
movq (%r14), %rdi
movq (%r12,%r15), %rsi
callq 0x2d30e
testl %eax, %eax
jne 0x400ad
movl 0x10(%r12,%r15), %ecx
cmpl $0x1, %ebx
jne 0x400bd
movq %r13, %rax
shlq $0x5, %rax
addq %r15, %rax
cmpl $0x7, %ecx
jne 0x4007a
cmpq $0x0, -0x30(%rbp)
jne 0x40086
jmp 0x400f2
cmpq $0x0, -0x30(%rbp)
je 0x400bd
cmpl $0x8, %ecx
jne 0x400bd
movq -0x30(%rbp), %rcx
movl 0x10(%rcx), %ecx
testl $0x120a40, %ecx         # imm = 0x120A40
jne 0x400f2
testb $0x20, %cl
je 0x400ad
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rax), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x400ec
incq %r13
addq $0x20, %r12
jmp 0x4002c
xorl %eax, %eax
jmp 0x400f2
cmpq $0x0, -0x30(%rbp)
sete %dl
addq %r12, %r15
xorl %eax, %eax
cmpl $0x2, %ecx
setne %cl
cmovneq %r15, %rax
orb %dl, %cl
jne 0x400f2
movq -0x30(%rbp), %rax
movzwl 0x10(%rax), %eax
xorl %ecx, %ecx
testw $0x1408, %ax            # imm = 0x1408
cmoveq %rcx, %r15
jmp 0x400ef
addq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9ErrorRecover
static sxi32 jx9ErrorRecover(jx9_gen_state *pGen)
{
	/* Synchronize with the next-semi-colon and avoid compiling this erroneous statement */
	while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI /*';'*/) == 0){
		pGen->pIn++;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x158(%rdi), %rax
movq 0x160(%rdi), %rcx
cmpq %rcx, %rax
jae 0x4012b
testb $0x4, 0x12(%rax)
jne 0x4012b
addq $0x20, %rax
movq %rax, 0x158(%rdi)
jmp 0x40113
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileFunction
static sxi32 jx9CompileFunction(jx9_gen_state *pGen)
{
	SyString *pName;
	sxi32 iFlags;
	sxu32 nLine;
	sxi32 rc;

	nLine = pGen->pIn->nLine;
	pGen->pIn++; /* Jump the 'function' keyword */
	iFlags = 0;
	if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD)) == 0 ){
		/* Invalid function name */
		rc = jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Invalid function name");
		if( rc == SXERR_ABORT ){
			return SXERR_ABORT;
		}
		/* Sychronize with the next semi-colon or braces*/
		while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI|JX9_TK_OCB)) == 0 ){
			pGen->pIn++;
		}
		return SXRET_OK;
	}
	pName = &pGen->pIn->sData;
	nLine = pGen->pIn->nLine;
	/* Jump the function name */
	pGen->pIn++;
	if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_LPAREN) == 0 ){
		/* Syntax error */
		rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Expected '(' after function name '%z'", pName);
		if( rc == SXERR_ABORT ){
			/* Error count limit reached, abort immediately */
			return SXERR_ABORT;
		}
		/* Sychronize with the next semi-colon or '{' */
		while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI|JX9_TK_OCB)) == 0 ){
			pGen->pIn++;
		}
		return SXRET_OK;
	}
	/* Compile function body */
	rc = GenStateCompileFunc(&(*pGen),pName,iFlags,0);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x158(%rdi), %rax
movq 0x160(%rdi), %rcx
movl 0x14(%rax), %edx
leaq 0x20(%rax), %r8
movq %r8, 0x158(%rdi)
cmpq %rcx, %r8
jae 0x40ccd
testb $0xc, 0x30(%rax)
je 0x40ccd
movl 0x34(%rax), %edx
leaq 0x40(%rax), %rsi
movq %rsi, 0x158(%rbx)
cmpq %rcx, %rsi
jae 0x40c89
testb $0x2, 0x51(%rax)
jne 0x40d1b
leaq 0x24aec(%rip), %rcx     # 0x6577c
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3eed6
cmpl $-0xa, %eax
je 0x40ce6
movq 0x158(%rbx), %rcx
movq 0x160(%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x40ce9
testl $0x40040, 0x10(%rcx)    # imm = 0x40040
jne 0x40ce9
addq $0x20, %rcx
movq %rcx, 0x158(%rbx)
jmp 0x40cb2
leaq 0x24a92(%rip), %rcx     # 0x65766
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3eed6
cmpl $-0xa, %eax
jne 0x40cf0
pushq $-0xa
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x158(%rbx), %rcx
movq 0x160(%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x40ce9
testl $0x40040, 0x10(%rcx)    # imm = 0x40040
jne 0x40ce9
addq $0x20, %rcx
movq %rcx, 0x158(%rbx)
jmp 0x40d00
movq %rbx, %rdi
movq %r8, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x426f3
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileHalt
static sxi32 jx9CompileHalt(jx9_gen_state *pGen)
{
	sxi32 nExpr = 0;
	sxi32 rc;
	/* Jump the die/exit keyword */
	pGen->pIn++;
	if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
		/* Compile the expression */
		rc = jx9CompileExpr(&(*pGen), 0, 0);
		if( rc == SXERR_ABORT ){
			return SXERR_ABORT;
		}else if(rc != SXERR_EMPTY ){
			nExpr = 1;
		}
	}
	/* Emit the HALT instruction */
	jx9VmEmitInstr(pGen->pVm, JX9_OP_HALT, nExpr, 0, 0, 0);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x158(%rdi), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x158(%rdi)
xorl %ebx, %ebx
movl $0x0, %r15d
cmpq 0x160(%rdi), %rcx
jae 0x41c0f
testb $0x4, 0x32(%rax)
movl $0x0, %r15d
jne 0x41c0f
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4012f
cmpl $-0xa, %eax
je 0x41c32
cmpl $-0x3, %eax
je 0x41c0f
pushq $0x1
popq %r15
movq (%r14), %rdi
pushq $0x2
popq %rsi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ee6f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
jmp 0x41c25
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileReturn
static sxi32 jx9CompileReturn(jx9_gen_state *pGen)
{
	sxi32 nRet = 0; /* TRUE if there is a return value */
	sxi32 rc;
	/* Jump the 'return' keyword */
	pGen->pIn++;
	if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
		/* Compile the expression */
		rc = jx9CompileExpr(&(*pGen), 0, 0);
		if( rc == SXERR_ABORT ){
			return SXERR_ABORT;
		}else if(rc != SXERR_EMPTY ){
			nRet = 1;
		}
	}
	/* Emit the done instruction */
	jx9VmEmitInstr(pGen->pVm, JX9_OP_DONE, nRet, 0, 0, 0);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x158(%rdi), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x158(%rdi)
xorl %ebx, %ebx
movl $0x0, %r15d
cmpq 0x160(%rdi), %rcx
jae 0x41c8f
testb $0x4, 0x32(%rax)
movl $0x0, %r15d
jne 0x41c8f
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4012f
cmpl $-0xa, %eax
je 0x41cb2
cmpl $-0x3, %eax
je 0x41c8f
pushq $0x1
popq %r15
movq (%r14), %rdi
pushq $0x1
popq %rsi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ee6f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
jmp 0x41ca5
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileBreak
static sxi32 jx9CompileBreak(jx9_gen_state *pGen)
{
	GenBlock *pLoop; /* Target loop */
	sxi32 iLevel;    /* How many nesting loop to skip */
	sxu32 nLine;
	sxi32 rc;
	nLine = pGen->pIn->nLine;
	iLevel = 0;
	/* Jump the 'break' keyword */
	pGen->pIn++;
	if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_NUM) ){
		/* optional numeric argument which tells us how many levels
		 * of enclosing loops we should skip to the end of. 
		 */
		iLevel = (sxi32)jx9TokenValueToInt64(&pGen->pIn->sData);
		if( iLevel < 2 ){
			iLevel = 0;
		}
		pGen->pIn++; /* Jump the optional numeric argument */
	}
	/* Extract the target loop */
	pLoop = GenStateFetchBlock(pGen->pCurrent, GEN_BLOCK_LOOP, iLevel);
	if( pLoop == 0 ){
		/* Illegal break */
		rc = jx9GenCompileError(pGen, E_ERROR, pGen->pIn->nLine, "A 'break' statement may only be used within a loop or switch");
		if( rc == SXERR_ABORT ){
			/* Error count limit reached, abort immediately */
			return SXERR_ABORT;
		}
	}else{
		sxu32 nInstrIdx; 
		rc = jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, 0, 0, &nInstrIdx);
		if( rc == SXRET_OK ){
			/* Fix the jump later when the jump destination is resolved */
			GenStateNewJumpFixup(pLoop, JX9_OP_JMP, nInstrIdx);
		}
	}
	if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
		/* Not so fatal, emit a warning only */
		jx9GenCompileError(&(*pGen), E_WARNING, pGen->pIn->nLine, "Expected semi-colon ';' after 'break' statement");
	}
	/* Statement successfully compiled */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x158(%rdi), %rax
leaq 0x20(%rax), %r14
movq %r14, 0x158(%rdi)
xorl %esi, %esi
cmpq 0x160(%rdi), %r14
jae 0x41d08
testb $0x3, 0x30(%rax)
je 0x41d08
movq %r14, %rdi
callq 0x3758e
xorl %esi, %esi
cmpl $0x2, %eax
cmovgel %eax, %esi
movq 0x158(%rbx), %r14
addq $0x20, %r14
movq %r14, 0x158(%rbx)
movq 0xc8(%rbx), %rdi
callq 0x42f1d
testq %rax, %rax
je 0x41d46
movq %rax, %r15
movq (%rbx), %rdi
pushq $0x8
popq %rsi
leaq -0x1c(%rbp), %r9
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3ee6f
testl %eax, %eax
jne 0x41d69
movl -0x1c(%rbp), %edx
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x42528
jmp 0x41d69
movl 0x14(%r14), %edx
leaq 0x23df6(%rip), %rcx     # 0x65b47
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3eed6
cmpl $-0xa, %eax
jne 0x41d69
pushq $-0xa
popq %r14
jmp 0x41d9c
movq 0x158(%rbx), %rax
xorl %r14d, %r14d
cmpq 0x160(%rbx), %rax
jae 0x41d9c
testb $0x4, 0x12(%rax)
jne 0x41d9c
movl 0x14(%rax), %edx
leaq 0x23df8(%rip), %rcx     # 0x65b84
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3eed6
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileContinue
static sxi32 jx9CompileContinue(jx9_gen_state *pGen)
{
	GenBlock *pLoop; /* Target loop */
	sxi32 iLevel;    /* How many nesting loop to skip */
	sxu32 nLine;
	sxi32 rc;
	nLine = pGen->pIn->nLine;
	iLevel = 0;
	/* Jump the 'continue' keyword */
	pGen->pIn++;
	if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_NUM) ){
		/* optional numeric argument which tells us how many levels
		 * of enclosing loops we should skip to the end of. 
		 */
		iLevel = (sxi32)jx9TokenValueToInt64(&pGen->pIn->sData);
		if( iLevel < 2 ){
			iLevel = 0;
		}
		pGen->pIn++; /* Jump the optional numeric argument */
	}
	/* Point to the target loop */
	pLoop = GenStateFetchBlock(pGen->pCurrent, GEN_BLOCK_LOOP, iLevel);
	if( pLoop == 0 ){
		/* Illegal continue */
		rc = jx9GenCompileError(pGen, E_ERROR, nLine, "A 'continue' statement may only be used within a loop or switch");
		if( rc == SXERR_ABORT ){
			/* Error count limit reached, abort immediately */
			return SXERR_ABORT;
		}
	}else{
		sxu32 nInstrIdx = 0;
		/* Emit the unconditional jump to the beginning of the target loop */
		jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, pLoop->nFirstInstr, 0, &nInstrIdx);
		if( pLoop->bPostContinue == TRUE ){
			JumpFixup sJumpFix;
			/* Post-continue */
			sJumpFix.nJumpType = JX9_OP_JMP;
			sJumpFix.nInstrIdx = nInstrIdx;
			SySetPut(&pLoop->aPostContFix, (const void *)&sJumpFix);
		}
	}
	if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
		/* Not so fatal, emit a warning only */
		jx9GenCompileError(&(*pGen), E_WARNING, pGen->pIn->nLine, "Expected semi-colon ';' after 'continue' statement");
	}
	/* Statement successfully compiled */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x158(%rdi), %rax
movl 0x14(%rax), %r14d
leaq 0x20(%rax), %rdi
movq %rdi, 0x158(%rbx)
xorl %esi, %esi
cmpq 0x160(%rbx), %rdi
jae 0x41df6
testb $0x3, 0x30(%rax)
je 0x41df6
callq 0x3758e
xorl %esi, %esi
cmpl $0x2, %eax
cmovgel %eax, %esi
addq $0x20, 0x158(%rbx)
movq 0xc8(%rbx), %rdi
callq 0x42f1d
testq %rax, %rax
je 0x41e4a
movq %rax, %r15
leaq -0x1c(%rbp), %r9
andl $0x0, (%r9)
movq (%rbx), %rdi
movl 0x10(%rax), %ecx
pushq $0x8
popq %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x3ee6f
cmpb $0x1, 0x48(%r15)
jne 0x41e6c
leaq -0x24(%rbp), %rsi
movl $0x8, (%rsi)
movl -0x1c(%rbp), %eax
movl %eax, 0x4(%rsi)
addq $0x50, %r15
movq %r15, %rdi
callq 0x2be00
jmp 0x41e6c
leaq 0x23d63(%rip), %rcx     # 0x65bb4
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x3eed6
cmpl $-0xa, %eax
jne 0x41e6c
pushq $-0xa
popq %r14
jmp 0x41e9f
movq 0x158(%rbx), %rax
xorl %r14d, %r14d
cmpq 0x160(%rbx), %rax
jae 0x41e9f
testb $0x4, 0x12(%rax)
jne 0x41e9f
movl 0x14(%rax), %edx
leaq 0x23d65(%rip), %rcx     # 0x65bf4
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3eed6
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileUplink
static sxi32 jx9CompileUplink(jx9_gen_state *pGen)
{
	SyToken *pTmp, *pNext = 0;
	sxi32 nExpr;
	sxi32 rc;
	/* Jump the 'uplink' keyword */
	pGen->pIn++;
	if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_SEMI) ){
		/* Nothing to process */
		return SXRET_OK;
	}
	pTmp = pGen->pEnd;
	nExpr = 0;
	while( SXRET_OK == jx9GetNextExpr(pGen->pIn, pTmp, &pNext) ){
		if( pGen->pIn < pNext ){
			pGen->pEnd = pNext;
			if( (pGen->pIn->nType & JX9_TK_DOLLAR) == 0 ){
				rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "uplink: Expected variable name");
				if( rc == SXERR_ABORT ){
					return SXERR_ABORT;
				}
			}else{
				pGen->pIn++;
				if( pGen->pIn >= pGen->pEnd ){
					/* Emit a warning */
					jx9GenCompileError(&(*pGen), E_WARNING, pGen->pIn[-1].nLine, "uplink: Empty variable name");
				}else{
					rc = jx9CompileExpr(&(*pGen), 0, 0);
					if( rc == SXERR_ABORT ){
						return SXERR_ABORT;
					}else if(rc != SXERR_EMPTY ){
						nExpr++;
					}
				}
			}
		}
		/* Next expression in the stream */
		pGen->pIn = pNext;
		/* Jump trailing commas */
		while( pGen->pIn < pTmp && (pGen->pIn->nType & JX9_TK_COMMA) ){
			pGen->pIn++;
		}
	}
	/* Restore token stream */
	pGen->pEnd = pTmp;
	if( nExpr > 0 ){
		/* Emit the uplink instruction */
		jx9VmEmitInstr(pGen->pVm, JX9_OP_UPLINK, nExpr, 0, 0, 0);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
andq $0x0, -0x38(%rbp)
movq 0x158(%rdi), %rax
movq 0x160(%rdi), %r15
leaq 0x20(%rax), %r13
movq %r13, 0x158(%rdi)
xorl %ebx, %ebx
cmpq %r15, %r13
jae 0x42229
testb $0x4, 0x32(%rax)
jne 0x42229
movq %rdi, %r14
leaq -0x38(%rbp), %r12
pushq $-0xa
popq %rbx
movl $0x0, -0x2c(%rbp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x42f48
testl %eax, %eax
jne 0x42202
movq 0x158(%r14), %rax
movq -0x38(%rbp), %r13
cmpq %r13, %rax
jae 0x421e4
movq %r13, 0x160(%r14)
testb $0x10, 0x10(%rax)
jne 0x421a2
movl 0x14(%rax), %edx
movq %r14, %rdi
pushq $0x1
popq %rsi
leaq 0x23b08(%rip), %rcx     # 0x65c99
xorl %eax, %eax
callq 0x3eed6
cmpl $-0xa, %eax
jne 0x421e4
jmp 0x42229
leaq 0x20(%rax), %rcx
movq %rcx, 0x158(%r14)
cmpq %r13, %rcx
jae 0x421cd
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4012f
cmpl $-0x3, %eax
je 0x421e4
cmpl $-0xa, %eax
je 0x4223a
incl -0x2c(%rbp)
jmp 0x421e4
movl 0x14(%rax), %edx
movq %r14, %rdi
pushq $0x2
popq %rsi
leaq 0x23adb(%rip), %rcx     # 0x65cb8
xorl %eax, %eax
callq 0x3eed6
cmpq %r15, %r13
jae 0x421f6
testb $0x2, 0x12(%r13)
je 0x421f6
addq $0x20, %r13
jmp 0x421e4
movq %r13, 0x158(%r14)
jmp 0x4214e
movq %r15, 0x160(%r14)
movl -0x2c(%rbp), %edx
testl %edx, %edx
jle 0x42227
movq (%r14), %rdi
xorl %ebx, %ebx
pushq $0x40
popq %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ee6f
jmp 0x42229
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
jmp 0x42229
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateEnterBlock
static sxi32 GenStateEnterBlock(
	jx9_gen_state *pGen,  /* Code generator state */
	sxi32 iType,          /* Block type [i.e: loop, conditional, function body, etc.]*/
	sxu32 nFirstInstr,    /* First instruction to compile */
	void *pUserData,      /* Upper layer private data */
	GenBlock **ppBlock    /* OUT: instantiated block */
	)
{
	GenBlock *pBlock;
	/* Allocate a new block instance */
	pBlock = (GenBlock *)SyMemBackendPoolAlloc(&pGen->pVm->sAllocator, sizeof(GenBlock));
	if( pBlock == 0 ){
		/* If the supplied memory subsystem is so sick that we are unable to allocate
		 * a tiny chunk of memory, there is no much we can do here.
		 */
		return GenStateOutOfMem(pGen);
	}
	/* Zero the structure */
	SyZero(pBlock, sizeof(GenBlock));
	GenStateInitBlock(&(*pGen), pBlock, iType, nFirstInstr, pUserData);
	/* Link to the parent block */
	pBlock->pParent = pGen->pCurrent;
	/* Mark as the current block */
	pGen->pCurrent = pBlock;
	if( ppBlock ){
		/* Write a pointer to the new instance */
		*ppBlock = pBlock;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, -0x30(%rbp)
movl %edx, %r13d
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x78
popq %rsi
callq 0x279f7
testq %rax, %rax
je 0x424dc
movq %rax, %r12
pushq $0x78
popq %rsi
movq %rax, %rdi
callq 0x27aea
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r13d, %ecx
movq -0x30(%rbp), %r8
callq 0x3ee1f
movq 0xc8(%r14), %rax
movq %rax, 0x8(%r12)
movq %r12, 0xc8(%r14)
xorl %eax, %eax
testq %rbx, %rbx
je 0x424e7
movq %r12, (%rbx)
jmp 0x424e7
movq %r14, %rdi
callq 0x426d9
pushq $-0xa
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateNewJumpFixup
static sxi32 GenStateNewJumpFixup(GenBlock *pBlock, sxi32 nJumpType, sxu32 nInstrIdx)
{
	JumpFixup sJumpFix;
	sxi32 rc;
	/* Init the JumpFixup structure */
	sJumpFix.nJumpType = nJumpType;
	sJumpFix.nInstrIdx = nInstrIdx;
	/* Insert in the jump fixup table */
	rc = SySetPut(&pBlock->aJumpFix,(const void *)&sJumpFix);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rax
movl %esi, (%rax)
movl %edx, 0x4(%rax)
addq $0x18, %rdi
movq %rax, %rsi
callq 0x2be00
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileBlock
static sxi32 jx9CompileBlock(
	jx9_gen_state *pGen /* Code generator state */
	)
{
	sxi32 rc;
	if( pGen->pIn->nType & JX9_TK_OCB /* '{' */ ){
		sxu32 nLine = pGen->pIn->nLine;
		rc = GenStateEnterBlock(&(*pGen), GEN_BLOCK_STD, jx9VmInstrLength(pGen->pVm), 0, 0);
		if( rc != SXRET_OK ){
			return SXERR_ABORT;
		}
		pGen->pIn++;
		/* Compile until we hit the closing braces '}' */
		for(;;){
			if( pGen->pIn >= pGen->pEnd ){
				/* No more token to process. Missing closing braces */
				jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Missing closing braces '}'");
				break;
			}
			if( pGen->pIn->nType & JX9_TK_CCB/*'}'*/ ){
				/* Closing braces found, break immediately*/
				pGen->pIn++;
				break;
			}
			/* Compile a single statement */
			rc = GenStateCompileChunk(&(*pGen),JX9_COMPILE_SINGLE_STMT);
			if( rc == SXERR_ABORT ){
				return SXERR_ABORT;
			}
		}
		GenStateLeaveBlock(&(*pGen), 0);			
	}else{
		/* Compile a single statement */
		rc = GenStateCompileChunk(&(*pGen),JX9_COMPILE_SINGLE_STMT);
		if( rc == SXERR_ABORT ){
			return SXERR_ABORT;
		}
	}
	/* Jump trailing semi-colons ';' */
	while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) ){
		pGen->pIn++;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x158(%rdi), %rax
testb $0x40, 0x10(%rax)
jne 0x42580
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f05e
cmpl $-0xa, %eax
jne 0x42617
pushq $-0xa
popq %r15
jmp 0x425ab
movl 0x14(%rax), %r14d
movq (%rbx), %rax
movq 0xf0(%rax), %rax
movl 0x10(%rax), %edx
movq %rbx, %rdi
movl $0x80, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4246c
pushq $-0xa
popq %r15
testl %eax, %eax
je 0x425b7
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x20, 0x158(%rbx)
pushq $0x1
popq %r12
movq 0x158(%rbx), %rax
cmpq 0x160(%rbx), %rax
jae 0x425eb
testb $-0x80, 0x10(%rax)
jne 0x42604
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3f05e
cmpl $-0xa, %eax
jne 0x425c3
jmp 0x425ab
leaq 0x23765(%rip), %rcx     # 0x65d57
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x3eed6
jmp 0x4260f
addq $0x20, %rax
movq %rax, 0x158(%rbx)
movq %rbx, %rdi
callq 0x426b3
movq 0x158(%rbx), %rax
movq 0x160(%rbx), %rcx
xorl %r15d, %r15d
cmpq %rcx, %rax
jae 0x425ab
testb $0x4, 0x12(%rax)
je 0x425ab
addq $0x20, %rax
movq %rax, 0x158(%rbx)
jmp 0x42628
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateFixJumps
static sxu32 GenStateFixJumps(GenBlock *pBlock, sxi32 nJumpType, sxu32 nJumpDest)
{
	JumpFixup *aFix;
	VmInstr *pInstr;
	sxu32 nFixed; 
	sxu32 n;
	/* Point to the jump fixup table */
	aFix = (JumpFixup *)SySetBasePtr(&pBlock->aJumpFix);
	/* Fix the desired jumps */
	for( nFixed = n = 0 ; n < SySetUsed(&pBlock->aJumpFix) ; ++n ){
		if( aFix[n].nJumpType < 0 ){
			/* Already fixed */
			continue;
		}
		if( nJumpType > 0 && aFix[n].nJumpType != nJumpType ){
			/* Not of our interest */
			continue;
		}
		/* Point to the instruction to fix */
		pInstr = jx9VmGetInstr(pBlock->pGen->pVm, aFix[n].nInstrIdx);
		if( pInstr ){
			pInstr->iP2 = nJumpDest;
			nFixed++;
			/* Mark as fixed */
			aFix[n].nJumpType = -1;
		}
	}
	/* Total number of fixed jumps */
	return nFixed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x20(%rdi), %rax
movl 0x28(%rdi), %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %r8, %rcx
je 0x426b0
testl %esi, %esi
setle %r10b
movl (%rax,%r8,8), %ebx
cmpl %esi, %ebx
sete %r11b
testl %ebx, %ebx
js 0x426ab
orb %r11b, %r10b
je 0x426ab
movq (%rdi), %r10
movq (%r10), %r11
movl 0x4(%rax,%r8,8), %r10d
movq 0xf0(%r11), %r11
cmpl %r10d, 0x10(%r11)
jbe 0x426ab
movq 0x8(%r11), %rbx
testq %rbx, %rbx
je 0x426ab
imull 0x18(%r11), %r10d
movl %edx, 0x8(%rbx,%r10)
incl %r9d
orl $-0x1, (%rax,%r8,8)
incq %r8
jmp 0x4265a
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateForEachNodeValidator
static sxi32 GenStateForEachNodeValidator(jx9_gen_state *pGen,jx9_expr_node *pRoot)
{
	sxi32 rc = SXRET_OK; /* Assume a valid expression tree */
	if( pRoot->xCode != jx9CompileVariable ){
		/* Unexpected expression */
		rc = jx9GenCompileError(&(*pGen),
			E_ERROR,
			pRoot->pStart? pRoot->pStart->nLine : 0, 
			"foreach: Expecting a variable name"
			);
		if( rc != SXERR_ABORT ){
			rc = SXERR_INVALID;
		}
	}
	return rc;
}

// Assembly:
leaq 0x4e(%rip), %rax        # 0x42d51
cmpq %rax, 0x30(%rsi)
je 0x42d17
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x42d1a
movl 0x14(%rax), %edx
jmp 0x42d1c
xorl %eax, %eax
retq
xorl %edx, %edx
pushq %rbp
movq %rsp, %rbp
leaq 0x22c29(%rip), %rcx     # 0x65950
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x3eed6
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0xa, %ecx
sete %al
xorl $-0x9, %eax
popq %rbp
retq