LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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), %rax
movq %rax, 0x158(%rdi)
cmpq 0x160(%rdi), %rax
jae 0x42db8
testb $0xc, 0x30(%r13)
je 0x42db8
movl %esi, %r14d
leaq 0x40(%r13), %rax
movq %rax, 0x158(%rbx)
leaq 0x88(%rbx), %r12
movq 0x20(%r13), %rsi
movl 0x28(%r13), %edx
movq %r12, %rdi
callq 0x3ae09
testq %rax, %rax
je 0x42dd8
movq 0x10(%rax), %r15
jmp 0x42e02
leaq 0x22bb4(%rip), %rcx     # 0x65973
xorl %r14d, %r14d
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3eed6
cmpl $-0xa, %eax
cmovel %eax, %r14d
jmp 0x42e25
movq (%rbx), %rdi
movq 0x20(%r13), %rsi
movl 0x28(%r13), %edx
callq 0x35732
testq %rax, %rax
je 0x42e37
movq %rax, %r15
movl 0x28(%r13), %edx
movq %r12, %rdi
movq %rax, %rsi
movq %rax, %rcx
callq 0x3b67d
andl $0x3, %r14d
xorl %edx, %edx
cmpl $0x2, %r14d
sete %dl
movq (%rbx), %rdi
xorl %r14d, %r14d
pushq $0x3
popq %rsi
xorl %ecx, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x3ee6f
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x426d9
pushq $-0xa
popq %r14
jmp 0x42e25
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x158(%rdi), %r8
leaq 0x22df1(%rip), %r15     # 0x65c58
pushq $0x1
popq %r12
pushq $-0xa
popq %r13
xorl %eax, %eax
cmpq 0x160(%rbx), %r8
jae 0x42eae
testb $0x14, 0x12(%r8)
jne 0x42eae
movl 0x14(%r8), %edx
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0x3eed6
cmpl $-0xa, %eax
je 0x42f06
movq 0x158(%rbx), %r8
addq $0x20, %r8
movq %r8, 0x158(%rbx)
jmp 0x42e71
addq $0x20, %r8
movq %r8, 0x158(%rbx)
movq (%rbx), %rcx
movq 0xf0(%rcx), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, (%r14)
pushq $-0x12
popq %r14
movq 0x158(%rbx), %rcx
cmpq 0x160(%rbx), %rcx
jae 0x42f09
movl 0x10(%rcx), %eax
testb $0x4, %al
jne 0x42eea
testb %al, %al
jns 0x42ef9
jmp 0x42f18
movl 0x18(%rcx), %ecx
xorl %eax, %eax
cmpl $0x5, %ecx
je 0x42f09
cmpl $0xa, %ecx
je 0x42f09
movq %rbx, %rdi
callq 0x4254b
cmpl $-0xa, %eax
jne 0x42ecd
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %eax
jmp 0x42f09
// File: /workspace/github_c_makefile_star2_O2/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 0x42fa8
testb $0x4, 0x12(%rdi)
jne 0x42fa8
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdi
jae 0x42fa2
movl 0x10(%rdi), %r8d
testl $0x60000, %r8d          # imm = 0x60000
je 0x42f79
testl %eax, %eax
jle 0x42fa2
movl %r8d, %r9d
andl $0x1480, %r9d           # imm = 0x1480
negl %r9d
movl $0x0, %r9d
sbbl %r9d, %r9d
testw $0xa40, %r8w            # imm = 0xA40
cmovnel %ecx, %r9d
addl %r9d, %eax
addq $0x20, %rdi
jmp 0x42f63
movq %rdi, (%rdx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x158(%rdi), %rax
movq 0x160(%rdi), %rsi
addq $0x20, %rax
movq %rax, 0x158(%rdi)
addq $-0x20, %rsi
movq %rsi, 0x160(%rdi)
xorl %r12d, %r12d
pushq $-0xa
popq %rbx
addq $0x20, %rax
leaq -0x20(%rax), %r13
cmpq %rsi, %r13
jae 0x4414a
testb $0x2, -0xe(%rax)
je 0x4414a
movq %rax, (%r15)
jmp 0x44132
movq %r13, %rdi
movq %r15, %rdx
callq 0x42f48
testl %eax, %eax
jne 0x44185
movq 0x158(%r14), %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x4462d
cmpl $-0xa, %eax
je 0x4419d
incl %r12d
movq 0x158(%r14), %rax
movq 0x160(%r14), %rsi
jmp 0x44132
movq (%r14), %rdi
xorl %ebx, %ebx
pushq $0x6
popq %rsi
movl %r12d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ee6f
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_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CompileAnnonFunc
JX9_PRIVATE sxi32 jx9CompileAnnonFunc(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
	jx9_vm_func *pAnnonFunc; /* Annonymous function body */
	char zName[512];         /* Unique lambda name */
	static int iCnt = 1;     /* There is no worry about thread-safety here, because only
							  * one thread is allowed to compile the script.
						      */
	jx9_value *pObj;
	SyString sName;
	sxu32 nIdx;
	sxu32 nLen;
	sxi32 rc;

	pGen->pIn++; /* Jump the 'function' keyword */
	if( pGen->pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD) ){
		pGen->pIn++;
	}
	/* Reserve a constant for the lambda */
	pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
	if( pObj == 0 ){
		GenStateOutOfMem(pGen);
		SXUNUSED(iCompileFlag); /* cc warning */
		return SXERR_ABORT;
	}
	/* Generate a unique name */
	nLen = SyBufferFormat(zName, sizeof(zName), "[lambda_%d]", iCnt++);
	/* Make sure the generated name is unique */
	while( SyHashGet(&pGen->pVm->hFunction, zName, nLen) != 0 && nLen < sizeof(zName) - 2 ){
		nLen = SyBufferFormat(zName, sizeof(zName), "[lambda_%d]", iCnt++);
	}
	SyStringInitFromBuf(&sName, zName, nLen);
	jx9MemObjInitFromString(pGen->pVm, pObj, &sName);
	/* Compile the lambda body */
	rc = GenStateCompileFunc(&(*pGen),&sName,0,&pAnnonFunc);
	if( rc == SXERR_ABORT ){
		return SXERR_ABORT;
	}
	/* 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 %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq 0x158(%rdi), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x158(%rdi)
testb $0xc, 0x30(%rax)
je 0x443b3
addq $0x40, %rax
movq %rax, 0x158(%rbx)
movq (%rbx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3ebdc
testq %rax, %rax
je 0x4446c
movq %rax, -0x38(%rbp)
leaq 0x21b5e(%rip), %r12     # 0x65f31
leaq -0x250(%rbp), %r15
movl $0x308, %r14d           # imm = 0x308
movl 0x4357a(%rip), %ecx     # 0x87960
leal 0x1(%rcx), %eax
movl %eax, 0x43571(%rip)     # 0x87960
movq %r15, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r12, %rdx
xorl %eax, %eax
callq 0x2d4b8
movl %eax, %r13d
movq (%rbx), %rdi
addq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x3ae09
cmpl $0x1fd, %r13d           # imm = 0x1FD
ja 0x44422
testq %rax, %rax
jne 0x443e0
leaq -0x50(%rbp), %r12
movq %r15, (%r12)
movl %r13d, 0x8(%r12)
movq (%rbx), %rdi
movq -0x38(%rbp), %rsi
movq %r12, %rdx
callq 0x3bbfe
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x426f3
cmpl $-0xa, %eax
je 0x44474
movq (%rbx), %rdi
movl -0x2c(%rbp), %ecx
xorl %ebx, %ebx
pushq $0x4
popq %rsi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ee6f
jmp 0x44477
movq %rbx, %rdi
callq 0x426d9
pushq $-0xa
popq %rbx
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GenStateCompileJSONEntry
static sxi32 GenStateCompileJSONEntry(
	jx9_gen_state *pGen, /* Code generator state */
	SyToken *pIn,        /* Token stream */
	SyToken *pEnd,       /* End of the token stream */
	sxi32 iFlags,        /* Compilation flags */
	sxi32 (*xValidator)(jx9_gen_state *,jx9_expr_node *) /* Expression tree validator callback */
	)
{
	SyToken *pTmpIn, *pTmpEnd;
	sxi32 rc;
	/* Swap token stream */
	SWAP_DELIMITER(pGen, pIn, pEnd);
	/* Compile the expression*/
	rc = jx9CompileExpr(&(*pGen), iFlags, xValidator);
	/* Restore token stream */
	RE_SWAP_DELIMITER(pGen);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movups 0x158(%rdi), %xmm0
movaps %xmm0, -0x20(%rbp)
movq %rsi, 0x158(%rdi)
movq %rdx, 0x160(%rdi)
pushq $0x2
popq %rsi
movq %rcx, %rdx
callq 0x4012f
movaps -0x20(%rbp), %xmm0
movups %xmm0, 0x158(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 -0x4cc(%rip), %rdx      # 0x441ae
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x446d8
leaq 0x583(%rip), %rdx       # 0x44c0b
cmpq %rdx, %rcx
je 0x446d8
leaq -0x1943(%rip), %rdx     # 0x42d51
cmpq %rdx, %rcx
je 0x446d8
leaq 0x39(%rip), %rdx        # 0x446d9
cmpq %rdx, %rcx
je 0x446d8
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x446b3
movl 0x14(%rax), %edx
jmp 0x446b5
xorl %edx, %edx
pushq %rbp
movq %rsp, %rbp
leaq 0x21745(%rip), %rcx     # 0x65e05
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x3eed6
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0xa, %ecx
sete %al
xorl $-0x9, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rsi)
movq (%rdi), %rdi
callq 0x3ebdc
movq %rax, %rbx
testq %rax, %rax
je 0x44dd5
incl (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3bbfe
movq (%r14), %rdi
movl -0x1c(%rbp), %ecx
pushq $0x4
popq %rsi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ee6f
jmp 0x44ddd
movq %r14, %rdi
callq 0x426d9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 %rdi, %rbx
movq (%rdi), %rax
movabsq $0x2000000000, %rcx     # imm = 0x2000000000
leaq -0x58(%rbp), %r14
movq %rcx, 0x14(%r14)
andl $0x0, 0x10(%r14)
movq %rdx, %r15
andl $0x0, 0x1c(%r14)
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movq %rsi, %r12
andq $0x0, 0x20(%r14)
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x3eba8
subl %r12d, %r15d
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x3f009
movups 0x158(%rbx), %xmm0
movaps %xmm0, -0x30(%rbp)
movq 0x8(%r14), %rax
movq %rax, 0x158(%rbx)
movl 0x10(%r14), %ecx
shlq $0x5, %rcx
addq %rax, %rcx
movq %rcx, 0x160(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4012f
movl %eax, %r15d
movaps -0x30(%rbp), %xmm0
movups %xmm0, 0x158(%rbx)
movq %r14, %rdi
callq 0x31feb
movl %r15d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
andl $0x0, -0x1c(%rbp)
testb $0x1, 0x10(%r14)
jne 0x44f46
movq (%rbx), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3ebdc
testq %rax, %rax
je 0x44f95
movq %rax, %r15
movq (%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3bbfe
movq %r15, %rdi
callq 0x3ac20
movl -0x1c(%rbp), %r14d
jmp 0x44f7b
movq %r14, %rdi
callq 0x3758e
movq %rax, %r15
leaq -0x20(%rbp), %rsi
andl $0x0, (%rsi)
movq (%rbx), %rdi
callq 0x3ebdc
testq %rax, %rax
je 0x44f95
movl -0x20(%rbp), %r14d
movl %r14d, -0x1c(%rbp)
movq (%rbx), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3c0cd
movq (%rbx), %rdi
xorl %ebx, %ebx
pushq $0x4
popq %rsi
xorl %edx, %edx
movl %r14d, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ee6f
jmp 0x44fa0
movq %rbx, %rdi
callq 0x426d9
pushq $-0xa
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
andl $0x0, -0x14(%rbp)
cmpl $0x0, 0x8(%r14)
movq (%rdi), %rdi
je 0x44ffb
leaq -0x14(%rbp), %rsi
callq 0x3ebdc
testq %rax, %rax
je 0x45011
movq (%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3bbfe
movq (%rbx), %rdi
movl -0x14(%rbp), %ecx
xorl %ebx, %ebx
pushq $0x4
popq %rsi
xorl %edx, %edx
jmp 0x45004
xorl %ebx, %ebx
pushq $0x4
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ee6f
jmp 0x45032
movq 0x158(%rbx), %rax
movl 0x14(%rax), %edx
leaq 0x20c53(%rip), %rcx     # 0x65c75
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3eed6
pushq $-0xa
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x45062
movq %r14, %rdi
callq 0x4503d
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x45073
movq %r14, %rdi
callq 0x4503d
movq 0x60(%rbx), %rsi
testq %rsi, %rsi
je 0x45084
movq %r14, %rdi
callq 0x4503d
movl 0x48(%rbx), %eax
testl %eax, %eax
je 0x450b9
leaq 0x38(%rbx), %r15
movq 0x40(%rbx), %r12
xorl %r13d, %r13d
movl %eax, %eax
cmpq %rax, %r13
jae 0x450b1
movq (%r12,%r13,8), %rsi
movq %r14, %rdi
callq 0x4503d
incq %r13
movl 0x48(%rbx), %eax
jmp 0x45096
movq %r15, %rdi
callq 0x31feb
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27bf8
// File: /workspace/github_c_makefile_star2_O2/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 $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x45143
movq 0x60(%rbx), %rax
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r14
movups %xmm0, 0x8(%r14)
movq %rax, (%r14)
andl $0x0, 0x18(%r14)
movq (%rdx), %rdi
movq %r14, %rsi
callq 0x3703b
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
callq 0x29903
movq %r14, %rdi
callq 0x2a72f
jmp 0x4514d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 $0xb0, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x451f2
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x451f2
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r14), %edx
testl %edx, %edx
jle 0x451f2
movq 0x60(%rbx), %rcx
leaq -0x40(%rbp), %rsi
movq $0x20, 0x18(%rsi)
movq %rcx, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
andq $0x0, 0x20(%rsi)
leaq -0x14(%rbp), %r14
andl $0x0, (%r14)
leaq -0x80(%rbp), %rdi
movq %rsi, 0x38(%rdi)
leaq 0xffd(%rip), %rcx       # 0x461c0
movq %rcx, 0x28(%rdi)
movq %r14, 0x30(%rdi)
movq $0x1, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq %rsi, 0x20(%rdi)
movq %rax, %rsi
callq 0x3ff6e
cmpl $0x0, (%r14)
je 0x45208
leaq -0x40(%rbp), %rdi
callq 0x31feb
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0xc0(%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)
andl $0x0, 0x18(%rdi)
andl $0x0, 0x30(%rdi)
leaq 0x13ca(%rip), %rax      # 0x46605
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x46615
movl %eax, -0x14(%rbp)
cmpl $-0xa, %eax
jne 0x4525b
movq %rbx, %rdi
callq 0x298e8
leaq -0x40(%rbp), %rdi
callq 0x31feb
jmp 0x451fa
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x45307
movq 0x60(%rbx), %r14
movq 0xf8(%r14), %r15
cmpq $0x0, (%r15)
je 0x45307
movq (%rdx), %rdi
callq 0x29772
testl %eax, %eax
js 0x45319
cmpl 0x90(%r15), %eax
jge 0x45319
movq 0x88(%r15), %rcx
testq %rcx, %rcx
je 0x45319
imull 0x98(%r15), %eax
movl (%rcx,%rax), %eax
cmpl %eax, 0x218(%r14)
jbe 0x45319
movq 0x210(%r14), %rsi
testq %rsi, %rsi
je 0x45319
imull 0x220(%r14), %eax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x299d3
jmp 0x45323
leaq 0x20fbf(%rip), %rdx     # 0x662cd
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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), %rax
movq 0xf8(%rax), %r15
cmpq $0x0, (%r15)
je 0x453be
movq %rbx, %rdi
callq 0x2a2b0
testq %rax, %rax
je 0x453d0
movq %rax, %r14
movq 0x88(%r15), %r12
xorl %r13d, %r13d
movl 0x90(%r15), %eax
cmpq %rax, %r13
jae 0x453b1
movq 0x60(%rbx), %rcx
movl (%r12), %eax
cmpl %eax, 0x218(%rcx)
jbe 0x453a8
movq 0x210(%rcx), %rdx
testq %rdx, %rdx
je 0x453a8
imull 0x220(%rcx), %eax
addq %rax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x29c4b
incq %r13
addq $0x10, %r12
jmp 0x4536c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x299d3
jmp 0x453da
leaq 0x20f08(%rip), %rdx     # 0x662cd
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_func_exists
static int vm_builtin_func_exists(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zName;
	jx9_vm *pVm;
	int nLen;
	int res;
	if( nArg < 1 ){
		/* Missing argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Extract the function name */
	zName = jx9_value_to_string(apArg[0], &nLen);
	/* Assume the function is not defined */
	res = 0;
	/* Perform the lookup */
	if( SyHashGet(&pVm->hFunction, (const void *)zName, (sxu32)nLen) != 0 ||
		SyHashGet(&pVm->hHostFunction, (const void *)zName, (sxu32)nLen) != 0 ){
			/* Function is defined */
			res = 1;
	}
	jx9_result_bool(pCtx, res);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x45451
movq 0x60(%rbx), %r14
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
movq %rax, %r15
leaq 0x308(%r14), %rdi
movl (%r12), %edx
movq %rax, %rsi
callq 0x3ae09
testq %rax, %rax
jne 0x45449
addq $0x2c8, %r14            # imm = 0x2C8
movl -0x24(%rbp), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ae09
testq %rax, %rax
je 0x4546a
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x45456
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
jmp 0x4544c
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_get_defined_func
static int vm_builtin_get_defined_func(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray;
	/* NOTE:
	 * Don't worry about freeing memory here, every allocated resource will be released
	 * automatically by the engine as soon we return from this foreign function.
	 */
	pArray = jx9_context_new_array(pCtx);
 	if( pArray == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* Return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Fill with the appropriate information */
	SyHashForEach(&pCtx->pVm->hHostFunction,VmHashFuncStep,pArray);
	/* Fill with the appropriate information */
	SyHashForEach(&pCtx->pVm->hFunction, VmHashFuncStep,pArray);
	/* Return a copy of the array array */
	jx9_result_value(pCtx, pArray);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2a2b0
testq %rax, %rax
je 0x454f4
movq %rax, %r14
movl $0x2c8, %edi            # imm = 0x2C8
addq 0x60(%rbx), %rdi
leaq 0x15e6(%rip), %r15      # 0x46aae
movq %r15, %rsi
movq %rax, %rdx
callq 0x46a61
movl $0x308, %edi            # imm = 0x308
addq 0x60(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x46a61
movq %rbx, %rdi
movq %r14, %rsi
callq 0x299d3
jmp 0x454fc
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_defined
static int vm_builtin_defined(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zName;
	int nLen = 0;
	int res = 0;
	if( nArg < 1 ){
		/* Missing constant name, return FALSE */
		jx9_context_throw_error(pCtx,JX9_CTX_NOTICE,"Missing constant name");
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Extract constant name */
	zName = jx9_value_to_string(apArg[0], &nLen);
	/* Perform the lookup */
	if( nLen > 0 && SyHashGet(&pCtx->pVm->hConstant, (const void *)zName, (sxu32)nLen) != 0 ){
		/* Already defined */
		res = 1;
	}
	jx9_result_bool(pCtx, res);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andl $0x0, -0x14(%rbp)
testl %esi, %esi
jle 0x45551
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r14), %edx
testl %edx, %edx
jle 0x4556a
movl $0x288, %edi            # imm = 0x288
addq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x3ae09
xorl %esi, %esi
testq %rax, %rax
setne %sil
jmp 0x4556c
leaq 0x20d90(%rip), %rdx     # 0x662e8
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x4556f
xorl %esi, %esi
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_get_defined_constants
static int vm_builtin_get_defined_constants(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray;
	/* Create the array first*/
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* Return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Fill the array with the defined constants */
	SyHashForEach(&pCtx->pVm->hConstant, VmHashConstStep, pArray);
	/* Return the created array */
	jx9_result_value(pCtx, pArray);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2a2b0
testq %rax, %rax
je 0x455bb
movq %rax, %r14
movl $0x288, %edi            # imm = 0x288
addq 0x60(%rbx), %rdi
leaq 0x1560(%rip), %rsi      # 0x46b06
movq %rax, %rdx
callq 0x46a61
movq %rbx, %rdi
movq %r14, %rsi
callq 0x299d3
jmp 0x455c3
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_rand
static int vm_builtin_rand(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	sxu32 iNum;
	/* Generate the random number */
	iNum = jx9VmRandomNum(pCtx->pVm);
	if( nArg > 1 ){
		sxu32 iMin, iMax;
		iMin = (sxu32)jx9_value_to_int(apArg[0]);
		iMax = (sxu32)jx9_value_to_int(apArg[1]);
		if( iMin < iMax ){
			sxu32 iDiv = iMax+1-iMin;
			if( iDiv > 0 ){
				iNum = (iNum % iDiv)+iMin;
			}
		}else if(iMax > 0 ){
			iNum %= iMax;
		}
	}
	/* Return the number */
	jx9_result_int64(pCtx, (jx9_int64)iNum);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x46b5e
movl %eax, %r14d
cmpl $0x2, %r15d
jl 0x45631
movq (%r12), %rdi
callq 0x29772
movl %eax, %r15d
movq 0x8(%r12), %rdi
callq 0x29772
movl %eax, %ecx
cmpl %eax, %r15d
jae 0x45623
incl %ecx
subl %r15d, %ecx
je 0x45631
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r14d
addl %r15d, %r14d
jmp 0x45631
testl %ecx, %ecx
je 0x45631
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x29897
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_rand_str
static int vm_builtin_rand_str(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	char zString[1024];
	int iLen = 0x10;
	if( nArg > 0 ){
		/* Get the desired length */
		iLen = jx9_value_to_int(apArg[0]);
		if( iLen < 1 || iLen > 1024 ){
			/* Default length */
			iLen = 0x10;
		}
	}
	/* Generate the random string */
	jx9VmRandomString(pCtx->pVm, zString, iLen);
	/* Return the generated string */
	jx9_result_string(pCtx, zString, iLen); /* Will make it's own copy */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
testl %esi, %esi
jle 0x4567c
movq (%rdx), %rdi
callq 0x29772
leal -0x401(%rax), %ecx
cmpl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
pushq $0x10
popq %r14
cmovael %eax, %r14d
jmp 0x45680
pushq $0x10
popq %r14
movq 0x60(%rbx), %rdi
leaq -0x420(%rbp), %r15
movq %r15, %rsi
movl %r14d, %edx
callq 0x46b83
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x29903
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_print
static int vm_builtin_print(jx9_context *pCtx, int nArg,jx9_value **apArg)
{
	const char *zData;
	int nDataLen = 0;
	jx9_vm *pVm;
	int i, rc;
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Output */
	for( i = 0 ; i < nArg ; ++i ){
		zData = jx9_value_to_string(apArg[i], &nDataLen);
		if( nDataLen > 0 ){
			rc = pVm->sVmConsumer.xConsumer((const void *)zData, (unsigned int)nDataLen, pVm->sVmConsumer.pUserData);
			/* Increment output length */
			pVm->nOutputLen += nDataLen;
			if( rc == SXERR_ABORT ){
				/* Output consumer callback request an operation abort */
				return JX9_ABORT;
			}
		}
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
leaq -0x2c(%rbp), %r12
andl $0x0, (%r12)
movq 0x60(%rdi), %r13
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r15d
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x4572f
movq (%rbx,%r14,8), %rdi
movq %r12, %rsi
callq 0x297ed
movl -0x2c(%rbp), %esi
testl %esi, %esi
jle 0x4572a
movq 0x500(%r13), %rdx
movq %rax, %rdi
callq *0x4f8(%r13)
movl -0x2c(%rbp), %ecx
addl %ecx, 0x4f4(%r13)
cmpl $-0xa, %eax
je 0x45733
incq %r14
jmp 0x456f2
xorl %eax, %eax
jmp 0x45736
pushq $-0xa
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_exit
static int vm_builtin_exit(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg > 0 ){
		if( jx9_value_is_string(apArg[0]) ){
			const char *zData;
			int iLen = 0;
			/* Print exit message */
			zData = jx9_value_to_string(apArg[0], &iLen);
			jx9_context_output(pCtx, zData, iLen);
		}else if(jx9_value_is_int(apArg[0]) ){
			sxi32 iExitStatus;
			/* Record exit status code */
			iExitStatus = jx9_value_to_int(apArg[0]);
			pCtx->pVm->iExitStatus = iExitStatus;
		}
	}
	/* Abort processing immediately */
	return JX9_ABORT;
}

// Assembly:
testl %esi, %esi
jle 0x4579c
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
movl 0x8(%rdi), %eax
testb $0x1, %al
jne 0x45776
testb $0x2, %al
je 0x45794
callq 0x29772
movq 0x60(%rbx), %rcx
movl %eax, 0x560(%rcx)
jmp 0x45794
leaq -0x14(%rbp), %r14
andl $0x0, (%r14)
movq %r14, %rsi
callq 0x297ed
movl (%r14), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29fae
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
pushq $-0xa
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_gettype
static int vm_builtin_gettype(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zType = "null";
	if( nArg > 0 ){
		zType = jx9MemObjTypeDump(apArg[0]);
	}
	/* Return the variable type */
	jx9_result_string(pCtx, zType, -1/*Compute length automatically*/);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x457ba
movq (%rdx), %rdi
callq 0x46bcc
movq %rax, %rsi
jmp 0x457c1
leaq 0x212fe(%rip), %rsi     # 0x66abf
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x29903
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_get_resource_type
static int vm_builtin_get_resource_type(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE*/
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	jx9_result_string_format(pCtx, "resID_%#x", apArg[0]->x.pOther);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x457e6
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
jne 0x457ef
xorl %esi, %esi
callq 0x298b2
jmp 0x45800
movq (%rax), %rdx
leaq 0x20b1c(%rip), %rsi     # 0x66315
xorl %eax, %eax
callq 0x3bdad
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_dump
static int vm_builtin_dump(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyBlob sDump; /* Generated dump is stored here */
	int i;
	SyBlobInit(&sDump,&pCtx->pVm->sAllocator);
	/* Dump one or more expressions */
	for( i = 0 ; i < nArg ; i++ ){
		jx9_value *pObj = apArg[i];
		/* Reset the working buffer */
		SyBlobReset(&sDump);
		/* Dump the given expression */
		jx9MemObjDump(&sDump,pObj);
		/* Output */
		if( SyBlobLength(&sDump) > 0 ){
			jx9_context_output(pCtx, (const char *)SyBlobData(&sDump), (int)SyBlobLength(&sDump));
		}
	}
	/* Release the working buffer */
	SyBlobRelease(&sDump);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq 0x60(%rdi), %rax
xorps %xmm0, %xmm0
leaq -0x48(%rbp), %r12
movups %xmm0, 0x8(%r12)
movq %rax, (%r12)
andl $0x0, 0x18(%r12)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movq %rsi, -0x60(%rbp)
pushq $0x1
popq %r13
xorl %r14d, %r14d
cmpq %r14, -0x60(%rbp)
je 0x4596b
movq -0x58(%rbp), %rax
movq (%rax,%r14,8), %r15
andl $0x0, -0x38(%rbp)
movl -0x30(%rbp), %eax
testb $0x4, %al
je 0x45876
andq $0x0, -0x40(%rbp)
andl $0x0, -0x34(%rbp)
andl $-0x5, %eax
movl %eax, -0x30(%rbp)
movq %r15, %rdi
callq 0x46bcc
movq %rax, %rbx
movq %rax, %rdi
callq 0x28e24
movq %r12, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x2e250
testb $0x20, 0x8(%r15)
jne 0x4593d
movq %r12, %rdi
leaq 0x1bb1f(%rip), %rsi     # 0x613ca
movl %r13d, %edx
callq 0x2e250
movl 0x8(%r15), %eax
testb $0x40, %al
jne 0x458cc
testb $0x1, %al
jne 0x458f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x36f88
jmp 0x4592b
movq (%r15), %rax
movl 0x2c(%rax), %edx
movq %r12, %rdi
leaq 0x20a43(%rip), %rsi     # 0x6631f
xorl %eax, %eax
callq 0x35d7b
movq %r15, %rdi
movq %r12, %rsi
callq 0x3703b
jmp 0x4592b
movl 0x28(%r15), %edx
movq %r12, %rdi
leaq 0x20a25(%rip), %rsi     # 0x66323
xorl %eax, %eax
callq 0x35d7b
movl 0x28(%r15), %edx
testl %edx, %edx
je 0x45919
movq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0x2e250
movq %r12, %rdi
leaq 0x20a03(%rip), %rsi     # 0x66326
movl %r13d, %edx
callq 0x2e250
movq %r12, %rdi
leaq 0x1c389(%rip), %rsi     # 0x61cbe
movl %r13d, %edx
callq 0x2e250
movq %r12, %rdi
leaq 0x2297a(%rip), %rsi     # 0x682c1
movl %r13d, %edx
callq 0x2e250
movl -0x38(%rbp), %edx
testl %edx, %edx
je 0x45963
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x29fae
incq %r14
jmp 0x4584a
leaq -0x48(%rbp), %rdi
callq 0x2a72f
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_extract
static int vm_builtin_extract(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	extract_aux_data sAux;
	jx9_hashmap *pMap;
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing/Invalid arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Empty map, return  0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Prepare the aux data */
	SyZero(&sAux, sizeof(extract_aux_data)-sizeof(sAux.zWorker));
	if( nArg > 1 ){
		sAux.iFlags = jx9_value_to_int(apArg[1]);
		if( nArg > 2 ){
			sAux.zPrefix = jx9_value_to_string(apArg[2], &sAux.Prefixlen);
		}
	}
	sAux.pVm = pCtx->pVm;
	/* Invoke the worker callback */
	jx9HashmapWalk(pMap, VmExtractCallback, &sAux);
	/* Number of variables successfully imported */
	jx9_result_int(pCtx, sAux.iCount);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq %rdi, %rbx
testl %esi, %esi
jle 0x45a50
movq %rdx, %r15
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x45a50
movq (%rax), %r14
cmpl $0x0, 0x2c(%r14)
je 0x45a50
movl %esi, %r12d
leaq -0x440(%rbp), %rdi
pushq $0x20
popq %rsi
callq 0x27aea
cmpl $0x1, %r12d
je 0x45a27
movq 0x8(%r15), %rdi
callq 0x29772
movl %eax, -0x424(%rbp)
cmpl $0x3, %r12d
jb 0x45a27
movq 0x10(%r15), %rdi
leaq -0x428(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movq %rax, -0x8(%r15)
movq 0x60(%rbx), %rax
leaq -0x440(%rbp), %r15
movq %rax, (%r15)
leaq 0x12b4(%rip), %rsi      # 0x46cf0
movq %r14, %rdi
movq %r15, %rdx
callq 0x46c45
movl 0x8(%r15), %esi
movq %rbx, %rdi
jmp 0x45a55
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
xorl %eax, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_utf8_encode
static int vm_builtin_utf8_encode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nByte, c, e;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nByte);
	if( nByte < 1 ){
		/* Empty string, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	zEnd = &zIn[nByte];
	/* Start the encoding process */
	for(;;){
		if( zIn >= zEnd ){
			/* End of input */
			break;
		}
		c = zIn[0];
		/* Advance the stream cursor */
		zIn++;
		/* Encode */
		if( c<0x00080 ){
			e = (c&0xFF);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
		}else if( c<0x00800 ){
			e = 0xC0 + ((c>>6)&0x1F);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
			e = 0x80 + (c & 0x3F);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
		}else if( c<0x10000 ){
			e = 0xE0 + ((c>>12)&0x0F);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
			e = 0x80 + ((c>>6) & 0x3F);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
			e = 0x80 + (c & 0x3F);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
		}else{
			e = 0xF0 + ((c>>18) & 0x07);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
			e = 0x80 + ((c>>12) & 0x3F);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
			e = 0x80 + ((c>>6) & 0x3F);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
			e = 0x80 + (c & 0x3F);
			jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
		} 
	}
	/* All done */
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
testl %esi, %esi
jle 0x45e55
movq (%rdx), %rdi
leaq -0x44(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %rbx
testq %rbx, %rbx
jle 0x45e55
movq %r12, -0x38(%rbp)
addq %rax, %rbx
leaq -0x2c(%rbp), %r12
pushq $0x1
popq %r13
cmpq %rbx, %rax
jae 0x45e5d
movzbl (%rax), %r15d
testb %r15b, %r15b
js 0x45e0c
movq -0x38(%rbp), %r14
jmp 0x45e38
movq %rax, -0x40(%rbp)
movl %r15d, %eax
shrl $0x6, %eax
orl $0xc0, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x29903
movq -0x40(%rbp), %rax
andl $-0x41, %r15d
incq %rax
movl %r15d, -0x2c(%rbp)
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
movq %rax, %r14
callq 0x29903
movq %r14, %rax
jmp 0x45df8
movq %r12, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq