LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x5b61a
movb (%rdi), %cl
testb %cl, %cl
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
jne 0x5b610
cmpb $0x0, (%rsi)
je 0x5b610
testl %edx, %edx
je 0x5b626
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r8d
leaq -0x1(%r8), %r9
leaq -0x2(%r8), %r10
leaq -0x3(%r8), %r11
xorl %edx, %edx
movq %rsi, %rcx
movq %rdi, %rbx
movb (%rdi,%rdx), %al
testb %al, %al
je 0x5b629
cmpb (%rsi,%rdx), %al
jne 0x5b637
xorl %eax, %eax
cmpl %edx, %r9d
je 0x5b671
leaq 0x1(%rbx), %r14
movb 0x1(%rdi,%rdx), %r15b
testb %r15b, %r15b
je 0x5b63c
cmpb 0x1(%rsi,%rdx), %r15b
jne 0x5b641
cmpl %edx, %r10d
je 0x5b671
leaq 0x2(%rbx), %r14
movb 0x2(%rdi,%rdx), %r15b
testb %r15b, %r15b
je 0x5b64a
cmpb 0x2(%rsi,%rdx), %r15b
jne 0x5b654
cmpl %edx, %r11d
je 0x5b671
leaq 0x3(%rbx), %r14
movb 0x3(%rdi,%rdx), %r15b
testb %r15b, %r15b
je 0x5b65a
cmpb 0x3(%rsi,%rdx), %r15b
jne 0x5b660
addq $0x4, %rbx
addq $0x4, %rcx
addq $0x4, %rdx
cmpl %edx, %r8d
jne 0x5b581
jmp 0x5b671
movl $0x1, %eax
testb %cl, %cl
je 0x5b61a
retq
testq %rsi, %rsi
je 0x5b626
xorl %eax, %eax
cmpb (%rsi), %al
sbbl %eax, %eax
retq
xorl %eax, %eax
retq
addq %rdx, %rsi
addq %rdx, %rdi
movq %rdi, %r14
movq %rsi, %rcx
jmp 0x5b668
movq %rbx, %r14
jmp 0x5b668
incq %rcx
jmp 0x5b668
leaq (%rsi,%rdx), %rcx
incq %rcx
jmp 0x5b668
leaq (%rsi,%rdx), %rcx
addq $0x2, %rcx
jmp 0x5b668
addq $0x2, %rcx
jmp 0x5b668
addq $0x3, %rcx
jmp 0x5b668
leaq (%rsi,%rdx), %rcx
addq $0x3, %rcx
movzbl (%r14), %eax
movzbl (%rcx), %ecx
subl %ecx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5bab4
testb $0x40, 0x8(%r14)
je 0x5bab4
cmpl $0x1f, 0x20(%rbx)
jg 0x5bab4
movl 0x18(%rbx), %edx
testl %edx, %edx
jle 0x5bb16
cmpl $0x0, 0x1c(%rbx)
je 0x5bb06
movl $0x0, 0x1c(%rbx)
jmp 0x5bb16
leaq -0x1c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30b04
cmpl $0x0, (%r15)
jle 0x5bb35
movq %rax, %r14
movl 0x18(%rbx), %edx
testl %edx, %edx
jle 0x5baf2
cmpl $0x0, 0x1c(%rbx)
je 0x5bae2
movl $0x0, 0x1c(%rbx)
jmp 0x5baf2
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
movq 0x8(%rax), %rdi
callq 0x3087c
movq (%rbx), %rax
movl -0x1c(%rbp), %edx
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3087c
jmp 0x5bb35
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
movq 0x8(%rax), %rdi
callq 0x3087c
movl $0x1, 0x1c(%rbx)
incl 0x20(%rbx)
movq (%r14), %rdi
leaq -0xaf(%rip), %rsi       # 0x5ba7b
movq %rbx, %rdx
callq 0x52ab1
decl 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
cmpl %esi, %ecx
seta %al
testl %esi, %esi
sete %dl
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
orb %al, %dl
jne 0x5bbe1
movq %rdi, %r15
movq %r8, -0x30(%rbp)
movl %ecx, %r13d
addq %r12, %r13
movl %esi, %r14d
addq %rdi, %r14
callq 0xc4a0
movq (%rax), %rcx
movsbq (%r12), %rax
movl (%rcx,%rax,4), %edx
incq %r12
leaq 0x1(%r15), %rsi
movq %r15, %rax
movsbq (%rax), %rdi
cmpl %edx, (%rcx,%rdi,4)
jne 0x5bbc4
movq %rsi, %rdi
movq %r12, %r8
cmpq %r13, %r8
jae 0x5bbd1
cmpq %r14, %rdi
jae 0x5bbc4
movsbq (%rdi), %r9
movl (%rcx,%r9,4), %r9d
movsbq (%r8), %r10
incq %r8
incq %rdi
cmpl (%rcx,%r10,4), %r9d
je 0x5bba2
incq %rax
incq %rsi
cmpq %r14, %rax
jb 0x5bb93
jmp 0x5bbe1
xorl %ebx, %ebx
movq -0x30(%rbp), %rcx
testq %rcx, %rcx
je 0x5bbe1
subl %r15d, %eax
movl %eax, (%rcx)
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_O1/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 0x10(%rdi), %r12
movq (%rdi), %rax
movabsq $0x800000000, %rcx      # imm = 0x800000000
movq %rcx, 0x14(%rsi)
xorl %r13d, %r13d
movl %r13d, 0x10(%rsi)
movl %r13d, 0x1c(%rsi)
movq %rax, (%rsi)
movq %r13, 0x8(%rsi)
movq %r13, 0x20(%rsi)
cmpl %r13d, 0x2c(%rdi)
je 0x5cb1c
movq %rdi, %r14
leaq -0x30(%rbp), %r15
movq (%r12), %rax
movq (%rax), %rcx
movl 0x38(%r12), %eax
cmpl %eax, 0x218(%rcx)
jbe 0x5caf8
imull 0x220(%rcx), %eax
addq 0x210(%rcx), %rax
jmp 0x5cafa
xorl %eax, %eax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x5cb0e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x336fc
movq 0x48(%r12), %r12
incl %r13d
cmpl 0x2c(%r14), %r13d
jb 0x5cad4
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_O1/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)
testl %esi, %esi
jle 0x5cbe0
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movslq %esi, %r13
addq %rdi, %r13
movq %rdi, %rbx
xorl %eax, %eax
movsbl (%rbx), %ecx
cmpl %r12d, %ecx
jne 0x5cb68
testl %eax, %eax
je 0x5cb90
xorl %edx, %edx
testl %eax, %eax
sete %dl
cmpl %r14d, %ecx
sete %sil
cmpl %r15d, %ecx
setne %cl
cmovel %edx, %eax
andb %sil, %cl
movzbl %cl, %ecx
addq %rcx, %rbx
incq %rbx
cmpq %r13, %rbx
jb 0x5cb5c
cmpq %rdi, %rbx
jbe 0x5cbc2
movl %ebx, %ecx
subl %edi, %ecx
movsbl (%rdi), %eax
leal -0x2(%rcx), %esi
cmpl %r15d, %eax
cmovnel %ecx, %esi
testl %esi, %esi
jle 0x5cbc2
xorl %ecx, %ecx
cmpl %r15d, %eax
sete %cl
addq %rcx, %rdi
movq -0x30(%rbp), %rdx
callq 0x5cbef
cmpl $-0xa, %eax
je 0x5cbe0
cmpq %r13, %rbx
jae 0x5cbd4
movsbl (%rbx), %eax
cmpl %r12d, %eax
jne 0x5cbd4
incq %rbx
jmp 0x5cbc2
movq %rbx, %rdi
cmpq %r13, %rbx
jb 0x5cb5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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, %rbx
movq %rdi, -0x38(%rbp)
movl %esi, -0x30(%rbp)
testl %esi, %esi
je 0x5cc4e
movl %esi, %r14d
movq %rdi, %r15
movl -0x30(%rbp), %r12d
incq %r15
movsbq -0x1(%r15), %r13
cmpq $-0x41, %r13
ja 0x5cc4a
testb %r13b, %r13b
je 0x5cc3b
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
je 0x5cc4a
movq %r15, -0x38(%rbp)
incq %r15
decl %r14d
movl %r14d, %r12d
jne 0x5cc1b
movl %r12d, -0x30(%rbp)
movl -0x30(%rbp), %r14d
testl %r14d, %r14d
sete %r15b
je 0x5ccc7
movq -0x38(%rbp), %r12
decl %r14d
movb (%r12,%r14), %r13b
cmpb $-0x41, %r13b
ja 0x5cc93
testb %r13b, %r13b
je 0x5cc84
callq 0xc170
movq (%rax), %rax
movsbq %r13b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x5cc93
movl %r14d, -0x30(%rbp)
testl %r14d, %r14d
sete %r15b
jne 0x5cc5f
jmp 0x5ccc7
testb $0x1, %r15b
jne 0x5ccc7
movq 0x10(%rbx), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x45a64
testb $0x40, 0x8(%rbx)
je 0x5ccbe
movq (%rbx), %rdi
leaq -0x78(%rbp), %rdx
xorl %esi, %esi
callq 0x3f924
leaq -0x78(%rbp), %rdi
callq 0x309f2
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_O1/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 (%rdi), %r13
movl $0xffffffee, %r12d      # imm = 0xFFFFFFEE
cmpq %rsi, %r13
setb %bl
jae 0x5d1e6
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movb (%r13), %r14b
cmpb $-0x41, %r14b
ja 0x5d194
callq 0xc170
movq (%rax), %rax
incq %r13
movsbq %r14b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x5d191
cmpq %r15, %r13
je 0x5d1e6
setb %bl
movb (%r13), %r14b
incq %r13
cmpb $-0x41, %r14b
jbe 0x5d171
decq %r13
testb $0x1, %bl
movq -0x30(%rbp), %rcx
je 0x5d1e6
movq %r13, %rbx
cmpq %r15, %r13
jae 0x5d1d1
movq %r13, %rbx
movsbq (%rbx), %r14
cmpq $-0x41, %r14
ja 0x5d1cd
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0x5d1cd
incq %rbx
cmpq %r15, %rbx
jb 0x5d1a8
movq %r15, %rbx
movq -0x30(%rbp), %rcx
movq %r13, (%rcx)
movl %ebx, %eax
subl %r13d, %eax
movl %eax, 0x8(%rcx)
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_O1/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:
movq (%rdi), %r9
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
cmpq %rsi, %r9
setb %r11b
jae 0x5d2ac
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %ecx, %r10d
testl %ecx, %ecx
jle 0x5d244
movb (%r9), %bl
cmpb $-0x41, %bl
ja 0x5d244
xorl %r14d, %r14d
cmpb %bl, (%rdx,%r14)
je 0x5d236
incq %r14
cmpq %r14, %r10
jne 0x5d226
jmp 0x5d244
incq %r9
cmpq %rsi, %r9
setb %r11b
jne 0x5d217
jmp 0x5d2a8
testb $0x1, %r11b
je 0x5d2a8
movq %r9, %rax
cmpq %rsi, %r9
jae 0x5d297
movq %r9, %rax
movb (%rax), %r11b
cmpb $-0x40, %r11b
jb 0x5d27b
incq %rax
movq %rax, %r11
movq %r11, %rax
cmpq %rsi, %r11
jae 0x5d292
movb (%rax), %bl
andb $-0x40, %bl
leaq 0x1(%rax), %r11
negb %bl
jo 0x5d264
jmp 0x5d292
testl %ecx, %ecx
jle 0x5d28f
xorl %ebx, %ebx
cmpb %r11b, (%rdx,%rbx)
je 0x5d297
incq %rbx
cmpq %rbx, %r10
jne 0x5d281
incq %rax
cmpq %rsi, %rax
jb 0x5d255
movq %r9, (%r8)
movl %eax, %ecx
subl %r9d, %ecx
movl %ecx, 0x8(%r8)
movq %rax, (%rdi)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r14
movq %r14, %rsi
callq 0x30b04
movq $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl (%r14), %esi
testl %esi, %esi
jle 0x5d33c
movq %rax, %r15
movq 0x18(%rbx), %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x31892
movq %rax, %r14
testq %rax, %rax
je 0x5d317
movl -0x1c(%rbp), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x34fc5
movq %r14, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x5d337
movq 0x18(%rbx), %rax
movq (%rax), %rsi
movq 0x60(%rax), %rdi
addq $0x8, %rsi
leaq 0x1af98(%rip), %rcx     # 0x782c5
movl $0x1, %edx
callq 0x4153c
testq %r14, %r14
je 0x5d349
movq 0x10(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x336fc
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movl %esi, %r12d
movq %rdi, %r15
movl 0x10(%rdi), %eax
leal (%r12,%rdx), %esi
cmpl %eax, %esi
jae 0x5d395
movq 0x8(%r15), %rcx
movl %esi, %esi
movl %r12d, %edi
movb (%rcx,%rsi), %r8b
movl %edi, %r9d
movb %r8b, (%rcx,%r9)
incl %edi
incq %rsi
cmpl %esi, %eax
ja 0x5d381
subl %edx, 0x10(%r15)
testl %ebx, %ebx
jle 0x5d3f4
movq %r15, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x360ae
testl %eax, %eax
jne 0x5d3f4
movq 0x8(%r15), %rax
movl 0x10(%r15), %ecx
cmpl %r12d, %ecx
je 0x5d3d7
movl %r12d, %edx
subl %ecx, %edx
xorl %esi, %esi
subl $0x1, %ecx
cmovbl %esi, %ecx
movb (%rax,%rcx), %dil
leal (%rcx,%rbx), %r8d
movb %dil, (%rax,%r8)
incl %edx
jne 0x5d3c1
leal 0x1(%rbx), %ecx
movb (%r14), %dl
movl %r12d, %esi
movb %dl, (%rax,%rsi)
incl %r12d
incq %r14
decl %ecx
cmpl $0x1, %ecx
jg 0x5d3da
addl %ebx, 0x10(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x5d474
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 0x30b04
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x5d468
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
leaq -0x24(%rbp), %r8
movq %rax, %rdx
callq *0x8(%r15)
testl %eax, %eax
jne 0x5d468
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30b04
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl (%r15), %r8d
movq %rbx, %rdi
movq %rax, %rcx
callq 0x5d356
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x5e19a
movq %rdx, %r14
movq (%rdx), %rcx
movl 0x8(%rcx), %ecx
testb $0x40, %cl
jne 0x5e1af
xorl %r14d, %r14d
testb $0x20, %cl
sete %r14b
jmp 0x5e1de
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
jmp 0x5e1ed
movl %esi, %eax
xorl %esi, %esi
cmpl $0x1, %eax
je 0x5e1ce
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x3fd5f
xorl %esi, %esi
cmpl $0x1, (%r15)
sete %sil
movq (%r14), %rax
movq (%rax), %rdi
xorl %edx, %edx
callq 0x5f782
movq %rax, %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jle 0x5e221
movq 0x8(%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5e236
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
jmp 0x5e25b
movq (%rax), %rdi
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x44cbb
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
testl %esi, %esi
jle 0x5e2b3
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5e2b3
movq (%rax), %r14
cmpl $0x0, 0x2c(%r14)
je 0x5e2b3
movq 0x18(%r14), %rbx
movq (%rbx), %rax
movq (%rax), %rcx
movl 0x38(%rbx), %eax
cmpl %eax, 0x218(%rcx)
jbe 0x5e2c3
imull 0x220(%rcx), %eax
addq 0x210(%rcx), %rax
jmp 0x5e2c5
movq 0x8(%rdi), %rdi
callq 0x309f2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
movq 0x8(%rdi), %rsi
testq %rax, %rax
je 0x5e2e0
movq %rax, %rdi
callq 0x3ebc8
movq %rbx, %rdi
callq 0x5f830
jmp 0x5e2e8
movq %rsi, %rdi
callq 0x309f2
movq 0x10(%r14), %rax
movq %rax, 0x20(%r14)
jmp 0x5e2bc
// File: /workspace/github_c_makefile_star2_O1/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 0x5e313
movq %rdx, %r14
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5e318
xorl %r14d, %r14d
jmp 0x5e34d
movq (%rax), %r15
cmpl $0x1, %esi
je 0x5e349
movl %esi, %r12d
addq $-0x2, %r12
xorl %r13d, %r13d
movq 0x8(%r14,%r13,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x3f924
testl %eax, %eax
jne 0x5e349
leaq 0x1(%r13), %rax
cmpq %r13, %r12
movq %rax, %r13
jne 0x5e32a
movl 0x2c(%r15), %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
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_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_shift
static int jx9_hashmap_shift(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;
	}
	/* Point to the internal representation of the hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Empty hashmap, return NULL */
		jx9_result_null(pCtx);
	}else{
		jx9_hashmap_node *pEntry = pMap->pFirst;
		jx9_value *pObj;
		sxu32 n;
		pObj = HashmapExtractNodeValue(pEntry);
		if( pObj ){
			/* Node value */
			jx9_result_value(pCtx, pObj);
			/* Unlink the first node */
			jx9HashmapUnlinkNode(pEntry);
		}else{
			jx9_result_null(pCtx);
		}
		/* Rehash all int keys */
		n = pMap->nEntry;
		pEntry = pMap->pFirst;
		pMap->iNextIdx = 0; /* Reset the automatic index */
		for(;;){
			if( n < 1 ){
				break;
			}
			if( pEntry->iType == HASHMAP_INT_NODE ){
				HashmapRehashIntNode(pEntry);
			}
			/* Point to the next entry */
			pEntry = pEntry->pPrev; /* Reverse link */
			n--;
		}
		/* Reset the cursor */
		pMap->pCur = pMap->pFirst;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5e3c1
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5e3c1
movq (%rax), %r14
cmpl $0x0, 0x2c(%r14)
je 0x5e3c1
movq 0x10(%r14), %rbx
movq (%rbx), %rax
movq (%rax), %rcx
movl 0x38(%rbx), %eax
cmpl %eax, 0x218(%rcx)
jbe 0x5e3d7
imull 0x220(%rcx), %eax
addq 0x210(%rcx), %rax
jmp 0x5e3d9
movq 0x8(%rdi), %rdi
callq 0x309f2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
movq 0x8(%rdi), %rsi
testq %rax, %rax
je 0x5e3f4
movq %rax, %rdi
callq 0x3ebc8
movq %rbx, %rdi
callq 0x5f830
jmp 0x5e3fc
movq %rsi, %rdi
callq 0x309f2
movl 0x2c(%r14), %r15d
movq 0x10(%r14), %rbx
movq $0x0, 0x48(%r14)
testl %r15d, %r15d
je 0x5e428
cmpl $0x1, 0x8(%rbx)
jne 0x5e41f
movq %rbx, %rdi
callq 0x5f920
movq 0x48(%rbx), %rbx
decl %r15d
jne 0x5e411
movq 0x10(%r14), %rax
movq %rax, 0x20(%r14)
jmp 0x5e3ca
// File: /workspace/github_c_makefile_star2_O1/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 0x5e90e
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5e90e
movq (%rax), %r15
movq %rbx, %rdi
callq 0x317eb
testq %rax, %rax
je 0x5e90e
movq %rax, %r14
cmpl $0x0, 0x2c(%r15)
je 0x5e900
leaq 0x10(%r15), %r12
xorl %r13d, %r13d
movq (%r12), %r12
movq (%r12), %rax
movq (%rax), %rax
movl 0x38(%r12), %edx
cmpl %edx, 0x218(%rax)
jbe 0x5e8db
imull 0x220(%rax), %edx
addq 0x210(%rax), %rdx
jmp 0x5e8dd
xorl %edx, %edx
testq %rdx, %rdx
je 0x5e8f3
testb $0x40, 0x8(%r14)
je 0x5e8f3
movq (%r14), %rdi
xorl %esi, %esi
callq 0x3f924
addq $0x48, %r12
incl %r13d
cmpl 0x2c(%r15), %r13d
jb 0x5e8b3
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3ebc8
jmp 0x5e917
movq 0x8(%rbx), %rdi
callq 0x309f2
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_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_same
static int jx9_hashmap_same(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *p1, *p2;
	int rc;
	if( nArg < 2 || !jx9_value_is_json_array(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
		/* Missing or invalid arguments, return FALSE*/
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the hashmaps */
	p1 = (jx9_hashmap *)apArg[0]->x.pOther;
	p2 = (jx9_hashmap *)apArg[1]->x.pOther;
	rc = (p1 == p2);
	/* Same instance? */
	jx9_result_bool(pCtx, rc);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %esi
jl 0x5e947
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5e947
movq 0x8(%rdx), %rcx
testb $0x40, 0x8(%rcx)
jne 0x5e96f
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rax), %rax
xorl %r14d, %r14d
cmpq (%rcx), %rax
sete %r14b
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x5e95a
// File: /workspace/github_c_makefile_star2_O1/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 0x5eb29
movq %rdx, %r15
movl %esi, %ebx
movq %r14, %rdi
callq 0x317eb
testq %rax, %rax
je 0x5eb29
movq %rax, %r12
movq %r14, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl %ebx, %ebx
xorl %r14d, %r14d
movq %r15, -0x50(%rbp)
movq %r12, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
movq (%r15,%r14,8), %rdx
testb $0x40, 0x8(%rdx)
jne 0x5ea04
testb $0x40, 0x8(%r12)
je 0x5eb0b
movq (%r12), %rdi
xorl %esi, %esi
callq 0x3f924
jmp 0x5eb0b
movq %r14, -0x58(%rbp)
movq (%rdx), %r14
cmpq -0x30(%rbp), %r14
je 0x5eafb
cmpl $0x0, 0x2c(%r14)
je 0x5eafb
leaq 0x10(%r14), %r13
xorl %r12d, %r12d
movq %r14, -0x60(%rbp)
movq (%r13), %r13
movq (%r13), %rax
movq (%rax), %rax
movl 0x38(%r13), %ebx
cmpl %ebx, 0x218(%rax)
jbe 0x5ea52
imull 0x220(%rax), %ebx
addq 0x210(%rax), %rbx
jmp 0x5ea54
xorl %ebx, %ebx
cmpl $0x2, 0x8(%r13)
jne 0x5ead6
movq -0x30(%rbp), %r15
movq (%r15), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0xa0(%rbp)
movq %rax, -0x90(%rbp)
leaq -0x80(%rbp), %rcx
movups %xmm0, (%rcx)
movq %rax, -0x88(%rbp)
movl $0x0, -0x70(%rbp)
movl $0x1, -0x98(%rbp)
movq 0x18(%r13), %rsi
movl 0x20(%r13), %edx
leaq -0xa0(%rbp), %r14
movq %r14, %rdi
callq 0x3f7f6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3f924
movl %eax, %ebx
movq %r14, %rdi
movq -0x60(%rbp), %r14
callq 0x309f2
jmp 0x5eae6
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3f924
movl %eax, %ebx
testl %ebx, %ebx
jne 0x5eafb
addq $0x48, %r13
incl %r12d
cmpl 0x2c(%r14), %r12d
jb 0x5ea2b
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %rbx
movq -0x58(%rbp), %r14
incq %r14
cmpq %rbx, %r14
jne 0x5e9de
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
callq 0x3ebc8
jmp 0x5eb32
movq 0x8(%r14), %rdi
callq 0x309f2
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_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x5edff
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
jmp 0x5ee68
movq %rdx, %r15
movq (%rdx), %r14
xorl %edx, %edx
cmpl $0x2, %esi
je 0x5ee1c
movq 0x10(%r15), %r12
movq %r12, %rdi
callq 0x446ef
movl (%r12), %edx
movq 0x8(%r15), %rsi
testb $0x40, 0x8(%rsi)
jne 0x5ee3b
testq %r14, %r14
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x5ee48
xorl %r14d, %r14d
jmp 0x5ee59
movq (%rsi), %rdi
movq %r14, %rsi
callq 0x5f9b8
jmp 0x5ee50
movq %r14, %rdi
callq 0x450b0
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5eebd
movq %rdx, %r15
movq %rbx, %rdi
callq 0x317eb
testq %rax, %rax
je 0x5eebd
movq %rax, %r14
movq (%rax), %rsi
movq (%r15), %rdx
testb $0x40, 0x8(%rdx)
jne 0x5eec8
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3f924
jmp 0x5eed0
movq 0x8(%rbx), %rdi
callq 0x309f2
jmp 0x5eedc
movq (%rdx), %rdi
callq 0x45959
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3ebc8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5ef02
movq (%rdx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3eda2
jmp 0x5ef23
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_walk
static int jx9_hashmap_walk(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pValue, *pUserData, sKey;
	jx9_hashmap_node *pEntry;
	jx9_hashmap *pMap;
	sxi32 rc;
	sxu32 n;
	if( nArg < 2 || !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid/Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	pUserData = nArg > 2 ? apArg[2] : 0;
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	jx9MemObjInit(pMap->pVm, &sKey);
	/* Perform the desired operation */
	pEntry = pMap->pFirst;
	for( n = 0 ; n < pMap->nEntry ; n++ ){
		/* Extract the node value */
		pValue = HashmapExtractNodeValue(pEntry);
		if( pValue ){
			/* Extract the entry key */
			jx9HashmapExtractNodeKey(pEntry, &sKey);
			/* Invoke the supplied callback */
			rc = jx9VmCallUserFunctionAp(pMap->pVm, apArg[1], 0, pValue, &sKey, pUserData, 0);
			jx9MemObjRelease(&sKey);
			if( rc != SXRET_OK ){
				/* An error occured while invoking the supplied callback [i.e: not defined] */
				jx9_result_bool(pCtx, 0); /* return FALSE */
				return JX9_OK;
			}
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
	}
	/* All done, return TRUE */
	jx9_result_bool(pCtx, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpl $0x2, %esi
jl 0x5f118
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5f149
xorl %r14d, %r14d
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %esi
jne 0x5f158
movq $0x0, -0x38(%rbp)
jmp 0x5f160
movq 0x10(%rdx), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %r15
movq (%r15), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x60(%rbp)
movq %rax, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x20, -0x78(%rbp)
movl $0x1, %r14d
cmpl $0x0, 0x2c(%r15)
je 0x5f11b
movq %rdx, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
leaq 0x10(%r15), %r12
leaq -0x80(%rbp), %r13
xorl %r14d, %r14d
movq (%r12), %r12
movq (%r12), %rax
movq (%rax), %rax
movl 0x38(%r12), %ebx
cmpl %ebx, 0x218(%rax)
jbe 0x5f1db
imull 0x220(%rax), %ebx
addq 0x210(%rax), %rbx
jmp 0x5f1dd
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x5f21e
movq %r12, %rdi
movq %r13, %rsi
callq 0x3ed27
movq (%r15), %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x0, (%rsp)
movq %rbx, %rcx
movq %r13, %r8
movq -0x38(%rbp), %r9
xorl %eax, %eax
callq 0x5fb45
movl %eax, %ebx
movq %r13, %rdi
callq 0x309f2
testl %ebx, %ebx
jne 0x5f23a
addq $0x48, %r12
incl %r14d
cmpl 0x2c(%r15), %r14d
jb 0x5f1b3
movq -0x30(%rbp), %rdi
movl $0x1, %r14d
jmp 0x5f11b
xorl %r14d, %r14d
movq -0x30(%rbp), %rdi
jmp 0x5f11b
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_sort
static int jx9_hashmap_sort(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	/* Make sure we are dealing with a valid hashmap */
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry > 1 ){
		sxi32 iCmpFlags = 0;
		if( nArg > 1 ){
			/* Extract comparison flags */
			iCmpFlags = jx9_value_to_int(apArg[1]);
			if( iCmpFlags == 3 /* SORT_REGULAR */ ){
				iCmpFlags = 0; /* Standard comparison */
			}
		}
		/* Do the merge sort */
		HashmapMergeSort(pMap, HashmapCmpCallback1, SX_INT_TO_PTR(iCmpFlags));
		/* Rehash [Do not maintain index association as requested by the JX9 specification] */
		HashmapSortRehash(pMap);
	}
	/* All done, return TRUE */
	jx9_result_bool(pCtx, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x5f261
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5f28c
xorl %r12d, %r12d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r12, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %r14
movl $0x1, %r12d
cmpl $0x2, 0x2c(%r14)
jb 0x5f264
cmpl $0x1, %esi
jne 0x5f2a5
xorl %edx, %edx
jmp 0x5f2c0
movq 0x8(%rdx), %r15
movq %r15, %rdi
callq 0x3fd5f
movl (%r15), %eax
xorl %edx, %edx
cmpq $0x3, %rax
cltq
cmovneq %rax, %rdx
leaq 0xab1(%rip), %rsi       # 0x5fd78
movq %r14, %rdi
callq 0x5fc74
movq %r14, %rdi
callq 0x5fe9c
jmp 0x5f264
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_usort
static int jx9_hashmap_usort(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	/* Make sure we are dealing with a valid hashmap */
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry > 1 ){
		jx9_value *pCallback = 0;
		ProcNodeCmp xCmp;
		xCmp = HashmapCmpCallback4; /* User-defined function as the comparison callback */
		if( nArg > 1 && jx9_value_is_callable(apArg[1]) ){
			/* Point to the desired callback */
			pCallback = apArg[1];
		}else{
			/* Use the default comparison function */
			xCmp = HashmapCmpCallback1;
		}
		/* Do the merge sort */
		HashmapMergeSort(pMap, xCmp, pCallback);
		/* Rehash [Do not maintain index association as requested by the JX9 specification] */
		HashmapSortRehash(pMap);
	}
	/* All done, return TRUE */
	jx9_result_bool(pCtx, 1);
	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 0x5f38d
movq %rdx, %r12
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5f3be
xorl %r13d, %r13d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r13, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %r14
movl $0x1, %r13d
cmpl $0x2, 0x2c(%r14)
jb 0x5f390
leaq 0x9a3(%rip), %r15       # 0x5fd78
cmpl $0x1, %esi
je 0x5f3fa
movq 0x8(%r12), %rsi
movq 0x10(%rsi), %rdi
callq 0x52930
testl %eax, %eax
je 0x5f3fa
movq 0x8(%r12), %rdx
leaq 0xce9(%rip), %r15       # 0x600e1
jmp 0x5f3fc
xorl %edx, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5fc74
movq %r14, %rdi
callq 0x5fe9c
jmp 0x5f390