LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x4b560
testb $0x4, 0x32(%rax)
movl $0x0, %r15d
jne 0x4b560
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x49789
cmpl $-0xa, %eax
je 0x4b585
cmpl $-0x3, %eax
je 0x4b560
movl $0x1, %r15d
movq (%r14), %rdi
movl $0x1, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48365
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
jmp 0x4b578
// File: /workspace/github_c_makefile_star2_O3/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 0x4b5d9
testb $0x3, 0x30(%rax)
je 0x4b5d9
callq 0x3fbb7
xorl %ecx, %ecx
cmpl $0x2, %eax
cmovgel %eax, %ecx
movq 0x158(%rbx), %rdi
addq $0x20, %rdi
movq %rdi, 0x158(%rbx)
movq 0xc8(%rbx), %r14
movl 0x14(%r14), %eax
testb $0x1, %al
je 0x4b5ef
cmpl $0x2, %ecx
jl 0x4b626
decl %ecx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x4b600
movl 0x14(%r14), %eax
testb $0xa, %al
je 0x4b5e4
movl 0x14(%rdi), %edx
leaq 0x2a55d(%rip), %rcx     # 0x75b67
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x483d1
movl $0xfffffff6, %r14d      # imm = 0xFFFFFFF6
cmpl $-0xa, %eax
jne 0x4b65e
jmp 0x4b693
movq (%rbx), %rdi
leaq -0x14(%rbp), %r9
movl $0x8, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x48365
testl %eax, %eax
jne 0x4b65e
movl -0x14(%rbp), %eax
leaq -0x1c(%rbp), %rsi
movl $0x8, (%rsi)
movl %eax, 0x4(%rsi)
addq $0x18, %r14
movq %r14, %rdi
callq 0x33094
movq 0x158(%rbx), %rax
xorl %r14d, %r14d
cmpq 0x160(%rbx), %rax
jae 0x4b693
testb $0x4, 0x12(%rax)
jne 0x4b693
movl 0x14(%rax), %edx
leaq 0x2a523(%rip), %rcx     # 0x75ba4
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x483d1
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x2e481
testq %rax, %rax
je 0x4bea3
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x74, %rcx
jb 0x4be2f
movl %r13d, 0x10(%rax)
movq %r12, 0x40(%rax)
movq %r14, (%rax)
movl %r15d, 0x14(%rax)
movb $0x0, 0x48(%rax)
movq (%r14), %rdx
movaps 0x277e2(%rip), %xmm0    # 0x73640
movups %xmm0, 0x28(%rax)
movq %rdx, 0x18(%rax)
xorl %ecx, %ecx
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 0x4bec3
movq %rax, (%rbx)
jmp 0x4bec3
leaq 0x298af(%rip), %rcx     # 0x75759
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x483d1
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_O3/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 0x4bf0f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x48577
movl $0xfffffff6, %r14d      # imm = 0xFFFFFFF6
cmpl $-0xa, %eax
jne 0x4bfb4
jmp 0x4bfe7
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 0x4bdf9
movl $0xfffffff6, %r14d      # imm = 0xFFFFFFF6
testl %eax, %eax
jne 0x4bfe7
addq $0x20, 0x158(%rbx)
movq 0x158(%rbx), %rax
cmpq 0x160(%rbx), %rax
jae 0x4bf72
testb $-0x80, 0x10(%rax)
jne 0x4bf8d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x48577
cmpl $-0xa, %eax
jne 0x4bf48
jmp 0x4bfe7
leaq 0x29dfe(%rip), %rcx     # 0x75d77
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x483d1
jmp 0x4bf98
addq $0x20, %rax
movq %rax, 0x158(%rbx)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x4bfb4
movq 0x8(%rdi), %rax
movq %rax, 0xc8(%rbx)
callq 0x484ee
movq 0x158(%rbx), %rcx
movq 0x160(%rbx), %rax
xorl %r14d, %r14d
cmpq %rax, %rcx
jae 0x4bfe7
addq $0x20, %rcx
testb $0x4, -0xe(%rcx)
je 0x4bfe7
movq %rcx, 0x158(%rbx)
leaq 0x20(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0x4bfce
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4c065
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 0x4c05b
orb %r11b, %r10b
je 0x4c05b
movq (%rdi), %r10
movq (%r10), %r11
movl 0x4(%rcx,%r8,8), %r10d
movq 0xf0(%r11), %r11
cmpl %r10d, 0x10(%r11)
jbe 0x4c05b
movq 0x8(%r11), %rbx
testq %rbx, %rbx
je 0x4c05b
imull 0x18(%r11), %r10d
movl %edx, 0x8(%rbx,%r10)
incl %r9d
movl $0xffffffff, (%rcx,%r8,8) # imm = 0xFFFFFFFF
incq %r8
cmpq %r8, %rax
jne 0x4c00c
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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        # 0x4c6ff
cmpq %rax, 0x30(%rsi)
je 0x4c6d4
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x4c6d7
movl 0x14(%rax), %edx
jmp 0x4c6d9
xorl %eax, %eax
retq
xorl %edx, %edx
pushq %rbp
movq %rsp, %rbp
leaq 0x2928c(%rip), %rcx     # 0x75970
movl $0x1, %esi
xorl %eax, %eax
callq 0x483d1
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0xa, %ecx
sete %al
xorl $-0x9, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r12
movq %r12, 0x158(%rdi)
cmpq 0x160(%rdi), %r12
jae 0x4c773
testb $0xc, 0x30(%r13)
je 0x4c773
movl %esi, %r14d
leaq 0x40(%r13), %rax
movq %rax, 0x158(%rbx)
leaq 0x88(%rbx), %r15
movl 0x28(%r13), %edx
testl %edx, %edx
je 0x4c799
cmpl $0x0, 0xb0(%rbx)
je 0x4c799
movq (%r12), %rsi
movq %r15, %rdi
callq 0x448fa
testq %rax, %rax
je 0x4c795
movq 0x10(%rax), %r12
jmp 0x4c7bf
leaq 0x29219(%rip), %rcx     # 0x75993
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x483d1
cmpl $-0xa, %eax
cmovel %eax, %r14d
jmp 0x4c807
movl 0x28(%r13), %edx
movq (%rbx), %rdi
movq (%r12), %rsi
callq 0x3da5b
testq %rax, %rax
je 0x4c7e6
movq %rax, %r12
movl 0x28(%r13), %edx
movq %r15, %rdi
movq %rax, %rsi
movq %rax, %rcx
callq 0x445f4
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 0x48365
jmp 0x4c807
leaq 0x28f6c(%rip), %rcx     # 0x75759
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x483d1
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_O3/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
movq 0x160(%rdi), %rcx
xorl %eax, %eax
cmpq %rcx, %r8
jae 0x4c845
testb $0x14, 0x12(%r8)
je 0x4c8a9
addq $0x20, %r8
movq %r8, 0x158(%rbx)
movq (%rbx), %rdx
movq 0xf0(%rdx), %rdx
movl 0x10(%rdx), %edx
movl %edx, (%r14)
cmpq %rcx, %r8
jae 0x4c904
movl 0x10(%r8), %eax
testb $0x4, %al
jne 0x4c87a
testb %al, %al
jns 0x4c88a
jmp 0x4c8ff
movl 0x18(%r8), %ecx
xorl %eax, %eax
cmpl $0x5, %ecx
je 0x4c904
cmpl $0xa, %ecx
je 0x4c904
movq %rbx, %rdi
callq 0x4bed4
cmpl $-0xa, %eax
je 0x4c8f8
movq 0x158(%rbx), %r8
cmpq 0x160(%rbx), %r8
jb 0x4c869
jmp 0x4c904
leaq 0x293c8(%rip), %r15     # 0x75c78
movl 0x14(%r8), %edx
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0x483d1
cmpl $-0xa, %eax
je 0x4c8f8
movq 0x158(%rbx), %rdx
movq 0x160(%rbx), %rcx
leaq 0x20(%rdx), %r8
movq %r8, 0x158(%rbx)
cmpq %rcx, %r8
jae 0x4c845
testb $0x14, 0x32(%rdx)
je 0x4c8b0
jmp 0x4c845
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
jmp 0x4c904
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %rbx
movq 0x158(%rdi), %rax
movq 0x160(%rdi), %r13
movq %rax, %r12
cmpq %r13, %rax
jae 0x4c971
xorl %ecx, %ecx
movq %rax, %r12
movl 0x10(%r12), %edx
btl $0x9, %edx
jb 0x4c95d
btl $0xa, %edx
jb 0x4c961
testl $0x140000, %edx         # imm = 0x140000
je 0x4c963
testl %ecx, %ecx
jg 0x4c963
jmp 0x4c96c
incl %ecx
jmp 0x4c963
decl %ecx
addq $0x20, %r12
cmpq %r13, %r12
jb 0x4c93e
cmpq %r12, %rax
jb 0x4c9a6
movq %rsi, %r14
movl 0x14(%rax), %edx
leaq 0x291d3(%rip), %rcx     # 0x75b51
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x483d1
movl $0xfffffff6, %r15d      # imm = 0xFFFFFFF6
cmpl $-0xa, %eax
je 0x4ca32
movq 0x160(%rbx), %r13
movq %r14, %rsi
movq %r12, 0x160(%rbx)
movq (%rbx), %rax
movq 0xf0(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl $0xc8, %r14d
leaq (%rax,%r14), %rcx
testq %rsi, %rsi
cmovneq %rsi, %rcx
movq %rcx, 0xf0(%rax)
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x49789
movl %eax, -0x2c(%rbp)
movq (%rbx), %rdi
xorl %edx, %edx
cmpl $-0x3, %eax
setne %dl
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48365
movq (%rbx), %rax
addq %rax, %r14
movq -0x38(%rbp), %rcx
testq %rcx, %rcx
cmovneq %rcx, %r14
movq %r14, 0xf0(%rax)
movq %r12, 0x158(%rbx)
movq %r13, 0x160(%rbx)
movl -0x2c(%rbp), %eax
cmpl $-0xa, %eax
cmovel %eax, %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_O3/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 0x4caa3
testb $0x4, 0x12(%rdi)
jne 0x4caa3
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x1, %ecx
movl 0x10(%rdi), %r8d
testl $0x60000, %r8d          # imm = 0x60000
je 0x4ca70
testl %eax, %eax
jle 0x4ca9d
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 0x4ca5f
movq %rdi, (%rdx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
leaq 0x158(%rdi), %r14
movq 0x158(%rdi), %r13
movq 0x160(%rdi), %r12
addq $0x20, %r13
movq %r13, 0x158(%rdi)
addq $-0x20, %r12
movq %r12, 0x160(%rdi)
movq $0x0, -0x30(%rbp)
cmpq %r12, %r13
jae 0x4dcc1
addq $0x20, %r13
testb $0x2, -0xe(%r13)
je 0x4dcbd
movq %r13, (%r14)
leaq 0x20(%r13), %r15
cmpq %r12, %r13
movq %r15, %r13
jb 0x4dca1
addq $-0x20, %r15
jmp 0x4dcc4
addq $-0x20, %r13
movq %r13, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4ca44
testl %eax, %eax
jne 0x4dd23
movq 0x158(%rbx), %r13
movq 0x160(%rbx), %r12
movq %r15, 0x158(%rbx)
movq %r13, 0x160(%rbx)
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x49789
movq %r13, 0x158(%rbx)
movq %r12, 0x160(%rbx)
cmpl $-0xa, %eax
je 0x4dd40
movq -0x30(%rbp), %rax
incl %eax
movq %rax, -0x30(%rbp)
jmp 0x4dc98
movq (%rbx), %rdi
xorl %ebx, %ebx
movl $0x6, %esi
movq -0x30(%rbp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48365
jmp 0x4dd45
movl $0xfffffff6, %ebx       # imm = 0xFFFFFFF6
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 -0x5cd(%rip), %rdx      # 0x4dd56
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x4e383
leaq 0x5a6(%rip), %rdx       # 0x4e8d7
cmpq %rdx, %rcx
je 0x4e383
leaq -0x1c3e(%rip), %rdx     # 0x4c6ff
cmpq %rdx, %rcx
je 0x4e383
leaq 0x3b(%rip), %rdx        # 0x4e384
cmpq %rdx, %rcx
je 0x4e383
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x4e35c
movl 0x14(%rax), %edx
jmp 0x4e35e
xorl %edx, %edx
pushq %rbp
movq %rsp, %rbp
leaq 0x27abc(%rip), %rcx     # 0x75e25
movl $0x1, %esi
xorl %eax, %eax
callq 0x483d1
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0xa, %ecx
sete %al
xorl $-0x9, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x480f1
movq %rax, %rbx
testq %rax, %rax
je 0x4eaff
incl (%r15)
movq (%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%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 0x48365
jmp 0x4eb1a
leaq 0x26c53(%rip), %rcx     # 0x75759
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x483d1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x0, -0x28(%rbp)
movl $0x100, %esi            # imm = 0x100
callq 0x33d86
movq %rax, -0x40(%rbp)
testq %rax, %rax
je 0x4eb7f
movl $0x8, -0x34(%rbp)
subl %r15d, %r14d
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movl %r14d, %esi
movq %r12, %rdx
callq 0x4851c
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 0x49789
movl %eax, %r14d
movaps -0x60(%rbp), %xmm0
movups %xmm0, 0x158(%rbx)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4ebef
movq -0x40(%rbp), %rsi
testq %rsi, %rsi
je 0x4ebef
callq 0x3490d
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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), %r14
movl $0x0, -0x1c(%rbp)
testb $0x1, 0x10(%r14)
jne 0x4ec54
movq (%rbx), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x480f1
testq %rax, %rax
je 0x4ecc4
movq %rax, %r15
movq (%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x44c17
movq %r15, %rdi
callq 0x43a31
movl -0x1c(%rbp), %ecx
jmp 0x4ecab
movq %r14, %rdi
callq 0x3fbb7
movq %rax, %r14
leaq -0x20(%rbp), %rsi
movl $0x0, (%rsi)
movq (%rbx), %rdi
callq 0x480f1
testq %rax, %rax
je 0x4ecc4
movl -0x20(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq (%rbx), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rax)
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0x1c(%rax)
movl $0x0, 0x3c(%rax)
movq %rdx, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %rdx, 0x18(%rax)
movq %r14, (%rax)
movl $0x2, 0x8(%rax)
movq (%rbx), %rdi
xorl %ebx, %ebx
movl $0x4, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48365
jmp 0x4ece4
leaq 0x26a8e(%rip), %rcx     # 0x75759
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x483d1
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_O3/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 0x4ed44
leaq -0x14(%rbp), %rsi
callq 0x480f1
testq %rax, %rax
je 0x4ed5c
movq (%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x44c17
movq (%rbx), %rdi
movl -0x14(%rbp), %ecx
xorl %ebx, %ebx
movl $0x4, %esi
xorl %edx, %edx
jmp 0x4ed4f
xorl %ebx, %ebx
movl $0x4, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48365
jmp 0x4ed81
movq 0x158(%rbx), %rax
movl 0x14(%rax), %edx
leaq 0x26f28(%rip), %rcx     # 0x75c95
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x483d1
movl $0xfffffff6, %ebx       # imm = 0xFFFFFFF6
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x4edb1
movq %r14, %rdi
callq 0x4ed8c
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x4edc2
movq %r14, %rdi
callq 0x4ed8c
movq 0x60(%rbx), %rsi
testq %rsi, %rsi
je 0x4edd3
movq %r14, %rdi
callq 0x4ed8c
cmpl $0x0, 0x48(%rbx)
je 0x4ee03
leaq 0x38(%rbx), %r15
movq 0x40(%rbx), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rsi
movq %r14, %rdi
callq 0x4ed8c
incq %r13
movl 0x48(%rbx), %eax
cmpq %rax, %r13
jb 0x4ede4
movq %r15, %rdi
callq 0x399c8
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e659
// File: /workspace/github_c_makefile_star2_O3/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, -0x30(%rbp)
xorl %r12d, %r12d
movq -0x30(%rbp), %rax
cmpl $0xdead2bad, 0x6e8(%rax) # imm = 0xDEAD2BAD
je 0x4f0bd
movq %r12, %rax
shlq $0x4, %rax
leaq 0x42c94(%rip), %rcx     # 0x91c30
movq (%rax,%rcx), %r14
cmpb $0x0, (%r14)
movq %r14, %rcx
je 0x4efdc
leaq 0x2(%r14), %rcx
cmpb $0x0, -0x1(%rcx)
je 0x4efd4
cmpb $0x0, (%rcx)
je 0x4efdc
cmpb $0x0, 0x1(%rcx)
je 0x4efd9
leaq 0x4(%rcx), %rdx
cmpb $0x0, 0x2(%rcx)
movq %rdx, %rcx
jne 0x4efad
addq $-0x2, %rdx
movq %rdx, %rcx
jmp 0x4efdc
decq %rcx
jmp 0x4efdc
incq %rcx
subl %r14d, %ecx
je 0x4f0bd
leaq 0x42c44(%rip), %rdx     # 0x91c30
movq 0x8(%rax,%rdx), %rax
movq %rax, -0x38(%rbp)
movl %ecx, %r13d
xorl %r15d, %r15d
movsbq (%r14,%r15), %rbx
cmpq $-0x41, %rbx
ja 0x4f022
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0x4f022
incq %r15
cmpl %r15d, %r13d
jne 0x4effb
jmp 0x4f0bd
leaq (%r14,%r15), %rax
movq %rax, -0x48(%rbp)
movsbq -0x1(%r14,%r13), %rbx
cmpq $-0x41, %rbx
ja 0x4f04f
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0x4f04f
decq %r13
cmpq %r13, %r15
jne 0x4f02a
jmp 0x4f0bd
subl %r15d, %r13d
movl %r13d, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4f0bd
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rdi
testq %rdi, %rdi
je 0x4f077
movq 0x4602c(%rip), %rax     # 0x950a0
callq *0x20(%rax)
cmpl $0x2, 0x46032(%rip)     # 0x950b0
jb 0x4f090
movq -0x30(%rbp), %rax
cmpl $0xdead2bad, 0x6e8(%rax) # imm = 0xDEAD2BAD
je 0x4f0bd
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
leaq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rcx
callq 0x2ffd7
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x4f0bd
movq 0x45fe6(%rip), %rax     # 0x950a0
callq *0x30(%rax)
incq %r12
cmpq $0x7a, %r12
jne 0x4ef7a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x4335d(%rip), %r15     # 0x92450
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x3d2cb
addq $0x10, %r14
cmpq $0x768, %r14            # imm = 0x768
jne 0x4f0f3
movl $0x8, %r14d
leaq 0x43e50(%rip), %r15     # 0x92f70
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x3d2cb
addq $0x10, %r14
cmpq $0x1d8, %r14            # imm = 0x1D8
jne 0x4f120
movl $0x8, %r14d
leaq 0x43ff3(%rip), %r15     # 0x93140
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq 0xc0(%rbx), %rax
movq 0xb8(%rax), %rcx
movq %rbx, %rdi
callq 0x3d2cb
addq $0x10, %r14
cmpq $0x3b8, %r14            # imm = 0x3B8
jne 0x4f14d
movl $0x8, %r14d
leaq 0x4436a(%rip), %r15     # 0x934f0
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %rbx, %rcx
callq 0x3d2cb
addq $0x10, %r14
cmpq $0x1f8, %r14            # imm = 0x1F8
jne 0x4f186
leaq 0x43222(%rip), %rdx     # 0x923d0
movq %rbx, %rdi
movl $0xb, %esi
xorl %eax, %eax
callq 0x46833
leaq 0x4451c(%rip), %rdx     # 0x936e0
movq %rbx, %rdi
movl $0xb, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x46833
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_json_encode
static int vm_builtin_json_encode(jx9_context *pCtx,int nArg,jx9_value **apArg)
{
	SyBlob sBlob;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Init the working buffer */
	SyBlobInit(&sBlob,&pCtx->pVm->sAllocator);
	/* Perform the encoding operation */
	jx9JsonSerialize(apArg[0],&sBlob);
	/* Return the serialized value */
	jx9_result_string(pCtx,(const char *)SyBlobData(&sBlob),(int)SyBlobLength(&sBlob));
	/* Cleanup */
	SyBlobRelease(&sBlob);
	/* All done */
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4f24f
movq 0x60(%rbx), %rax
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r14
movups %xmm0, 0x8(%r14)
movq %rax, (%r14)
xorl %eax, %eax
movl %eax, 0x18(%r14)
movq (%rdx), %rdi
leaq -0x48(%rbp), %rsi
movl %eax, 0x10(%rsi)
movq %r14, (%rsi)
movq $0x1, 0x8(%rsi)
callq 0x3f650
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
movq 0x8(%rbx), %rdi
callq 0x302f6
testb $0x6, 0x18(%r14)
jne 0x4f270
cmpl $0x0, -0x1c(%rbp)
je 0x4f270
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3490d
jmp 0x4f270
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_json_decode
static int vm_builtin_json_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zJSON;
	int nByte;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the JSON string */
	zJSON = jx9_value_to_string(apArg[0], &nByte);
	if( nByte < 1 ){
		/* Empty string, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Decode the raw JSON */
	jx9JsonDecode(pCtx,zJSON,nByte);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4f344
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x4f344
leaq -0x44(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %edx
testl %edx, %edx
jle 0x4f344
movq 0x60(%rbx), %rcx
leaq -0x40(%rbp), %rsi
movq $0x20, 0x18(%rsi)
movq %rcx, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movq $0x0, 0x20(%rsi)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
leaq -0x88(%rbp), %rdi
movq %rsi, 0x38(%rdi)
leaq 0x155f(%rip), %rcx      # 0x50856
movq %rcx, 0x28(%rdi)
movq %r14, 0x30(%rdi)
movq $0x1, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq %rsi, 0x20(%rdi)
movq %rax, %rsi
callq 0x49203
cmpl $0x0, (%r14)
je 0x4f35b
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4f334
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x4f334
callq 0x3490d
movq $0x0, -0x38(%rbp)
xorl %eax, %eax
movl %eax, -0x30(%rbp)
movl %eax, -0x24(%rbp)
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0xc8(%rbp), %rdi
movq %rbx, (%rdi)
movq %r14, 0x38(%rdi)
movq -0x38(%rbp), %rax
movq %rax, 0x20(%rdi)
movl -0x30(%rbp), %ecx
shlq $0x5, %rcx
addq %rax, %rcx
movq %rcx, 0x28(%rdi)
xorl %eax, %eax
movl %eax, 0x18(%rdi)
movl %eax, 0x30(%rdi)
leaq 0x19d8(%rip), %rax      # 0x50d66
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x50d76
movl %eax, -0x14(%rbp)
cmpl $-0xa, %eax
jne 0x4f3b2
movq 0x8(%rbx), %rdi
callq 0x30465
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4f34d
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x4f34d
callq 0x3490d
jmp 0x4f34d
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_func_num_args
static int vm_builtin_func_num_args(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	VmFrame *pFrame;
	jx9_vm *pVm;
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Current frame */
	pFrame = pVm->pFrame;
	if( pFrame->pParent == 0 ){
		SXUNUSED(nArg);
		SXUNUSED(apArg);
		/* Global frame, return -1 */
		jx9_result_int(pCtx, -1);
		return SXRET_OK;
	}
	/* Total number of arguments passed to the enclosing function */
	nArg = (int)SySetUsed(&pFrame->sArg);
	jx9_result_int(pCtx, nArg);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x60(%rdi), %rax
movq 0xf8(%rax), %rax
cmpq $0x0, (%rax)
je 0x4f3fb
movslq 0x90(%rax), %r14
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x4f40e
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $-0x1, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_func_get_arg
static int vm_builtin_func_get_arg(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pObj = 0;
	VmSlot *pSlot = 0;
	VmFrame *pFrame;
	jx9_vm *pVm;
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Current frame */
	pFrame = pVm->pFrame;
	if( nArg < 1 || pFrame->pParent == 0 ){
		/* Global frame or Missing arguments, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Called in the global scope");
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Extract the desired index */
	nArg = jx9_value_to_int(apArg[0]);
	if( nArg < 0 || nArg >= (int)SySetUsed(&pFrame->sArg) ){
		/* Invalid index, return FALSE */
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Extract the desired argument */
	if( (pSlot = (VmSlot *)SySetAt(&pFrame->sArg, (sxu32)nArg)) != 0 ){
		if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pSlot->nIdx)) != 0 ){
			/* Return the desired argument */
			jx9_result_value(pCtx, (jx9_value *)pObj);
		}else{
			/* No such argument, return false */
			jx9_result_bool(pCtx, 0);
		}
	}else{
		/* CAN'T HAPPEN */
		jx9_result_bool(pCtx, 0);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %r14
testl %esi, %esi
jle 0x4f4a7
movq 0xf8(%r14), %r12
cmpq $0x0, (%r12)
je 0x4f4a7
movq (%rdx), %r15
movq %r15, %rdi
callq 0x3f362
movl (%r15), %eax
testl %eax, %eax
js 0x4f4c2
cmpl %eax, 0x90(%r12)
jle 0x4f4c2
movq 0x88(%r12), %rcx
testq %rcx, %rcx
je 0x4f4c2
imull 0x98(%r12), %eax
movl (%rcx,%rax), %eax
cmpl %eax, 0x218(%r14)
jbe 0x4f4c2
movq 0x210(%r14), %rdi
testq %rdi, %rdi
je 0x4f4c2
imull 0x220(%r14), %eax
addq %rax, %rdi
movq 0x8(%rbx), %rsi
callq 0x3e19f
jmp 0x4f4e3
movq (%rbx), %rsi
addq $0x8, %rsi
leaq 0x26e38(%rip), %rcx     # 0x762ed
movq %r14, %rdi
movl $0x2, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_func_get_args
static int vm_builtin_func_get_args(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pObj = 0;
	jx9_value *pArray;
	VmFrame *pFrame;
	VmSlot *aSlot;
	sxu32 n;
	/* Point to the current frame */
	pFrame = pCtx->pVm->pFrame;
	if( pFrame->pParent == 0 ){
		/* Global frame, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Called in the global scope");
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Start filling the array with the given arguments */
	aSlot = (VmSlot *)SySetBasePtr(&pFrame->sArg);
	for( n = 0;  n < SySetUsed(&pFrame->sArg) ; n++ ){
		pObj = (jx9_value *)SySetAt(&pCtx->pVm->aMemObj, aSlot[n].nIdx);
		if( pObj ){
			jx9_array_add_elem(pArray, 0/* Automatic index assign*/, pObj);
		}
	}
	/* Return the freshly created array */
	jx9_result_value(pCtx, pArray);
	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 0x60(%rdi), %rdi
movq 0xf8(%rdi), %r15
cmpq $0x0, (%r15)
je 0x4f597
movq %rbx, %rdi
callq 0x31231
testq %rax, %rax
je 0x4f5af
movq %rax, %r14
movl 0x90(%r15), %eax
testl %eax, %eax
je 0x4f589
movq 0x88(%r15), %r12
xorl %r13d, %r13d
movq 0x60(%rbx), %rsi
movl (%r12), %ecx
cmpl %ecx, 0x218(%rsi)
jbe 0x4f57b
movq 0x210(%rsi), %rdx
testq %rdx, %rdx
je 0x4f57b
testb $0x40, 0x8(%r14)
je 0x4f57b
imull 0x220(%rsi), %ecx
addq %rcx, %rdx
movq (%r14), %rdi
xorl %esi, %esi
callq 0x3ef1d
movl 0x90(%r15), %eax
incq %r13
movl %eax, %ecx
addq $0x10, %r12
cmpq %rcx, %r13
jb 0x4f53d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3e19f
jmp 0x4f5d0
movq (%rbx), %rsi
addq $0x8, %rsi
leaq 0x26d48(%rip), %rcx     # 0x762ed
movl $0x2, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq