LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x158(%rdi), %rcx
movq 0x160(%rdi), %rax
cmpq %rax, %rcx
jae 0x4a7a6
pushq %rbp
movq %rsp, %rbp
addq $0x20, %rcx
testb $0x4, -0xe(%rcx)
jne 0x4a7a5
movq %rcx, 0x158(%rdi)
leaq 0x20(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0x4a78c
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4b53d
testb $0xc, 0x30(%rax)
je 0x4b53d
movl 0x34(%rax), %edx
leaq 0x40(%rax), %rsi
movq %rsi, 0x158(%rbx)
cmpq %rcx, %rsi
jae 0x4b4e2
testb $0x2, 0x51(%rax)
jne 0x4b59b
leaq 0x2c2a8(%rip), %rcx     # 0x77791
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x49434
movl %eax, %ecx
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
cmpl $-0xa, %ecx
je 0x4b594
movq 0x158(%rbx), %rcx
movq 0x160(%rbx), %rax
cmpq %rax, %rcx
jae 0x4b592
addq $0x20, %rcx
testl $0x40040, -0x10(%rcx)   # imm = 0x40040
jne 0x4b592
movq %rcx, 0x158(%rbx)
leaq 0x20(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0x4b51f
jmp 0x4b592
leaq 0x2c237(%rip), %rcx     # 0x7777b
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x49434
movl %eax, %ecx
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
cmpl $-0xa, %ecx
je 0x4b594
movq 0x158(%rbx), %rcx
movq 0x160(%rbx), %rax
cmpq %rax, %rcx
jae 0x4b592
addq $0x20, %rcx
testl $0x40040, -0x10(%rcx)   # imm = 0x40040
jne 0x4b592
movq %rcx, 0x158(%rbx)
leaq 0x20(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0x4b576
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movq %r8, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4d1c7
// File: /workspace/github_c_makefile_star2_O1/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 0x4c63d
testb $0x4, 0x32(%rax)
movl $0x0, %r15d
jne 0x4c63d
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a7a9
cmpl $-0xa, %eax
je 0x4c662
cmpl $-0x3, %eax
je 0x4c63d
movl $0x1, %r15d
movq (%r14), %rdi
movl $0x2, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x493c1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
jmp 0x4c655
// File: /workspace/github_c_makefile_star2_O1/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 0x4c6c1
testb $0x4, 0x32(%rax)
movl $0x0, %r15d
jne 0x4c6c1
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a7a9
cmpl $-0xa, %eax
je 0x4c6e6
cmpl $-0x3, %eax
je 0x4c6c1
movl $0x1, %r15d
movq (%r14), %rdi
movl $0x1, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x493c1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
jmp 0x4c6d9
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x158(%rdi), %rax
leaq 0x20(%rax), %rdi
movq %rdi, 0x158(%rbx)
xorl %ecx, %ecx
cmpq 0x160(%rbx), %rdi
jae 0x4c730
testb $0x3, 0x30(%rax)
je 0x4c730
callq 0x405c7
xorl %ecx, %ecx
cmpl $0x2, %eax
cmovgel %eax, %ecx
addq $0x20, 0x158(%rbx)
movq 0xc8(%rbx), %r14
testb $0x1, 0x14(%r14)
je 0x4c745
cmpl $0x2, %ecx
jl 0x4c758
decl %ecx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x4c755
testb $0xa, 0x14(%r14)
je 0x4c737
xorl %r14d, %r14d
testq %r14, %r14
je 0x4c797
movq (%rbx), %rdi
leaq -0x14(%rbp), %r9
movl $0x8, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x493c1
testl %eax, %eax
jne 0x4c7c2
movl -0x14(%rbp), %eax
leaq -0x1c(%rbp), %rsi
movl $0x8, (%rsi)
movl %eax, 0x4(%rsi)
addq $0x18, %r14
movq %r14, %rdi
callq 0x336fc
jmp 0x4c7c2
movq 0x158(%rbx), %rax
movl 0x14(%rax), %edx
leaq 0x2b3b4(%rip), %rcx     # 0x77b5c
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x49434
movl $0xfffffff6, %r14d      # imm = 0xFFFFFFF6
cmpl $-0xa, %eax
je 0x4c7f7
movq 0x158(%rbx), %rax
xorl %r14d, %r14d
cmpq 0x160(%rbx), %rax
jae 0x4c7f7
testb $0x4, 0x12(%rax)
jne 0x4c7f7
movl 0x14(%rax), %edx
leaq 0x2b3b4(%rip), %rcx     # 0x77b99
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x49434
movl %r14d, %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: 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
movq $0x0, -0x38(%rbp)
movq 0x158(%rdi), %rax
movq 0x160(%rdi), %r15
leaq 0x20(%rax), %rcx
movq %rcx, 0x158(%rdi)
xorl %ebx, %ebx
cmpq %r15, %rcx
jae 0x4cce9
testb $0x4, 0x32(%rax)
jne 0x4cce9
movq %rdi, %r14
movq 0x158(%rdi), %rdi
leaq -0x38(%rbp), %rdx
movq %r15, %rsi
callq 0x4dc3f
xorl %ebx, %ebx
movl $0x0, -0x2c(%rbp)
testl %eax, %eax
jne 0x4ccc4
leaq -0x38(%rbp), %r13
movl $0x0, -0x2c(%rbp)
movq 0x158(%r14), %rax
movq -0x38(%rbp), %r12
cmpq %r12, %rax
jae 0x4cc94
movq %r12, 0x160(%r14)
testb $0x10, 0x10(%rax)
jne 0x4cc4c
movl 0x14(%rax), %edx
movq %r14, %rdi
movl $0x1, %esi
leaq 0x2b073(%rip), %rcx     # 0x77cae
xorl %eax, %eax
callq 0x49434
cmpl $-0xa, %eax
jne 0x4cc94
jmp 0x4ccfa
leaq 0x20(%rax), %rcx
movq %rcx, 0x158(%r14)
cmpq %r12, %rcx
jae 0x4cc7b
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a7a9
cmpl $-0x3, %eax
je 0x4cc94
cmpl $-0xa, %eax
je 0x4cd01
incl -0x2c(%rbp)
jmp 0x4cc94
movl 0x14(%rax), %edx
movq %r14, %rdi
movl $0x2, %esi
leaq 0x2b040(%rip), %rcx     # 0x77ccd
xorl %eax, %eax
callq 0x49434
cmpq %r15, %r12
jae 0x4cca7
testb $0x2, 0x12(%r12)
je 0x4cca7
addq $0x20, %r12
jmp 0x4cc94
movq %r12, 0x158(%r14)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4dc3f
testl %eax, %eax
je 0x4cc0c
movq %r15, 0x160(%r14)
movl -0x2c(%rbp), %edx
testl %edx, %edx
jle 0x4cce9
movq (%r14), %rdi
xorl %ebx, %ebx
movl $0x40, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x493c1
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffff6, %ebx       # imm = 0xFFFFFFF6
jmp 0x4cce9
movl %eax, %ebx
jmp 0x4cce9
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movl %edx, %r13d
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x78, %esi
callq 0x2e951
testq %rax, %rax
je 0x4d000
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x74, %rcx
jb 0x4cf88
movl %r13d, 0x10(%rax)
movq %r12, 0x40(%rax)
movq %r14, (%rax)
movl %r15d, 0x14(%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movb $0x0, 0x48(%rax)
movq (%r14), %rdx
movaps 0x28623(%rip), %xmm0    # 0x755e0
movups %xmm0, 0x28(%rax)
movq %rdx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x38(%rax)
movq $0x8, 0x68(%rax)
movq %rdx, 0x50(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rax)
movq %rcx, 0x70(%rax)
movq 0xc8(%r14), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0xc8(%r14)
testq %rbx, %rbx
je 0x4d020
movq %rax, (%rbx)
jmp 0x4d020
leaq 0x2a747(%rip), %rcx     # 0x7774e
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x49434
movl $0xfffffff6, %ecx       # imm = 0xFFFFFFF6
movl %ecx, %eax
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: 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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x158(%rdi), %rax
testb $0x40, 0x10(%rax)
jne 0x4d06c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x495e6
movl $0xfffffff6, %r14d      # imm = 0xFFFFFFF6
cmpl $-0xa, %eax
jne 0x4d111
jmp 0x4d144
movl 0x14(%rax), %r15d
movq (%rbx), %rax
movq 0xf0(%rax), %rax
movl 0x10(%rax), %edx
movq %rbx, %rdi
movl $0x80, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4cf52
movl $0xfffffff6, %r14d      # imm = 0xFFFFFFF6
testl %eax, %eax
jne 0x4d144
addq $0x20, 0x158(%rbx)
movq 0x158(%rbx), %rax
cmpq 0x160(%rbx), %rax
jae 0x4d0cf
testb $-0x80, 0x10(%rax)
jne 0x4d0ea
movq %rbx, %rdi
movl $0x1, %esi
callq 0x495e6
cmpl $-0xa, %eax
jne 0x4d0a5
jmp 0x4d144
leaq 0x2ac96(%rip), %rcx     # 0x77d6c
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x49434
jmp 0x4d0f5
addq $0x20, %rax
movq %rax, 0x158(%rbx)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x4d111
movq 0x8(%rdi), %rax
movq %rax, 0xc8(%rbx)
callq 0x4955d
movq 0x158(%rbx), %rcx
movq 0x160(%rbx), %rax
xorl %r14d, %r14d
cmpq %rax, %rcx
jae 0x4d144
addq $0x20, %rcx
testb $0x4, -0xe(%rcx)
je 0x4d144
movq %rcx, 0x158(%rbx)
leaq 0x20(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0x4d12b
movl %r14d, %eax
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: 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:
movl 0x28(%rdi), %eax
testq %rax, %rax
je 0x4d1c6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x20(%rdi), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
testl %esi, %esi
setle %r10b
movl (%rcx,%r8,8), %ebx
cmpl %esi, %ebx
sete %r11b
testl %ebx, %ebx
js 0x4d1bc
orb %r11b, %r10b
je 0x4d1bc
movq (%rdi), %r10
movq (%r10), %r11
movl 0x4(%rcx,%r8,8), %r10d
movq 0xf0(%r11), %r11
cmpl %r10d, 0x10(%r11)
jbe 0x4d1a5
imull 0x18(%r11), %r10d
addq 0x8(%r11), %r10
jmp 0x4d1a8
xorl %r10d, %r10d
testq %r10, %r10
je 0x4d1bc
movl %edx, 0x8(%r10)
incl %r9d
movl $0xffffffff, (%rcx,%r8,8) # imm = 0xFFFFFFFF
incq %r8
cmpq %r8, %rax
jne 0x4d169
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f(%rip), %rax        # 0x4d908
cmpq %rax, 0x30(%rsi)
je 0x4d8dd
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x4d8e0
movl 0x14(%rax), %edx
jmp 0x4d8e2
xorl %eax, %eax
retq
xorl %edx, %edx
pushq %rbp
movq %rsp, %rbp
leaq 0x2a078(%rip), %rcx     # 0x77965
movl $0x1, %esi
xorl %eax, %eax
callq 0x49434
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0xa, %ecx
sete %al
xorl $-0x9, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileVariable
JX9_PRIVATE sxi32 jx9CompileVariable(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
	sxu32 nLine = pGen->pIn->nLine;
	SyHashEntry *pEntry;
	SyString *pName;
	char *zName = 0;
	sxi32 iP1;
	void *p3;
	sxi32 rc;
	
	pGen->pIn++; /* Jump the dollar sign '$' */
	if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD)) == 0 ){
		/* Invalid variable name */
		rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Invalid variable name");
		if( rc == SXERR_ABORT ){
			/* Error count limit reached, abort immediately */
			return SXERR_ABORT;
		}
		return SXRET_OK;
	}
	/* Extract variable name */
	pName = &pGen->pIn->sData;
	/* Advance the stream cursor */
	pGen->pIn++;
	pEntry = SyHashGet(&pGen->hVar, (const void *)pName->zString, pName->nByte);
	if( pEntry == 0 ){
		/* Duplicate name */
		zName = SyMemBackendStrDup(&pGen->pVm->sAllocator, pName->zString, pName->nByte);
		if( zName == 0 ){
			return GenStateOutOfMem(pGen);
		}
		/* Install in the hashtable */
		SyHashInsert(&pGen->hVar, zName, pName->nByte, zName);
	}else{
		/* Name already available */
		zName = (char *)pEntry->pUserData;
	}
	p3 = (void *)zName;	
	iP1 = 0;
	if( iCompileFlag & EXPR_FLAG_RDONLY_LOAD ){
		if( (iCompileFlag & EXPR_FLAG_LOAD_IDX_STORE) == 0 ){
			/* Read-only load.In other words do not create the variable if inexistant */
			iP1 = 1;
		}
	}
	/* Emit the load instruction */
	jx9VmEmitInstr(pGen->pVm, JX9_OP_LOAD, iP1, 0, p3, 0);
	/* Node successfully compiled */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x158(%rdi), %r13
movl 0x14(%r13), %edx
leaq 0x20(%r13), %rcx
movq %rcx, 0x158(%rdi)
cmpq 0x160(%rdi), %rcx
jae 0x4d97d
testb $0xc, 0x30(%r13)
je 0x4d97d
movl %esi, %r14d
leaq 0x40(%r13), %rax
movq %rax, 0x158(%rbx)
leaq 0x88(%rbx), %r15
movl 0x28(%r13), %edx
xorl %eax, %eax
testl %edx, %edx
je 0x4d972
cmpl $0x0, 0xb0(%rbx)
je 0x4d972
movq (%rcx), %rsi
movq %r15, %rdi
callq 0x4573a
testq %rax, %rax
je 0x4d99f
movq 0x10(%rax), %r12
jmp 0x4d9c9
leaq 0x2a004(%rip), %rcx     # 0x77988
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x49434
cmpl $-0xa, %eax
cmovel %eax, %r14d
jmp 0x4d9ee
movq (%rbx), %rdi
movq 0x20(%r13), %rsi
movl 0x28(%r13), %edx
callq 0x3e425
testq %rax, %rax
je 0x4da00
movq %rax, %r12
movl 0x28(%r13), %edx
movq %r15, %rdi
movq %rax, %rsi
movq %rax, %rcx
callq 0x4542b
andl $0x3, %r14d
xorl %edx, %edx
cmpl $0x2, %r14d
sete %dl
movq (%rbx), %rdi
xorl %r14d, %r14d
movl $0x3, %esi
xorl %ecx, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x493c1
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29d47(%rip), %rcx     # 0x7774e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x49434
movl $0xfffffff6, %r14d      # imm = 0xFFFFFFF6
jmp 0x4d9ee
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateCompileSwitchBlock
static sxi32 GenStateCompileSwitchBlock(jx9_gen_state *pGen,sxu32 *pBlockStart)
{
	sxi32 rc = SXRET_OK;
	while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI/*';'*/|JX9_TK_COLON/*':'*/)) == 0 ){
		/* Unexpected token */
		rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Unexpected token '%z'", &pGen->pIn->sData);
		if( rc == SXERR_ABORT ){
			return SXERR_ABORT;
		}
		pGen->pIn++;
	}
	pGen->pIn++;
	/* First instruction to execute in this block. */
	*pBlockStart = jx9VmInstrLength(pGen->pVm);
	/* Compile the block until we hit a case/default/endswitch keyword
	 * or the '}' token */
	for(;;){
		if( pGen->pIn >= pGen->pEnd ){
			/* No more input to process */
			break;
		}
		rc = SXRET_OK;
		if( (pGen->pIn->nType & JX9_TK_KEYWORD) == 0 ){
			if( pGen->pIn->nType & JX9_TK_CCB /*'}' */ ){
				rc = SXERR_EOF;
				break;
			}
		}else{
			sxi32 nKwrd;
			/* Extract the keyword */
			nKwrd = SX_PTR_TO_INT(pGen->pIn->pUserData);
			if( nKwrd == JX9_TKWRD_CASE || nKwrd == JX9_TKWRD_DEFAULT ){
				break;
			}
		}
		/* Compile block */
		rc = jx9CompileBlock(&(*pGen));
		if( rc == SXERR_ABORT ){
			return SXERR_ABORT;
		}
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x158(%rdi), %r8
xorl %eax, %eax
cmpq 0x160(%rdi), %r8
jae 0x4da4c
testb $0x14, 0x12(%r8)
je 0x4daab
addq $0x20, %r8
movq %r8, 0x158(%rbx)
movq (%rbx), %rcx
movq 0xf0(%rcx), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, (%r14)
movq 0x158(%rbx), %rcx
cmpq 0x160(%rbx), %rcx
jae 0x4dafc
movl 0x10(%rcx), %eax
testb $0x4, %al
jne 0x4da88
testb %al, %al
jns 0x4da97
jmp 0x4daf7
movl 0x18(%rcx), %ecx
xorl %eax, %eax
cmpl $0x5, %ecx
je 0x4dafc
cmpl $0xa, %ecx
je 0x4dafc
movq %rbx, %rdi
callq 0x4d031
cmpl $-0xa, %eax
jne 0x4da67
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
jmp 0x4dafc
leaq 0x2a1bb(%rip), %r15     # 0x77c6d
movl 0x14(%r8), %edx
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0x49434
cmpl $-0xa, %eax
je 0x4daa4
movq 0x158(%rbx), %rcx
leaq 0x20(%rcx), %r8
movq %r8, 0x158(%rbx)
cmpq 0x160(%rbx), %r8
jae 0x4da4c
testb $0x14, 0x32(%rcx)
je 0x4dab2
jmp 0x4da4c
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
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: GenStateCompileCaseExpr
static sxi32 GenStateCompileCaseExpr(jx9_gen_state *pGen, jx9_case_expr *pExpr)
{
	SySet *pInstrContainer;
	SyToken *pEnd, *pTmp;
	sxi32 iNest = 0;
	sxi32 rc;
	/* Delimit the expression */
	pEnd = pGen->pIn;
	while( pEnd < pGen->pEnd ){
		if( pEnd->nType & JX9_TK_LPAREN /*(*/ ){
			/* Increment nesting level */
			iNest++;
		}else if( pEnd->nType & JX9_TK_RPAREN /*)*/ ){
			/* Decrement nesting level */
			iNest--;
		}else if( pEnd->nType & (JX9_TK_SEMI/*';'*/|JX9_TK_COLON/*;'*/) && iNest < 1 ){
			break;
		}
		pEnd++;
	}
	if( pGen->pIn >= pEnd ){
		rc = jx9GenCompileError(pGen, E_ERROR, pGen->pIn->nLine, "Empty case expression");
		if( rc == SXERR_ABORT ){
			/* Error count limit reached, abort immediately */
			return SXERR_ABORT;
		}
	}
	/* Swap token stream */
	pTmp = pGen->pEnd;
	pGen->pEnd = pEnd;
	pInstrContainer = jx9VmGetByteCodeContainer(pGen->pVm);
	jx9VmSetByteCodeContainer(pGen->pVm, &pExpr->aByteCode);
	rc = jx9CompileExpr(&(*pGen), 0, 0);
	/* Emit the done instruction */
	jx9VmEmitInstr(pGen->pVm, JX9_OP_DONE, (rc != SXERR_EMPTY ? 1 : 0), 0, 0, 0);
	jx9VmSetByteCodeContainer(pGen->pVm, pInstrContainer); 
	/* Update token stream */
	pGen->pIn  = pEnd;
	pGen->pEnd = pTmp;
	if( rc == SXERR_ABORT ){
		return SXERR_ABORT;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x158(%rdi), %rax
movq 0x160(%rdi), %rcx
movq %rax, %r12
cmpq %rcx, %rax
jae 0x4db67
xorl %edx, %edx
movq %rax, %r12
movl 0x10(%r12), %esi
btl $0x9, %esi
jb 0x4db58
btl $0xa, %esi
jb 0x4db5c
testl $0x140000, %esi         # imm = 0x140000
je 0x4db5e
testl %edx, %edx
jg 0x4db5e
jmp 0x4db67
incl %edx
jmp 0x4db5e
decl %edx
addq $0x20, %r12
cmpq %rcx, %r12
jb 0x4db39
cmpq %r12, %rax
jb 0x4db94
movl 0x14(%rax), %edx
leaq 0x29fd0(%rip), %rcx     # 0x77b46
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x49434
movl $0xfffffff6, %r15d      # imm = 0xFFFFFFF6
cmpl $-0xa, %eax
je 0x4dc2d
movq (%rbx), %rax
movq 0x160(%rbx), %rcx
movq %rcx, -0x38(%rbp)
movq %r12, 0x160(%rbx)
movq 0xf0(%rax), %rcx
movq %rcx, -0x30(%rbp)
movl $0xc8, %r13d
leaq (%rax,%r13), %rcx
testq %r14, %r14
cmovneq %r14, %rcx
movq %rcx, 0xf0(%rax)
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a7a9
movl %eax, %r14d
movq (%rbx), %rdi
xorl %edx, %edx
cmpl $-0x3, %eax
setne %dl
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x493c1
movq (%rbx), %rax
addq %rax, %r13
movq -0x30(%rbp), %rcx
testq %rcx, %rcx
cmovneq %rcx, %r13
movq %r13, 0xf0(%rax)
movq %r12, 0x158(%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x160(%rbx)
cmpl $-0xa, %r14d
cmovel %r14d, %r15d
movl %r15d, %eax
addq $0x18, %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: jx9GetNextExpr
JX9_PRIVATE sxi32 jx9GetNextExpr(SyToken *pStart,SyToken *pEnd,SyToken **ppNext)
{
	SyToken *pCur = pStart;
	sxi32 iNest = 0;
	if( pCur >= pEnd || (pCur->nType & JX9_TK_SEMI/*';'*/) ){
		/* Last expression */
		return SXERR_EOF;
	}
	while( pCur < pEnd ){
		if( (pCur->nType & (JX9_TK_COMMA/*','*/|JX9_TK_SEMI/*';'*/)) && iNest <= 0){
			break;
		}
		if( pCur->nType & (JX9_TK_LPAREN/*'('*/|JX9_TK_OSB/*'['*/|JX9_TK_OCB/*'{'*/) ){
			iNest++;
		}else if( pCur->nType & (JX9_TK_RPAREN/*')'*/|JX9_TK_CSB/*']'*/|JX9_TK_CCB/*'}*/) ){
			iNest--;
		}
		pCur++;
	}
	*ppNext = pCur;
	return SXRET_OK;
}

// Assembly:
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
cmpq %rsi, %rdi
jae 0x4dca3
testb $0x4, 0x12(%rdi)
jne 0x4dca3
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
jae 0x4dc9d
xorl %eax, %eax
movl $0x1, %ecx
movl 0x10(%rdi), %r8d
testl $0x60000, %r8d          # imm = 0x60000
je 0x4dc70
testl %eax, %eax
jle 0x4dc9d
movl %r8d, %r9d
andl $0x1480, %r9d           # imm = 0x1480
negl %r9d
movl $0x0, %r9d
sbbl %r9d, %r9d
testl $0xa40, %r8d            # imm = 0xA40
cmovnel %ecx, %r9d
addl %r9d, %eax
addq $0x20, %rdi
cmpq %rsi, %rdi
jb 0x4dc5f
movq %rdi, (%rdx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileJsonArray
JX9_PRIVATE sxi32 jx9CompileJsonArray(jx9_gen_state *pGen, sxi32 iCompileFlag)
{
	sxi32 nPair = 0;
	SyToken *pCur;
	sxi32 rc;

	pGen->pIn++; /* Jump the open square bracket '['*/
	pGen->pEnd--;
	SXUNUSED(iCompileFlag); /* cc warning */
	for(;;){
		/* Jump leading commas */
		while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_COMMA) ){
			pGen->pIn++;
		}
		pCur = pGen->pIn;
		if( SXRET_OK != jx9GetNextExpr(pGen->pIn, pGen->pEnd, &pGen->pIn) ){
			/* No more entry to process */
			break;
		}
		/* Compile entry */
		rc = GenStateCompileJSONEntry(&(*pGen),pCur,pGen->pIn,EXPR_FLAG_RDONLY_LOAD/*Do not create the variable if inexistant*/,0);
		if( rc == SXERR_ABORT ){
			return SXERR_ABORT;
		}
		nPair++;
	}
	/* Emit the load map instruction */
	jx9VmEmitInstr(pGen->pVm, JX9_OP_LOAD_MAP,nPair,0,0,0);
	/* Node successfully compiled */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x158(%rdi), %r15
addq $0x20, 0x158(%rdi)
addq $-0x20, 0x160(%rdi)
xorl %ebx, %ebx
movq 0x158(%r14), %r12
movq 0x160(%r14), %rsi
cmpq %rsi, %r12
jae 0x4f1ad
addq $0x20, %r12
testb $0x2, -0xe(%r12)
je 0x4f1a9
movq %r12, (%r15)
leaq 0x20(%r12), %rax
cmpq %rsi, %r12
movq %rax, %r12
jb 0x4f188
addq $-0x20, %rax
movq %rax, %r12
jmp 0x4f1ad
addq $-0x20, %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x4dc3f
testl %eax, %eax
jne 0x4f209
movq 0x158(%r14), %r13
movq 0x160(%r14), %rax
movq %rax, -0x30(%rbp)
movq %r12, 0x158(%r14)
movq %r13, 0x160(%r14)
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x4a7a9
movq %r13, 0x158(%r14)
movq -0x30(%rbp), %rcx
movq %rcx, 0x160(%r14)
cmpl $-0xa, %eax
je 0x4f225
incl %ebx
jmp 0x4f171
movq (%r14), %rdi
xorl %r14d, %r14d
movl $0x6, %esi
movl %ebx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x493c1
jmp 0x4f22b
movl $0xfffffff6, %r14d      # imm = 0xFFFFFFF6
movl %r14d, %eax
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: GenStateJSONObjectKeyNodeValidator
static sxi32 GenStateJSONObjectKeyNodeValidator(jx9_gen_state *pGen,jx9_expr_node *pRoot)
{
	sxi32 rc = SXRET_OK;
	if( pRoot->xCode != jx9CompileVariable && pRoot->xCode != jx9CompileString 
		&& pRoot->xCode != jx9CompileSimpleString && pRoot->xCode != jx9CompileLiteral ){
		/* Unexpected expression */
		rc = jx9GenCompileError(&(*pGen), E_ERROR, pRoot->pStart? pRoot->pStart->nLine : 0, 
			"JSON Object: Unexpected expression, key must be of type string, literal or simple variable");
		if( rc != SXERR_ABORT ){
			rc = SXERR_INVALID;
		}
	}
	return rc;
}

// Assembly:
movq 0x30(%rsi), %rcx
leaq -0x606(%rip), %rdx      # 0x4f23d
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x4f8a3
leaq 0x67e(%rip), %rdx       # 0x4fecf
cmpq %rdx, %rcx
je 0x4f8a3
leaq -0x1f55(%rip), %rdx     # 0x4d908
cmpq %rdx, %rcx
je 0x4f8a3
leaq 0x3b(%rip), %rdx        # 0x4f8a4
cmpq %rdx, %rcx
je 0x4f8a3
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x4f87c
movl 0x14(%rax), %edx
jmp 0x4f87e
xorl %edx, %edx
pushq %rbp
movq %rsp, %rbp
leaq 0x28591(%rip), %rcx     # 0x77e1a
movl $0x1, %esi
xorl %eax, %eax
callq 0x49434
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0xa, %ecx
sete %al
xorl $-0x9, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateNewStrObj
static jx9_value * GenStateNewStrObj(jx9_gen_state *pGen,sxi32 *pCount)
{
	jx9_value *pConstObj;
	sxu32 nIdx = 0;
	/* Reserve a new constant */
	pConstObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
	if( pConstObj == 0 ){
		GenStateOutOfMem(&(*pGen));
		return 0;
	}
	(*pCount)++;
	jx9MemObjInitFromString(pGen->pVm, pConstObj, 0);
	/* Emit the load constant instruction */
	jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
	return pConstObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq -0x1c(%rbp), %rsi
movl $0x0, (%rsi)
movq (%rdi), %rdi
callq 0x49175
testq %rax, %rax
je 0x500ff
movq %rax, %rbx
incl (%r15)
movq (%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, (%rbx)
movups %xmm0, 0x20(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x0, 0x30(%rbx)
movl $0x1, 0x8(%rbx)
movq (%r14), %rdi
movl -0x1c(%rbp), %ecx
movl $0x4, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x493c1
jmp 0x5011c
leaq 0x27648(%rip), %rcx     # 0x7774e
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x49434
movq %rbx, %rax
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: GenStateProcessStringExpression
static sxi32 GenStateProcessStringExpression(
	jx9_gen_state *pGen, /* Code generator state */
	const char *zIn,     /* Raw expression */
	const char *zEnd     /* End of the expression */
	)
{
	SyToken *pTmpIn, *pTmpEnd;
	SySet sToken;
	sxi32 rc;
	/* Initialize the token set */
	SySetInit(&sToken, &pGen->pVm->sAllocator, sizeof(SyToken));
	/* Preallocate some slots */
	SySetAlloc(&sToken, 0x08);
	/* Tokenize the text */
	jx9Tokenize(zIn,(sxu32)(zEnd-zIn),&sToken);
	/* Swap delimiter */
	pTmpIn  = pGen->pIn;
	pTmpEnd = pGen->pEnd;
	pGen->pIn = (SyToken *)SySetBasePtr(&sToken);
	pGen->pEnd = &pGen->pIn[SySetUsed(&sToken)];
	/* Compile the expression */
	rc = jx9CompileExpr(&(*pGen), 0, 0);
	/* Restore token stream */
	pGen->pIn  = pTmpIn;
	pGen->pEnd = pTmpEnd;
	/* Release the token set */
	SySetRelease(&sToken);
	/* Compilation result */
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movabsq $0x2000000000, %rax     # imm = 0x2000000000
movq %rax, -0x34(%rbp)
xorl %eax, %eax
movl %eax, -0x38(%rbp)
movl %eax, -0x2c(%rbp)
movq %rdi, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq %rax, -0x28(%rbp)
movl $0x100, %esi            # imm = 0x100
callq 0x343ed
movq %rax, -0x40(%rbp)
testq %rax, %rax
je 0x50181
movl $0x8, -0x34(%rbp)
subl %r15d, %r14d
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movl %r14d, %esi
movq %r12, %rdx
callq 0x4958b
movups 0x158(%rbx), %xmm0
movaps %xmm0, -0x60(%rbp)
movq 0x8(%r12), %rax
movq %rax, 0x158(%rbx)
movl 0x10(%r12), %ecx
shlq $0x5, %rcx
addq %rax, %rcx
movq %rcx, 0x160(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a7a9
movl %eax, %r14d
movaps -0x60(%rbp), %xmm0
movups %xmm0, 0x158(%rbx)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x501f1
movq -0x40(%rbp), %rsi
testq %rsi, %rsi
je 0x501f1
callq 0x3503f
movl %r14d, %eax
addq $0x40, %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: GenStateFindLiteral
static sxi32 GenStateFindLiteral(jx9_gen_state *pGen, const SyString *pValue, sxu32 *pIdx)
{
	SyHashEntry *pEntry;
	pEntry = SyHashGet(&pGen->hLiteral, (const void *)pValue->zString, pValue->nByte);
	if( pEntry == 0 ){
		return SXERR_NOTFOUND;
	}
	*pIdx = (sxu32)SX_PTR_TO_INT(pEntry->pUserData);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x8(%rsi), %edx
xorl %eax, %eax
testl %edx, %edx
je 0x50225
cmpl $0x0, 0x30(%rdi)
je 0x50225
addq $0x8, %rdi
movq (%rsi), %rsi
callq 0x4573a
testq %rax, %rax
je 0x50233
movl 0x10(%rax), %eax
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0x50238
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileNumLiteral
static sxi32 jx9CompileNumLiteral(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
	SyToken *pToken = pGen->pIn; /* Raw token */
	sxu32 nIdx = 0;
	if( pToken->nType & JX9_TK_INTEGER ){
		jx9_value *pObj;
		sxi64 iValue;
		iValue = jx9TokenValueToInt64(&pToken->sData);
		pObj = GenStateInstallNumLiteral(&(*pGen), &nIdx);
		if( pObj == 0 ){
			SXUNUSED(iCompileFlag); /* cc warning */
			return SXERR_ABORT;
		}
		jx9MemObjInitFromInt(pGen->pVm, pObj, iValue);
	}else{
		/* Real number */
		jx9_value *pObj;
		/* Reserve a new constant */
		pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
		if( pObj == 0 ){
			return GenStateOutOfMem(pGen);
		}
		jx9MemObjInitFromString(pGen->pVm, pObj, &pToken->sData);
		jx9MemObjToReal(pObj);
	}
	/* Emit the load constant instruction */
	jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
	/* Node 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), %r15
movl $0x0, -0x1c(%rbp)
testb $0x1, 0x10(%r15)
jne 0x5028d
movq (%rbx), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x49175
movq %rax, %r14
testq %rax, %rax
je 0x502ba
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x45a64
movq %r14, %rdi
callq 0x44891
jmp 0x502d5
movq %r15, %rdi
callq 0x405c7
movq %rax, %r14
leaq -0x20(%rbp), %rsi
movl $0x0, (%rsi)
movq (%rbx), %rdi
callq 0x49175
testq %rax, %rax
je 0x502dc
movq %rax, %r15
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x502fa
leaq 0x2748d(%rip), %rcx     # 0x7774e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x49434
testq %r14, %r14
jne 0x50333
jmp 0x5034f
leaq 0x2746b(%rip), %rcx     # 0x7774e
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x49434
testq %r15, %r15
je 0x5034f
movq (%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, (%r15)
movups %xmm0, 0x20(%r15)
movq %rax, 0x10(%r15)
movq %rax, 0x18(%r15)
movl $0x0, 0x30(%r15)
movq %r14, (%r15)
movl $0x2, 0x8(%r15)
movq (%rbx), %rdi
movl -0x1c(%rbp), %ecx
xorl %ebx, %ebx
movl $0x4, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x493c1
jmp 0x50354
movl $0xfffffff6, %ebx       # imm = 0xFFFFFFF6
movl %ebx, %eax
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: jx9CompileNowdoc
static sxi32 jx9CompileNowdoc(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
	SyString *pStr = &pGen->pIn->sData; /* Constant string literal */
	jx9_value *pObj;
	sxu32 nIdx;
	nIdx = 0; /* Prevent compiler warning */
	if( pStr->nByte <= 0 ){
		/* Empty string, load NULL */
		jx9VmEmitInstr(pGen->pVm,JX9_OP_LOADC, 0, 0, 0, 0);
		return SXRET_OK;
	}
	/* Reserve a new constant */
	pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
	if( pObj == 0 ){
		jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "JX9 engine is running out of memory");
		SXUNUSED(iCompileFlag); /* cc warning */
		return SXERR_ABORT;
	}
	/* No processing is done here, simply a memcpy() operation */
	jx9MemObjInitFromString(pGen->pVm, pObj, pStr);
	/* Emit the load constant instruction */
	jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
	/* Node successfully compiled */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x158(%rdi), %r14
movl $0x0, -0x14(%rbp)
cmpl $0x0, 0x8(%r14)
movq (%rdi), %rdi
je 0x503b4
leaq -0x14(%rbp), %rsi
callq 0x49175
testq %rax, %rax
je 0x503cc
movq (%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x45a64
movq (%rbx), %rdi
movl -0x14(%rbp), %ecx
xorl %ebx, %ebx
movl $0x4, %esi
xorl %edx, %edx
jmp 0x503bf
xorl %ebx, %ebx
movl $0x4, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x493c1
jmp 0x503f1
movq 0x158(%rbx), %rax
movl 0x14(%rax), %edx
leaq 0x278ad(%rip), %rcx     # 0x77c8a
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x49434
movl $0xfffffff6, %ebx       # imm = 0xFFFFFFF6
movl %ebx, %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: ExprFreeTree
static void ExprFreeTree(jx9_gen_state *pGen, jx9_expr_node *pNode)
{
	if( pNode->pLeft ){
		/* Release the left tree */
		ExprFreeTree(&(*pGen), pNode->pLeft);
	}
	if( pNode->pRight ){
		/* Release the right tree */
		ExprFreeTree(&(*pGen), pNode->pRight);
	}
	if( pNode->pCond ){
		/* Release the conditional tree used by the ternary operator */
		ExprFreeTree(&(*pGen), pNode->pCond);
	}
	if( SySetUsed(&pNode->aNodeArgs) > 0 ){
		jx9_expr_node **apArg;
		sxu32 n;
		/* Release node arguments */
		apArg = (jx9_expr_node **)SySetBasePtr(&pNode->aNodeArgs);
		for( n = 0 ; n < SySetUsed(&pNode->aNodeArgs) ; ++n ){
			ExprFreeTree(&(*pGen), apArg[n]);
		}
		SySetRelease(&pNode->aNodeArgs);
	}
	/* Finally, release this node */
	SyMemBackendPoolFree(&pGen->pVm->sAllocator, pNode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x50421
movq %r14, %rdi
callq 0x503fc
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x50432
movq %r14, %rdi
callq 0x503fc
movq 0x60(%rbx), %rsi
testq %rsi, %rsi
je 0x50443
movq %r14, %rdi
callq 0x503fc
cmpl $0x0, 0x48(%rbx)
je 0x50479
leaq 0x38(%rbx), %r15
cmpl $0x0, 0x48(%rbx)
je 0x50471
movq 0x40(%rbx), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rsi
movq %r14, %rdi
callq 0x503fc
incq %r13
movl 0x48(%rbx), %eax
cmpq %rax, %r13
jb 0x5045a
movq %r15, %rdi
callq 0x3a2bc
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2eb38
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9RegisterBuiltInConstant
JX9_PRIVATE void jx9RegisterBuiltInConstant(jx9_vm *pVm)
{
	sxu32 n;
	/* 
	 * Note that all built-in constants have access to the jx9 virtual machine
	 * that trigger the constant invocation as their private data.
	 */
	for( n = 0 ; n < SX_ARRAYSIZE(aBuiltIn) ; ++n ){
		jx9_create_constant(&(*pVm), aBuiltIn[n].zName, aBuiltIn[n].xExpand, &(*pVm));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rdi, -0x30(%rbp)
cmpl $0xdead2bad, 0x6e8(%rbx) # imm = 0xDEAD2BAD
jne 0x5060b
incq %r12
cmpq $0x7a, %r12
jne 0x505f1
jmp 0x50789
movq %r12, %rax
shlq $0x4, %rax
leaq 0x43617(%rip), %rcx     # 0x93c30
movq (%rax,%rcx), %r13
movq 0x8(%rax,%rcx), %rax
movq %rax, -0x48(%rbp)
movq %r13, -0x40(%rbp)
cmpb $0x0, (%r13)
movq %r13, %r14
je 0x5066b
leaq 0x2(%r13), %r14
cmpb $0x0, -0x1(%r14)
je 0x50663
cmpb $0x0, (%r14)
je 0x5066b
cmpb $0x0, 0x1(%r14)
je 0x50668
leaq 0x4(%r14), %rax
cmpb $0x0, 0x2(%r14)
movq %rax, %r14
jne 0x50638
addq $-0x2, %rax
movq %rax, %r14
jmp 0x5066b
decq %r14
jmp 0x5066b
incq %r14
subl %r13d, %r14d
movl %r14d, -0x38(%rbp)
je 0x5069a
movsbq (%r13), %r15
cmpq $-0x41, %r15
ja 0x5069a
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
je 0x5069a
incq %r13
decl %r14d
jne 0x50674
xorl %r14d, %r14d
movl %r14d, -0x38(%rbp)
movq %r13, -0x40(%rbp)
testl %r14d, %r14d
sete %al
je 0x506cb
leal -0x1(%r14), %r15d
movsbq (%r13,%r15), %rbx
cmpq $-0x41, %rbx
ja 0x506c9
callq 0xc170
movq (%rax), %rcx
testb $0x20, 0x1(%rcx,%rbx,2)
jne 0x50748
xorl %eax, %eax
movq -0x30(%rbp), %rbx
movl %r14d, -0x38(%rbp)
movq -0x48(%rbp), %r14
testq %r14, %r14
je 0x505fd
testb %al, %al
jne 0x505fd
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x506fe
movq 0x469a5(%rip), %rax     # 0x970a0
callq *0x20(%rax)
cmpl $0x2, 0x469ab(%rip)     # 0x970b0
jb 0x50717
cmpl $0xdead2bad, 0x6e8(%rbx) # imm = 0xDEAD2BAD
je 0x505fd
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3055b
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x505fd
movq 0x46960(%rip), %rax     # 0x970a0
callq *0x30(%rax)
jmp 0x505fd
movl %r14d, %edx
movq -0x30(%rbp), %rbx
testl %r15d, %r15d
sete %al
je 0x50779
movl %r15d, %r14d
decq %rdx
leal -0x1(%r14), %r15d
movsbq (%r13,%r15), %rsi
cmpq $-0x41, %rsi
ja 0x50781
testb $0x20, 0x1(%rcx,%rsi,2)
jne 0x5074f
jmp 0x506cf
xorl %r14d, %r14d
jmp 0x506cf
movl %edx, %r14d
jmp 0x506cf
addq $0x28, %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: jx9RegisterBuiltInFunction
JX9_PRIVATE void jx9RegisterBuiltInFunction(jx9_vm *pVm)
{
	sxu32 n;
	for( n = 0 ; n < SX_ARRAYSIZE(aBuiltInFunc) ; ++n ){
		jx9_create_function(&(*pVm), aBuiltInFunc[n].zName, aBuiltInFunc[n].xFunc, 0);
	}
	/* Register hashmap functions [i.e: sort(), count(), array_diff(), ...] */
	jx9RegisterHashmapFunctions(&(*pVm));
	/* Register IO functions [i.e: fread(), fwrite(), chdir(), mkdir(), file(), ...] */
	jx9RegisterIORoutine(&(*pVm));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %r14d
leaq 0x43c9e(%rip), %r15     # 0x94450
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x3dc37
addq $0x10, %r14
cmpq $0x768, %r14            # imm = 0x768
jne 0x507b2
movl $0x8, %r14d
leaq 0x44791(%rip), %r15     # 0x94f70
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x3dc37
addq $0x10, %r14
cmpq $0x1d8, %r14            # imm = 0x1D8
jne 0x507df
movl $0x8, %r14d
leaq 0x44934(%rip), %r15     # 0x95140
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq 0xc0(%rbx), %rax
movq 0xb8(%rax), %rcx
movq %rbx, %rdi
callq 0x3dc37
addq $0x10, %r14
cmpq $0x3b8, %r14            # imm = 0x3B8
jne 0x5080c
movl $0x8, %r14d
leaq 0x44cab(%rip), %r15     # 0x954f0
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %rbx, %rcx
callq 0x3dc37
addq $0x10, %r14
cmpq $0x1f8, %r14            # imm = 0x1F8
jne 0x50845
leaq 0x43b63(%rip), %rdx     # 0x943d0
movq %rbx, %rdi
movl $0xb, %esi
xorl %eax, %eax
callq 0x47850
leaq 0x44e5d(%rip), %rdx     # 0x956e0
movq %rbx, %rdi
movl $0xb, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x47850