LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyStrncmp
JX9_PRIVATE sxi32 SyStrncmp(const char *zLeft, const char *zRight, sxu32 nLen)
{
	const unsigned char *zP = (const unsigned char *)zLeft;
	const unsigned char *zQ = (const unsigned char *)zRight;

	if( SX_EMPTY_STR(zP) || SX_EMPTY_STR(zQ)  ){
			return SX_EMPTY_STR(zP) ? (SX_EMPTY_STR(zQ) ? 0 : -1) :1;
	}
	if( nLen <= 0 ){
		return 0;
	}
	for(;;){
		if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
		if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
		if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
		if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
	}
	return (sxi32)(zP[0] - zQ[0]);
}

// Assembly:
testq %rdi, %rdi
je 0x4d6e7
movb (%rdi), %al
testb %al, %al
sete %cl
testq %rsi, %rsi
sete %r8b
orb %cl, %r8b
je 0x4d6f7
testb %al, %al
jne 0x4d78a
testq %rsi, %rsi
je 0x4d790
xorl %eax, %eax
cmpb (%rsi), %al
sbbl %eax, %eax
retq
cmpb $0x0, (%rsi)
je 0x4d78a
testl %edx, %edx
je 0x4d790
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl %edx, %r8d
leaq -0x3(%r8), %r10
leaq -0x2(%r8), %r11
leaq -0x1(%r8), %rbx
xorl %edx, %edx
movq %rsi, %rcx
xorl %eax, %eax
cmpl %edx, %r8d
je 0x4d793
movb (%rdi,%rdx), %r9b
testb %r9b, %r9b
je 0x4d7c5
cmpb (%rsi,%rdx), %r9b
jne 0x4d797
cmpl %edx, %ebx
je 0x4d7d1
movb 0x1(%rdi,%rdx), %r9b
testb %r9b, %r9b
je 0x4d79f
cmpb 0x1(%rsi,%rdx), %r9b
jne 0x4d7a8
cmpl %edx, %r11d
je 0x4d7d1
movb 0x2(%rdi,%rdx), %r9b
testb %r9b, %r9b
je 0x4d7ad
cmpb 0x2(%rsi,%rdx), %r9b
jne 0x4d7b3
cmpl %edx, %r10d
je 0x4d793
movb 0x3(%rdi,%rdx), %r9b
testb %r9b, %r9b
je 0x4d7bd
cmpb 0x3(%rsi,%rdx), %r9b
jne 0x4d7d4
addq $0x4, %rcx
addq $0x4, %rdx
jmp 0x4d723
movl $0x1, %eax
retq
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x4d7d1
addq %rdx, %rsi
movq %rsi, %rcx
jmp 0x4d7c8
leaq (%rsi,%rdx), %rcx
incq %rcx
jmp 0x4d7c5
incq %rcx
jmp 0x4d7c8
addq $0x2, %rcx
jmp 0x4d7c5
leaq (%rsi,%rdx), %rcx
addq $0x2, %rcx
jmp 0x4d7c8
leaq (%rsi,%rdx), %rcx
addq $0x3, %rcx
xorl %r9d, %r9d
movzbl %r9b, %eax
movzbl (%rcx), %ecx
subl %ecx, %eax
popq %rbx
popq %rbp
retq
addq $0x3, %rcx
jmp 0x4d7c8
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: implode_callback
static int implode_callback(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
	struct implode_data *pData = (struct implode_data *)pUserData;
	const char *zData;
	int nLen;
	if( pData->bRecursive && jx9_value_is_json_array(pValue) && pData->nRecCount < 32 ){
		if( pData->nSeplen > 0 ){
			if( !pData->bFirst ){
				/* append the separator first */
				jx9_result_string(pData->pCtx, pData->zSep, pData->nSeplen);
			}else{
				pData->bFirst = 0;
			}
		}
		/* Recurse */
		pData->bFirst = 1;
		pData->nRecCount++;
		jx9HashmapWalk((jx9_hashmap *)pValue->x.pOther, implode_callback, pData);
		pData->nRecCount--;
		return JX9_OK;
	}
	/* Extract the string representation of the entry value */
	zData = jx9_value_to_string(pValue, &nLen);
	if( nLen > 0 ){
		if( pData->nSeplen > 0 ){
			if( !pData->bFirst ){
				/* append the separator first */
				jx9_result_string(pData->pCtx, pData->zSep, pData->nSeplen);
			}else{
				pData->bFirst = 0;
			}
		}
		jx9_result_string(pData->pCtx, zData, nLen);
	}else{
		SXUNUSED(pKey); /* cc warning */
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x0, 0x8(%rdx)
je 0x4da67
testb $0x40, 0x8(%r14)
je 0x4da67
movl 0x20(%rbx), %eax
cmpl $0x1f, %eax
jg 0x4da67
movl 0x18(%rbx), %edx
testl %edx, %edx
jle 0x4da44
cmpl $0x0, 0x1c(%rbx)
jne 0x4da44
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x29903
movl 0x20(%rbx), %eax
movl $0x1, 0x1c(%rbx)
incl %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rdi
leaq -0x57(%rip), %rsi       # 0x4da03
movq %rbx, %rdx
callq 0x46c45
decl 0x20(%rbx)
jmp 0x4daaf
leaq -0x1c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x297ed
movl (%r15), %edx
testl %edx, %edx
jle 0x4daaf
movq %rax, %r14
movl 0x18(%rbx), %eax
testl %eax, %eax
jle 0x4daa4
cmpl $0x0, 0x1c(%rbx)
je 0x4da93
andl $0x0, 0x1c(%rbx)
jmp 0x4daa4
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movl %eax, %edx
callq 0x29903
movl -0x1c(%rbp), %edx
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x29903
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: iPatternMatch
static sxi32 iPatternMatch(const void *pText, sxu32 nLen, const void *pPattern, sxu32 iPatLen, sxu32 *pOfft)
{
	const char *zpIn = (const char *)pPattern;
	const char *zIn = (const char *)pText;
	const char *zpEnd = &zpIn[iPatLen];
	const char *zEnd = &zIn[nLen];
	const char *zPtr, *zPtr2;
	int c, d;
	if( iPatLen > nLen ){
		/* Don't bother processing */
		return SXERR_NOTFOUND;
	}
	for(;;){
		if( zIn >= zEnd ){
			break;
		}
		c = SyToLower(zIn[0]);
		d = SyToLower(zpIn[0]);
		if( c == d ){
			zPtr   = &zIn[1];
			zPtr2  = &zpIn[1];
			for(;;){
				if( zPtr2 >= zpEnd ){
					/* Pattern found */
					if( pOfft ){ *pOfft = (sxu32)(zIn-(const char *)pText); }
					return SXRET_OK;
				}
				if( zPtr >= zEnd ){
					break;
				}
				c = SyToLower(zPtr[0]);
				d = SyToLower(zPtr2[0]);
				if( c != d ){
					break;
				}
				zPtr++; zPtr2++;
			}
		}
		zIn++;
	}
	/* Pattern not found */
	return SXERR_NOTFOUND;
}

// Assembly:
pushq $-0x6
popq %rax
cmpl %esi, %ecx
ja 0x4db6f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %r8, -0x38(%rbp)
movl %ecx, %r13d
addq %rdx, %r13
movl %esi, %ebx
addq %rdi, %rbx
leaq 0x1(%rdx), %rax
movq %rax, -0x40(%rbp)
leaq 0x1(%rdi), %r14
movq %rdi, -0x30(%rbp)
movq %rdi, %r15
cmpq %rbx, %r15
jae 0x4db5e
callq 0xc4a0
movq (%rax), %rax
movsbq (%r15), %rcx
movl (%rax,%rcx,4), %ecx
movsbq (%r12), %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0x4db42
movq %r14, %rcx
movq -0x40(%rbp), %rdx
cmpq %r13, %rdx
jae 0x4db4a
cmpq %rbx, %rcx
jae 0x4db42
movsbq (%rcx), %rsi
movl (%rax,%rsi,4), %esi
movsbq (%rdx), %rdi
incq %rdx
incq %rcx
cmpl (%rax,%rdi,4), %esi
je 0x4db22
incq %r15
incq %r14
jmp 0x4dafd
xorl %eax, %eax
movq -0x38(%rbp), %rcx
testq %rcx, %rcx
je 0x4db61
subl -0x30(%rbp), %r15d
movl %r15d, (%rcx)
jmp 0x4db61
pushq $-0x6
popq %rax
addq $0x18, %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: jx9HashmapValuesToSet
JX9_PRIVATE int jx9HashmapValuesToSet(jx9_hashmap *pMap, SySet *pOut)
{
	jx9_hashmap_node *pEntry = pMap->pFirst;
	jx9_value *pValue;
	sxu32 n;
	/* Initialize the container */
	SySetInit(pOut, &pMap->pVm->sAllocator, sizeof(jx9_value *));
	for(n = 0 ; n < pMap->nEntry ; n++ ){
		/* Extract node value */
		pValue = HashmapExtractNodeValue(pEntry);
		if( pValue ){
			SySetPut(pOut, (const void *)&pValue);
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
	}
	/* Total inserted entries */
	return (int)SySetUsed(pOut);
}

// 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 0x10(%rdi), %r15
movq (%rdi), %rax
movabsq $0x800000000, %rcx      # imm = 0x800000000
movq %rcx, 0x14(%rsi)
andl $0x0, 0x10(%rsi)
andl $0x0, 0x1c(%rsi)
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
andq $0x0, 0x20(%rsi)
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
cmpl 0x2c(%r14), %r13d
jae 0x4e80d
movq %r15, %rdi
callq 0x35e71
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x4e804
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2be00
movq 0x48(%r15), %r15
incl %r13d
jmp 0x4e7e2
movl 0x10(%rbx), %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: jx9ProcessCsv
JX9_PRIVATE sxi32 jx9ProcessCsv(
	const char *zInput, /* Raw input */
	int nByte,  /* Input length */
	int delim,  /* Delimiter */
	int encl,   /* Enclosure */
	int escape,  /* Escape character */
	sxi32 (*xConsumer)(const char *, int, void *), /* User callback */
	void *pUserData /* Last argument to xConsumer() */
	)
{
	const char *zEnd = &zInput[nByte];
	const char *zIn = zInput;
	const char *zPtr;
	int isEnc;
	/* Start processing */
	for(;;){
		if( zIn >= zEnd ){
			/* No more input to process */
			break;
		}
		isEnc = 0;
		zPtr = zIn;
		/* Find the first delimiter */
		while( zIn < zEnd ){
			if( zIn[0] == delim && !isEnc){
				/* Delimiter found, break imediately */
				break;
			}else if( zIn[0] == encl ){
				/* Inside enclosure? */
				isEnc = !isEnc;
			}else if( zIn[0] == escape ){
				/* Escape sequence */
				zIn++;
			}
			/* Advance the cursor */
			zIn++;
		}
		if( zIn > zPtr ){
			int nByte = (int)(zIn-zPtr);
			sxi32 rc;
			/* Invoke the supllied callback */
			if( zPtr[0] == encl ){
				zPtr++;
				nByte-=2;
			}
			if( nByte > 0 ){
				rc = xConsumer(zPtr, nByte, pUserData);
				if( rc == SXERR_ABORT ){
					/* User callback request an operation abort */
					break;
				}
			}
		}
		/* Ignore trailing delimiter */
		while( zIn < zEnd && zIn[0] == delim ){
			zIn++;
		}
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movslq %esi, %r13
addq %rdi, %r13
cmpq %r13, %rdi
jae 0x4e8d0
xorl %eax, %eax
movq %rdi, %rbx
cmpq %r13, %rbx
jae 0x4e884
movsbl (%rbx), %ecx
cmpl %r12d, %ecx
jne 0x4e85f
testl %eax, %eax
je 0x4e884
xorl %edx, %edx
testl %eax, %eax
sete %dl
cmpl %r14d, %ecx
sete %sil
cmpl %r15d, %ecx
cmovel %edx, %eax
setne %cl
andb %sil, %cl
movzbl %cl, %ecx
addq %rcx, %rbx
incq %rbx
jmp 0x4e84e
cmpq %rdi, %rbx
jbe 0x4e8b6
movl %ebx, %ecx
subl %edi, %ecx
movsbl (%rdi), %eax
leal -0x2(%rcx), %esi
cmpl %r15d, %eax
cmovnel %ecx, %esi
testl %esi, %esi
jle 0x4e8b6
xorl %ecx, %ecx
cmpl %r15d, %eax
sete %cl
addq %rcx, %rdi
movq -0x30(%rbp), %rdx
callq 0x4e8df
cmpl $-0xa, %eax
je 0x4e8d0
cmpq %r13, %rbx
jae 0x4e8c8
movsbl (%rbx), %eax
cmpl %r12d, %eax
jne 0x4e8c8
incq %rbx
jmp 0x4e8b6
movq %rbx, %rdi
jmp 0x4e840
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: jx9CsvConsumer
JX9_PRIVATE sxi32 jx9CsvConsumer(const char *zToken, int nTokenLen, void *pUserData)
{
	jx9_value *pArray = (jx9_value *)pUserData;
	jx9_value sEntry;
	SyString sToken;
	/* Insert the token in the given array */
	SyStringInitFromBuf(&sToken, zToken, nTokenLen);
	/* Remove trailing and leading white spcaces and null bytes */
	SyStringFullTrimSafe(&sToken);
	if( sToken.nByte < 1){
		return SXRET_OK;
	}
	jx9MemObjInitFromString(pArray->pVm, &sEntry, &sToken);
	jx9_array_add_elem(pArray, 0, &sEntry);
	jx9MemObjRelease(&sEntry);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x40(%rbp)
movl %esi, %r14d
movq %rdi, %r15
movq %rdi, -0x38(%rbp)
movl %esi, -0x30(%rbp)
incq %r15
movl %esi, %r12d
decl %r14d
testl %r12d, %r12d
je 0x4e93e
movsbq -0x1(%r15), %r13
cmpq $-0x41, %r13
ja 0x4e93e
testb %r13b, %r13b
je 0x4e92f
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
je 0x4e93e
movq %r15, -0x38(%rbp)
incq %r15
decl %r14d
decq %r12
jmp 0x4e90a
movl %r12d, -0x30(%rbp)
movq %r12, %r13
subq $0x1, %r13
jb 0x4e9a8
movl %r14d, %r14d
movsbq -0x1(%r15,%r14), %rbx
cmpq $-0x41, %rbx
ja 0x4e975
testb %bl, %bl
je 0x4e96d
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0x4e975
decl %r14d
movq %r13, %r12
jmp 0x4e945
leaq -0x38(%rbp), %rdx
movl %r12d, 0x8(%rdx)
movq -0x40(%rbp), %rbx
movq 0x10(%rbx), %rdi
leaq -0x80(%rbp), %r14
movq %r14, %rsi
callq 0x3bbfe
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x29c4b
movq %r14, %rdi
callq 0x296af
jmp 0x4e9ac
movl %r12d, -0x30(%rbp)
xorl %eax, %eax
addq $0x58, %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: ExtractNonSpaceToken
static sxi32 ExtractNonSpaceToken(const char **pzIn, const char *zEnd, SyString *pOut)
{
	const char *zIn = *pzIn;
	const char *zPtr;
	/* Ignore leading white spaces */
	while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && SyisSpace(zIn[0]) ){
		zIn++;
	}
	if( zIn >= zEnd ){
		/* End of input */
		return SXERR_EOF;
	}
	zPtr = zIn;
	/* Extract the token */
	while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && !SyisSpace(zIn[0]) ){
		zIn++;
	}
	SyStringInitFromBuf(pOut, zPtr, zIn-zPtr);
	/* Synchronize pointers */
	*pzIn = zIn;
	/* Return to the caller */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movq (%rdi), %r13
pushq $-0x12
popq %r12
cmpq %r15, %r13
jae 0x4eed8
movsbq (%r13), %rbx
cmpq $-0x41, %rbx
ja 0x4ee94
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0x4ee94
incq %r13
jmp 0x4ee70
movq %r14, -0x30(%rbp)
xorl %r12d, %r12d
leaq (%r12,%r13), %rbx
cmpq %r15, %rbx
jae 0x4eec3
movsbq (%rbx), %r14
cmpq $-0x41, %r14
ja 0x4eec3
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0x4eec3
incq %r12
jmp 0x4ee9b
movq -0x30(%rbp), %rax
movq %r13, (%rax)
movl %r12d, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rbx, (%rax)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %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: ExtractToken
static sxi32 ExtractToken(const char **pzIn, const char *zEnd, const char *zMask, int nMasklen, SyString *pOut)
{
	const char *zIn = *pzIn;
	const char *zPtr;
	/* Ignore leading delimiter */
	while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && CheckMask(zIn[0], zMask, nMasklen, 0) ){
		zIn++;
	}
	if( zIn >= zEnd ){
		/* End of input */
		return SXERR_EOF;
	}
	zPtr = zIn;
	/* Extract the token */
	while( zIn < zEnd ){
		if( (unsigned char)zIn[0] >= 0xc0 ){
			/* UTF-8 stream */
			zIn++;
			SX_JMP_UTF8(zIn, zEnd);
		}else{
			if( CheckMask(zIn[0], zMask, nMasklen, 0) ){
				break;
			}
			zIn++;
		}
	}
	SyStringInitFromBuf(pOut, zPtr, zIn-zPtr);
	/* Update the cursor */
	*pzIn = zIn;
	/* Return to the caller */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movl %ecx, -0x2c(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, -0x40(%rbp)
movq (%rdi), %rbx
movq %rbx, %r14
cmpq %r15, %r14
jae 0x4efa0
movsbl (%r14), %edi
cmpl $-0x41, %edi
ja 0x4ef3b
movq %r12, %rsi
movl -0x2c(%rbp), %edx
xorl %ecx, %ecx
callq 0x4efb2
testl %eax, %eax
je 0x4ef3b
incq %r14
incl %ebx
jmp 0x4ef11
movq %r13, -0x38(%rbp)
movq %r14, %r13
cmpq %r15, %r13
jae 0x4ef86
movsbl (%r13), %edi
cmpl $-0x40, %edi
jb 0x4ef6b
incq %r13
cmpq %r15, %r13
jae 0x4ef81
movb (%r13), %al
andb $-0x40, %al
incq %r13
negb %al
jo 0x4ef54
decq %r13
jmp 0x4ef42
movq %r12, %rsi
movl -0x2c(%rbp), %edx
xorl %ecx, %ecx
callq 0x4efb2
testl %eax, %eax
jne 0x4ef86
incq %r13
jmp 0x4ef42
movq %r15, %r13
jmp 0x4ef42
movq -0x38(%rbp), %rcx
movq %r14, (%rcx)
movl %r13d, %eax
subl %ebx, %eax
movl %eax, 0x8(%rcx)
movq -0x40(%rbp), %rax
movq %r13, (%rax)
xorl %eax, %eax
jmp 0x4efa3
pushq $-0x12
popq %rax
addq $0x18, %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: CheckMask
static int CheckMask(int c, const char *zMask, int nMasklen, int *pOfft)
{
	int i;
	for( i = 0 ; i < nMasklen ; ++i ){
		if( c == zMask[i] ){
			if( pOfft ){
				*pOfft = i;
			}
			return TRUE;
		}
	}
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x4efe1
movsbl (%rsi,%r8), %r9d
cmpl %edi, %r9d
je 0x4efd4
incq %r8
jmp 0x4efc0
movl $0x1, %eax
testq %rcx, %rcx
je 0x4efe1
movl %r8d, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: StrReplaceWalker
static int StrReplaceWalker(jx9_value *pKey, jx9_value *pData, void *pUserData)
{
	str_replace_data *pRep = (str_replace_data *)pUserData;
	SyString sWorker;
	const char *zIn;
	int nByte;
	/* Extract a string representation of the given argument */
	zIn = jx9_value_to_string(pData, &nByte);
	SyStringInitFromBuf(&sWorker, 0, 0);
	if( nByte > 0 ){
		char *zDup;
		/* Duplicate the chunk */
		zDup = (char *)jx9_context_alloc_chunk(pRep->pCtx, (unsigned int)nByte, FALSE, 
			TRUE /* Release the chunk automatically, upon this context is destroyd */
			);
		if( zDup == 0 ){
			/* Ignore any memory failure problem */
			jx9_context_throw_error(pRep->pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
			return JX9_OK;
		}
		SyMemcpy(zIn, zDup, (sxu32)nByte);
		/* Save the chunk */
		SyStringInitFromBuf(&sWorker, zDup, nByte);
	}
	/* Save for later processing */
	SySetPut(pRep->pCollector, (const void *)&sWorker);
	/* All done */
	SXUNUSED(pKey); /* cc warning */
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
andq $0x0, -0x30(%rbp)
andl $0x0, -0x28(%rbp)
movl (%r15), %esi
testl %esi, %esi
jle 0x4f043
movq %rax, %r14
movq 0x18(%rbx), %rdi
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x2a356
testq %rax, %rax
je 0x4f052
movq %rax, %r15
movl -0x1c(%rbp), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2d3b0
movq %r15, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq 0x10(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2be00
jmp 0x4f065
movq 0x18(%rbx), %rdi
leaq 0x17253(%rip), %rdx     # 0x662b0
pushq $0x1
popq %rsi
callq 0x2a0db
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: StringReplace
static int StringReplace(SyBlob *pWorker, sxu32 nOfft, int nLen, const char *zReplace, int nReplen)
{
	char *zInput = (char *)SyBlobData(pWorker);
	sxu32 n, m;
	n = SyBlobLength(pWorker);
	m = nOfft;
	/* Delete the old entry */
	STRDEL(zInput, n, m, nLen);
	SyBlobLength(pWorker) -= nLen;
	if( nReplen > 0 ){
		sxi32 iRep = nReplen;
		sxi32 rc;
		/*
		 * Make sure the working buffer is big enough to hold the replacement
		 * string.
		 */
		rc = SyBlobAppend(pWorker, 0/* Grow without an append operation*/, (sxu32)nReplen);
		if( rc != SXRET_OK ){
			/* Simply ignore any memory failure problem */
			return SXRET_OK;
		}
		/* Perform the insertion now */
		zInput = (char *)SyBlobData(pWorker);
		n = SyBlobLength(pWorker);
		SHIFTRANDINSERT(zInput, n, nOfft, zReplace, iRep);
		SyBlobLength(pWorker) += nReplen;
	}	
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movl %esi, %r12d
movq %rdi, %r15
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %ecx
leal (%rdx,%r12), %esi
movl %r12d, %edi
cmpl %ecx, %esi
jae 0x4f0b0
movb (%rax,%rsi), %r8b
movl %edi, %r9d
movb %r8b, (%rax,%r9)
incl %edi
incq %rsi
jmp 0x4f09a
subl %edx, 0x10(%r15)
testl %ebx, %ebx
jle 0x4f10f
xorl %r13d, %r13d
movq %r15, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x2e250
testl %eax, %eax
jne 0x4f10f
movq 0x8(%r15), %rax
movl 0x10(%r15), %ecx
movl %r12d, %edx
subl %ecx, %edx
testl %edx, %edx
je 0x4f0f2
subl $0x1, %ecx
cmovbl %r13d, %ecx
movb (%rax,%rcx), %sil
leal (%rcx,%rbx), %edi
movb %sil, (%rax,%rdi)
incl %edx
jmp 0x4f0d8
movl %ebx, %ecx
testl %ecx, %ecx
jle 0x4f10b
movb (%r14), %dl
movl %r12d, %esi
movb %dl, (%rax,%rsi)
incl %r12d
incq %r14
decl %ecx
jmp 0x4f0f4
addl %ebx, 0x10(%r15)
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: StringReplaceWalker
static int StringReplaceWalker(jx9_value *pKey, jx9_value *pData, void *pUserData)
{
	str_replace_data *pRepData = (str_replace_data *)pUserData;
	const char *zTarget, *zReplace;
	SyBlob *pWorker;
	int tLen, nLen;
	sxu32 nOfft;
	sxi32 rc;
	/* Point to the working buffer */
	pWorker = pRepData->pWorker;
	if( !jx9_value_is_string(pKey) ){
		/* Target and replace must be a string */
		return JX9_OK;
	}
	/* Extract the target and the replace */
	zTarget = jx9_value_to_string(pKey, &tLen);
	if( tLen < 1 ){
		/* Empty target, return immediately */
		return JX9_OK;
	}
	/* Perform a pattern search */
	rc = pRepData->xMatch(SyBlobData(pWorker), SyBlobLength(pWorker), (const void *)zTarget, (sxu32)tLen, &nOfft);
	if( rc != SXRET_OK ){
		/* Pattern not found */
		return JX9_OK;
	}
	/* Extract the replace string */
	zReplace = jx9_value_to_string(pData, &nLen);
	/* Perform the replace process */
	StringReplace(pWorker, nOfft, tLen, zReplace, nLen);
	/* All done */
	return JX9_OK;
}

// Assembly:
testb $0x1, 0x8(%rdi)
je 0x4f195
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq (%rdx), %rbx
leaq -0x28(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x4f189
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
leaq -0x24(%rbp), %r8
movq %rax, %rdx
callq *0x8(%r15)
testl %eax, %eax
jne 0x4f189
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x297ed
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl (%r15), %r8d
movq %rbx, %rdi
movq %rax, %rcx
callq 0x4f072
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_count
static int jx9_hashmap_count(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int bRecursive = FALSE;
	sxi64 iCount;
	if( nArg < 1 ){
		/* Missing arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* TICKET 1433-19: Handle objects */
		int res = !jx9_value_is_null(apArg[0]);
		jx9_result_int(pCtx, res);
		return JX9_OK;
	}
	if( nArg > 1 ){
		/* Recursive count? */
		bRecursive = jx9_value_to_int(apArg[1]) == 1 /* COUNT_RECURSIVE */;
	}
	/* Count */
	iCount = HashmapCount((jx9_hashmap *)apArg[0]->x.pOther, bRecursive, 0);
	jx9_result_int64(pCtx, iCount);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x4fc9c
movq %rdx, %r14
movq (%rdx), %rcx
movl 0x8(%rcx), %edx
testb $0x40, %dl
jne 0x4fca8
xorl %esi, %esi
testb $0x20, %dl
sete %sil
movq %rbx, %rdi
jmp 0x4fca1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
jmp 0x4fcdb
movl %esi, %eax
xorl %esi, %esi
cmpl $0x1, %eax
je 0x4fcc6
movq 0x8(%r14), %rdi
callq 0x29772
xorl %esi, %esi
cmpl $0x1, %eax
sete %sil
movq (%r14), %rcx
movq (%rcx), %rdi
xorl %edx, %edx
callq 0x50c2e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29897
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: jx9_hashmap_key_exists
static int jx9_hashmap_key_exists(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[1]) ){
		/* Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the lookup */
	rc = jx9HashmapLookup((jx9_hashmap *)apArg[1]->x.pOther, apArg[0], 0);
	/* lookup result */
	jx9_result_bool(pCtx, rc == SXRET_OK ? 1 : 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
xorl %esi, %esi
cmpl $0x2, %eax
jl 0x4fd13
movq 0x8(%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x4fd13
movq (%rax), %rdi
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x3b028
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x298b2
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: jx9_hashmap_pop
static int jx9_hashmap_pop(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Noting to pop, return NULL */
		jx9_result_null(pCtx);
	}else{
		jx9_hashmap_node *pLast = pMap->pLast;
		jx9_value *pObj;
		pObj = HashmapExtractNodeValue(pLast);
		if( pObj ){
			/* Node value */
			jx9_result_value(pCtx, pObj);
			/* Unlink the node */
			jx9HashmapUnlinkNode(pLast);
		}else{
			jx9_result_null(pCtx);
		}
		/* Reset the cursor */
		pMap->pCur = pMap->pFirst;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4fd6e
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x4fd6e
movq (%rax), %r15
cmpl $0x0, 0x2c(%r15)
je 0x4fd6e
movq 0x18(%r15), %r14
movq %r14, %rdi
callq 0x35e71
movq %rbx, %rdi
testq %rax, %rax
je 0x4fd83
movq %rax, %rsi
callq 0x299d3
movq %r14, %rdi
callq 0x50cce
jmp 0x4fd88
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x298e8
movq 0x10(%r15), %rax
movq %rax, 0x20(%r15)
jmp 0x4fd76
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_push
static int jx9_hashmap_push(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	sxi32 rc;
	int i;
	if( nArg < 1 ){
		/* Missing arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Start pushing given values */
	for( i = 1 ; i < nArg ; ++i ){
		rc = jx9HashmapInsert(pMap, 0, apArg[i]);
		if( rc != SXRET_OK ){
			break;
		}
	}
	/* Return the new count */
	jx9_result_int64(pCtx, (sxi64)pMap->nEntry);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4fdb3
movq %rdx, %r14
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x4fdbf
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
jmp 0x4fdef
movq (%rax), %r15
movl %esi, %r12d
pushq $0x1
popq %r13
cmpq %r13, %r12
je 0x4fde3
movq (%r14,%r13,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x36999
incq %r13
testl %eax, %eax
je 0x4fdc9
movl 0x2c(%r15), %esi
movq %rbx, %rdi
callq 0x29897
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: jx9_hashmap_product
static int jx9_hashmap_product(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	jx9_value *pObj;
	if( nArg < 1 ){
		/* Missing arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Nothing to compute, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* If the first element is of type float, then perform floating
	 * point computaion.Otherwise switch to int64 computaion.
	 */
	pObj = HashmapExtractNodeValue(pMap->pFirst);
	if( pObj == 0 ){
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	if( pObj->iFlags & MEMOBJ_REAL ){
		DoubleProd(pCtx, pMap);
	}else{
		Int64Prod(pCtx, pMap);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4ff67
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x4ff67
movq (%rax), %r15
movl 0x2c(%r15), %r13d
testl %r13d, %r13d
je 0x4ff67
movq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x35e71
testq %rax, %rax
je 0x4ff67
testb $0x4, 0x8(%rax)
jne 0x4ff8f
movq %r15, -0x30(%rbp)
xorl %r12d, %r12d
pushq $0x1
popq %r15
cmpl %r13d, %r12d
jae 0x4ff82
movq %r14, %rdi
callq 0x35e71
testq %rax, %rax
je 0x4ff31
movl 0x8(%rax), %ecx
testw $0x160, %cx             # imm = 0x160
jne 0x4ff31
testb $0x4, %cl
jne 0x4ff28
testb $0xa, %cl
je 0x4ff3a
imulq (%rax), %r15
jmp 0x4ff31
cvttsd2si (%rax), %rax
imulq %rax, %r15
incl %r12d
movq 0x48(%r14), %r14
jmp 0x4fef8
testb $0x1, %cl
je 0x4ff31
movl 0x28(%rax), %esi
testl %esi, %esi
je 0x4ff31
andq $0x0, -0x38(%rbp)
movq 0x20(%rax), %rdi
leaq -0x38(%rbp), %rdx
callq 0x37b90
imulq -0x38(%rbp), %r15
movq -0x30(%rbp), %rax
movl 0x2c(%rax), %r13d
jmp 0x4ff31
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29897
jmp 0x4ff71
movsd 0x13629(%rip), %xmm0    # 0x635c0
movsd %xmm0, -0x30(%rbp)
leaq -0x38(%rbp), %r15
subl $0x1, %r13d
jb 0x50019
movq %r14, %rdi
callq 0x35e71
testq %rax, %rax
je 0x4ffea
movl 0x8(%rax), %ecx
testw $0x160, %cx             # imm = 0x160
jne 0x4ffea
testb $0x4, %cl
jne 0x4ffdc
testb $0xa, %cl
je 0x4fff0
cvtsi2sdq (%rax), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
jmp 0x4ffea
movsd -0x30(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x48(%r14), %r14
jmp 0x4ffa0
testb $0x1, %cl
je 0x4ffea
movl 0x28(%rax), %esi
testl %esi, %esi
je 0x4ffea
andq $0x0, -0x38(%rbp)
movq 0x20(%rax), %rdi
movq %r15, %rdx
callq 0x36406
movsd -0x30(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
jmp 0x4ffe5
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x298cd
jmp 0x4ff71
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_sum
static int jx9_hashmap_sum(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	jx9_value *pObj;
	if( nArg < 1 ){
		/* Missing arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Nothing to compute, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* If the first element is of type float, then perform floating
	 * point computaion.Otherwise switch to int64 computaion.
	 */
	pObj = HashmapExtractNodeValue(pMap->pFirst);
	if( pObj == 0 ){
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	if( pObj->iFlags & MEMOBJ_REAL ){
		DoubleSum(pCtx, pMap);
	}else{
		Int64Sum(pCtx, pMap);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x500f1
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x500f1
movq (%rax), %r15
movl 0x2c(%r15), %r13d
testl %r13d, %r13d
je 0x500f1
movq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x35e71
testq %rax, %rax
je 0x500f1
testb $0x4, 0x8(%rax)
jne 0x50119
movq %r15, -0x30(%rbp)
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpl %r13d, %r12d
jae 0x5010c
movq %r14, %rdi
callq 0x35e71
testq %rax, %rax
je 0x500bc
movl 0x8(%rax), %ecx
testw $0x160, %cx             # imm = 0x160
jne 0x500bc
testb $0x4, %cl
jne 0x500b4
testb $0xa, %cl
je 0x500c5
addq (%rax), %r15
jmp 0x500bc
cvttsd2si (%rax), %rax
addq %rax, %r15
incl %r12d
movq 0x48(%r14), %r14
jmp 0x50089
testb $0x1, %cl
je 0x500bc
movl 0x28(%rax), %esi
testl %esi, %esi
je 0x500bc
andq $0x0, -0x38(%rbp)
movq 0x20(%rax), %rdi
leaq -0x38(%rbp), %rdx
callq 0x37b90
addq -0x38(%rbp), %r15
movq -0x30(%rbp), %rax
movl 0x2c(%rax), %r13d
jmp 0x500bc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29897
jmp 0x500fb
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x38(%rbp), %r15
subl $0x1, %r13d
jb 0x5019f
movq %r14, %rdi
callq 0x35e71
testq %rax, %rax
je 0x50170
movl 0x8(%rax), %ecx
testw $0x160, %cx             # imm = 0x160
jne 0x50170
testb $0x4, %cl
jne 0x50162
testb $0xa, %cl
je 0x50176
cvtsi2sdq (%rax), %xmm0
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
jmp 0x50170
movsd -0x30(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x48(%r14), %r14
jmp 0x50126
testb $0x1, %cl
je 0x50170
movl 0x28(%rax), %esi
testl %esi, %esi
je 0x50170
andq $0x0, -0x38(%rbp)
movq 0x20(%rax), %rdi
movq %r15, %rdx
callq 0x36406
movsd -0x30(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
jmp 0x5016b
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x298cd
jmp 0x500fb
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_values
static int jx9_hashmap_values(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap_node *pNode;
	jx9_hashmap *pMap;
	jx9_value *pArray;
	jx9_value *pObj;
	sxu32 n;
	if( nArg < 1 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation that describe the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Perform the requested operation */
	pNode = pMap->pFirst;
	for( n = 0 ; n < pMap->nEntry ; ++n ){
		pObj = HashmapExtractNodeValue(pNode);
		if( pObj ){
			/* perform the insertion */
			jx9_array_add_elem(pArray, 0/* Automatic index assign */, pObj);
		}
		/* Point to the next entry */
		pNode = pNode->pPrev; /* Reverse link */
	}
	/* return the new array */
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x50217
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x50217
movq (%rax), %r12
movq %rbx, %rdi
callq 0x2a2b0
testq %rax, %rax
je 0x50217
movq %rax, %r14
leaq 0x10(%r12), %r15
xorl %r13d, %r13d
cmpl 0x2c(%r12), %r13d
jae 0x50230
movq (%r15), %r15
movq %r15, %rdi
callq 0x35e71
testq %rax, %rax
je 0x5020e
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x29c4b
addq $0x48, %r15
incl %r13d
jmp 0x501ea
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x299d3
jmp 0x5021f
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_merge
static int jx9_hashmap_merge(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap, *pSrc;
	jx9_value *pArray;
	int i;
	if( nArg < 1 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation of the hashmap */
	pMap = (jx9_hashmap *)pArray->x.pOther;
	/* Start merging */
	for( i = 0 ; i < nArg ; i++ ){
		/* Make sure we are dealing with a valid hashmap */
		if( !jx9_value_is_json_array(apArg[i]) ){
			/* Insert scalar value */
			jx9_array_add_elem(pArray, 0, apArg[i]);
		}else{
			pSrc = (jx9_hashmap *)apArg[i]->x.pOther;
			/* Merge the two hashmaps */
			HashmapMerge(pSrc, pMap);
		}
	}
	/* Return the freshly created array */
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
testl %esi, %esi
jle 0x50398
movq %rdx, %r15
movl %esi, %ebx
movq %r14, %rdi
callq 0x2a2b0
testq %rax, %rax
je 0x50398
movq %rax, %r13
movq %r14, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl %ebx, %ebx
xorl %r14d, %r14d
movq %r15, -0x50(%rbp)
movq %r13, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
cmpq %rbx, %r14
je 0x503a2
movq (%r15,%r14,8), %rdx
testb $0x40, 0x8(%rdx)
jne 0x502e5
movq %r13, %rdi
xorl %esi, %esi
callq 0x29c4b
jmp 0x50390
movq %r14, -0x58(%rbp)
movq (%rdx), %r14
cmpq -0x30(%rbp), %r14
je 0x50380
leaq 0x10(%r14), %rbx
xorl %r13d, %r13d
movq %r14, -0x60(%rbp)
cmpl 0x2c(%r14), %r13d
jae 0x50380
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x35e71
movq %rax, %r15
cmpl $0x2, 0x8(%rbx)
jne 0x50361
movq -0x30(%rbp), %r14
movq (%r14), %rdi
leaq -0xa0(%rbp), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x3bbfe
movq 0x18(%rbx), %rsi
movl 0x20(%rbx), %edx
movq %r12, %rdi
callq 0x3689a
movq %r14, %rdi
movq -0x60(%rbp), %r14
movq %r12, %rsi
movq %r15, %rdx
callq 0x36999
movl %eax, %r15d
movq %r12, %rdi
callq 0x296af
jmp 0x50372
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x36999
movl %eax, %r15d
testl %r15d, %r15d
jne 0x50380
addq $0x48, %rbx
incl %r13d
jmp 0x50301
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r13
movq -0x40(%rbp), %rbx
movq -0x58(%rbp), %r14
incq %r14
jmp 0x502c3
movq %r14, %rdi
callq 0x298e8
jmp 0x503ae
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x299d3
xorl %eax, %eax
addq $0x78, %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: jx9_hashmap_diff
static int jx9_hashmap_diff(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap_node *pEntry;
	jx9_hashmap *pSrc, *pMap;
	jx9_value *pArray;
	jx9_value *pVal;
	sxi32 rc;
	sxu32 n;
	int i;
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	if( nArg == 1 ){
		/* Return the first array since we cannot perform a diff */
		jx9_result_value(pCtx, apArg[0]);
		return JX9_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation of the source hashmap */
	pSrc = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Perform the diff */
	pEntry = pSrc->pFirst;
	n = pSrc->nEntry;
	for(;;){
		if( n < 1 ){
			break;
		}
		/* Extract the node value */
		pVal = HashmapExtractNodeValue(pEntry);
		if( pVal ){
			for( i = 1 ; i < nArg ; i++ ){
				if( !jx9_value_is_json_array(apArg[i])) {
					/* ignore */
					continue;
				}
				/* Point to the internal representation of the hashmap */
				pMap = (jx9_hashmap *)apArg[i]->x.pOther;
				/* Perform the lookup */
				rc = HashmapFindValue(pMap, pVal, 0, TRUE);
				if( rc == SXRET_OK ){
					/* Value exist */
					break;
				}
			}
			if( i >= nArg ){
				/* Perform the insertion */
				HashmapInsertNode((jx9_hashmap *)pArray->x.pOther, pEntry, TRUE);
			}
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
		n--;
	}
	/* Return the freshly created array */
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x503e6
movq %rdx, %r14
movl %esi, %r15d
movq (%rdx), %rsi
testb $0x40, 0x8(%rsi)
jne 0x503f3
movq %rbx, %rdi
callq 0x298e8
jmp 0x50490
cmpl $0x1, %r15d
jne 0x50401
movq %rbx, %rdi
jmp 0x5048b
movq %rbx, %rdi
callq 0x2a2b0
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x503e6
movq %rbx, -0x40(%rbp)
movq (%r14), %rax
movq (%rax), %rdi
movl 0x2c(%rdi), %ebx
addq $0x10, %rdi
movl %r15d, %r13d
subl $0x1, %ebx
jb 0x50483
movq (%rdi), %rdi
movq %rdi, -0x38(%rbp)
callq 0x35e71
testq %rax, %rax
je 0x50479
movq %rax, %r15
pushq $0x1
popq %r12
cmpq %r12, %r13
je 0x50469
movq (%r14,%r12,8), %rax
testb $0x40, 0x8(%rax)
je 0x50464
movq (%rax), %rdi
movq %r15, %rsi
pushq $0x1
popq %rdx
callq 0x50e4a
testl %eax, %eax
je 0x50479
incq %r12
jmp 0x50443
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x50f1f
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
jmp 0x50426
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x299d3
xorl %eax, %eax
addq $0x18, %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: jx9_hashmap_in_array
static int jx9_hashmap_in_array(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pNeedle;
	int bStrict;
	int rc;
	if( nArg < 2 ){
		/* Missing argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	pNeedle = apArg[0];
	bStrict = 0;
	if( nArg > 2 ){
		bStrict = jx9_value_to_bool(apArg[2]);
	}
	if( !jx9_value_is_json_array(apArg[1]) ){
		/* haystack must be an array, perform a standard comparison */ 
		rc = jx9_value_compare(pNeedle, apArg[1], bStrict);
		/* Set the comparison result */
		jx9_result_bool(pCtx, rc == 0);
		return JX9_OK;
	}
	/* Perform the lookup */
	rc = HashmapFindValue((jx9_hashmap *)apArg[1]->x.pOther, pNeedle, 0, bStrict);
	/* Lookup result */
	jx9_result_bool(pCtx, rc == SXRET_OK);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
xorl %edx, %edx
cmpl $0x2, %esi
jl 0x505ce
movq (%r15), %r14
je 0x505aa
movq 0x10(%r15), %rdi
callq 0x29790
movl %eax, %edx
movq 0x8(%r15), %rsi
testb $0x40, 0x8(%rsi)
jne 0x505be
movq %r14, %rdi
callq 0x2984e
jmp 0x505c9
movq (%rsi), %rdi
movq %r14, %rsi
callq 0x50e4a
testl %eax, %eax
sete %dl
movzbl %dl, %esi
movq %rbx, %rdi
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: jx9_hashmap_copy
static int jx9_hashmap_copy(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	jx9_value *pArray;
	if( nArg < 1 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation of the hashmap */
	pMap = (jx9_hashmap *)pArray->x.pOther;
	if( jx9_value_is_json_array(apArg[0])){
		/* Point to the internal representation of the source */
		jx9_hashmap *pSrc = (jx9_hashmap *)apArg[0]->x.pOther;
		/* Perform the copy */
		jx9HashmapDup(pSrc, pMap);
	}else{
		/* Simple insertion */
		jx9HashmapInsert(pMap, 0/* Automatic index assign*/, apArg[0]); 
	}
	/* Return the duplicated array */
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x50622
movq %rdx, %r15
movq %rbx, %rdi
callq 0x2a2b0
testq %rax, %rax
je 0x50622
movq %rax, %r14
movq (%rax), %rsi
movq (%r15), %rdx
testb $0x40, 0x8(%rdx)
jne 0x5062c
movq %rsi, %rdi
xorl %esi, %esi
callq 0x36999
jmp 0x50634
movq %rbx, %rdi
callq 0x298e8
jmp 0x5063f
movq (%rdx), %rdi
callq 0x3bb43
movq %rbx, %rdi
movq %r14, %rsi
callq 0x299d3
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: jx9_hashmap_erase
static int jx9_hashmap_erase(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	if( nArg < 1 ){
		/* Missing arguments */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Erase */
	jx9HashmapRelease(pMap, FALSE);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x50663
movq (%rdx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x35eb6
jmp 0x5066a
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_map
static int jx9_hashmap_map(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray, *pValue, sKey, sResult;
	jx9_hashmap_node *pEntry;
	jx9_hashmap *pMap;
	sxu32 n;
	if( nArg < 2 || !jx9_value_is_json_array(apArg[1]) ){
		/* Invalid arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[1]->x.pOther;
	jx9MemObjInit(pMap->pVm, &sResult);
	jx9MemObjInit(pMap->pVm, &sKey);
	/* Perform the requested operation */
	pEntry = pMap->pFirst;
	for( n = 0 ; n < pMap->nEntry ; n++ ){
		/* Extrcat the node value */
		pValue = HashmapExtractNodeValue(pEntry);
		if( pValue ){
			sxi32 rc;
			/* Invoke the supplied callback */
			rc = jx9VmCallUserFunction(pMap->pVm, apArg[0], 1, &pValue, &sResult);
			/* Extract the node key */
			jx9HashmapExtractNodeKey(pEntry, &sKey);
			if( rc != SXRET_OK ){
				/* An error occured while invoking the supplied callback [i.e: not defined] */
				jx9_array_add_elem(pArray, &sKey, pValue); /* Keep the same value */
			}else{
				/* Insert the callback return value */
				jx9_array_add_elem(pArray, &sKey, &sResult);
			}
			jx9MemObjRelease(&sKey);
			jx9MemObjRelease(&sResult);
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
	}
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x5078e
movq %rdx, %r14
movq 0x8(%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5078e
movq %rbx, %rdi
callq 0x2a2b0
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x5078e
movq %rbx, -0x40(%rbp)
movq 0x8(%r14), %rax
movq (%rax), %r12
movq (%r12), %rdi
leaq -0x88(%rbp), %rsi
callq 0x35772
movq (%r12), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x35772
leaq 0x10(%r12), %rbx
xorl %r13d, %r13d
cmpl 0x2c(%r12), %r13d
jae 0x507aa
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x35e71
movq %rax, -0x48(%rbp)
testq %rax, %rax
je 0x50782
movq %rax, %r15
movq (%r12), %rdi
movq (%r14), %rsi
pushq $0x1
popq %rdx
leaq -0x48(%rbp), %rcx
leaq -0x88(%rbp), %r8
callq 0x38181
movl %r13d, -0x2c(%rbp)
movq %r12, %r13
movq %r14, %r12
movl %eax, %r14d
movq %rbx, %rdi
leaq -0xc8(%rbp), %rsi
callq 0x35e0a
testl %r14d, %r14d
movq %r12, %r14
movq %r13, %r12
movl -0x2c(%rbp), %r13d
leaq -0x88(%rbp), %rax
cmoveq %rax, %r15
movq -0x38(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
movq %r15, %rdx
callq 0x29c4b
leaq -0xc8(%rbp), %rdi
callq 0x296af
leaq -0x88(%rbp), %rdi
callq 0x296af
addq $0x48, %rbx
incl %r13d
jmp 0x506e7
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x299d3
jmp 0x50796