LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_b64.c
// Function: cf_b64_decode
void
cf_b64_decode(const char* in, uint32_t in_len, uint8_t* out, uint32_t* out_size)
{
	uint32_t i = 0;
	uint32_t j = 0;

	while (i < in_len) {
		uint8_t i0 = (uint8_t)in[i];
		uint8_t i1 = (uint8_t)in[i + 1];
		uint8_t i2 = (uint8_t)in[i + 2];
		uint8_t i3 = (uint8_t)in[i + 3];

		out[j]     = (DA[i0] << 2) | (DA[i1] >> 4);
		out[j + 1] = (DA[i1] << 4) | (DA[i2] >> 2);
		out[j + 2] = (DA[i2] << 6) |  DA[i3];

		i += 4;
		j += 3;
	}

	if (out_size) {
		if (i != 0) {
			if (in[i - 1] == '=') {
				j--;
			}

			if (in[i - 2] == '=') {
				j--;
			}
		}

		*out_size = j;
	}
}

// Assembly:
testl %esi, %esi
je 0x1407f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
leaq 0x56cb(%rip), %r9       # 0x196a0
movl %r8d, %r10d
leal 0x2(%r10), %r8d
leal 0x5(%r10), %r15d
movzbl (%rdi,%r8), %r11d
leal 0x3(%r10), %r8d
movzbl (%rdi,%r15), %r15d
movzbl (%rdi,%r8), %ebx
leal 0x4(%r10), %r8d
addl $0x6, %r10d
movzbl (%rdi,%r8), %r14d
movb (%r11,%r9), %r11b
movb (%rbx,%r9), %bl
shlb $0x2, %r11b
movl %ebx, %ebp
shlb $0x4, %bl
shrb $0x4, %bpl
orb %r11b, %bpl
movl %eax, %r11d
movb %bpl, (%rdx,%r11)
movb (%r14,%r9), %r11b
movl %r11d, %ebp
shlb $0x6, %r11b
shrb $0x2, %bpl
orb %bl, %bpl
leal 0x1(%rax), %ebx
movb %bpl, (%rdx,%rbx)
leal 0x2(%rax), %ebx
addl $0x3, %eax
orb (%r15,%r9), %r11b
cmpl %esi, %r10d
movb %r11b, (%rdx,%rbx)
jb 0x13fd5
testq %rcx, %rcx
popq %rbx
popq %r14
popq %r15
popq %rbp
je 0x14088
cmpl $-0x2, %r8d
je 0x14086
leal 0x1(%r8), %edx
xorl %esi, %esi
cmpb $0x3d, (%rdi,%rdx)
movl %r8d, %edx
sete %sil
xorl %r8d, %r8d
cmpb $0x3d, (%rdi,%rdx)
sete %r8b
addl %r8d, %esi
subl %esi, %eax
jmp 0x14086
xorl %eax, %eax
testq %rcx, %rcx
je 0x14088
movl %eax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_b64.c
// Function: cf_b64_decode_in_place
void
cf_b64_decode_in_place(uint8_t* in_out, uint32_t in_len, uint32_t* out_size)
{
	uint32_t i = 0;
	uint32_t j = 0;

	uint32_t d = 0;

	if (out_size && in_len != 0) {
		if (in_out[in_len - 1] == '=') {
			d++;
		}

		if (in_out[in_len - 2] == '=') {
			d++;
		}
	}

	while (i < in_len) {
		uint8_t i0 = in_out[i];
		uint8_t i1 = in_out[i + 1];
		uint8_t i2 = in_out[i + 2];
		uint8_t i3 = in_out[i + 3];

		uint8_t b0 = (DA[i0] << 2) | (DA[i1] >> 4);
		uint8_t b1 = (DA[i1] << 4) | (DA[i2] >> 2);
		uint8_t b2 = (DA[i2] << 6) |  DA[i3];

		in_out[j]     = b0;
		in_out[j + 1] = b1;
		in_out[j + 2] = b2;

		i += 4;
		j += 3;
	}

	if (out_size) {
		*out_size = j - d;
	}
}

// Assembly:
testq %rdx, %rdx
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
jne 0x140b8
leal -0x1(%rsi), %ecx
xorl %eax, %eax
leal -0x2(%rsi), %r8d
cmpb $0x3d, (%rdi,%rcx)
sete %al
movl %eax, %ecx
notl %eax
negl %ecx
cmpb $0x3d, (%rdi,%r8)
cmovnel %ecx, %eax
jmp 0x140c7
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
je 0x1414f
pushq %rbp
pushq %r14
pushq %rbx
xorl %r8d, %r8d
leaq 0x55cb(%rip), %r9       # 0x196a0
xorl %ecx, %ecx
leal 0x1(%r8), %r11d
movl %r8d, %r10d
leal 0x2(%r8), %ebx
leal 0x3(%r8), %r14d
addl $0x4, %r8d
movzbl (%rdi,%r11), %r11d
movzbl (%rdi,%r10), %r10d
movzbl (%rdi,%rbx), %ebx
movzbl (%rdi,%r14), %r14d
movb (%r11,%r9), %r11b
movb (%r10,%r9), %r10b
movl %r11d, %ebp
shlb $0x2, %r10b
shlb $0x4, %r11b
shrb $0x4, %bpl
orb %r10b, %bpl
movb (%rbx,%r9), %r10b
movl %r10d, %ebx
shlb $0x6, %r10b
shrb $0x2, %bl
orb (%r14,%r9), %r10b
orb %r11b, %bl
movl %ecx, %r11d
movb %bpl, (%rdi,%r11)
leal 0x1(%rcx), %r11d
movb %bl, (%rdi,%r11)
leal 0x2(%rcx), %r11d
addl $0x3, %ecx
cmpl %esi, %r8d
movb %r10b, (%rdi,%r11)
jb 0x140d7
popq %rbx
popq %r14
popq %rbp
testq %rdx, %rdx
je 0x14158
addl %eax, %ecx
movl %ecx, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_b64.c
// Function: is_valid_encoded
static bool
is_valid_encoded(const char* in, uint32_t in_len)
{
	if (! in || in_len == 0 || (in_len & 3) != 0) {
		return false;
	}

	const uint8_t* end = (const uint8_t*)in + in_len - 2;
	const uint8_t* read = (const uint8_t*)in;

	while (read < end) {
		if (! VA[*read++]) {
			return false;
		}
	}

	if (*read == '=') {
		return *(read + 1) == '=';
	}

	if (! VA[*read++]) {
		return false;
	}

	return *read == '=' || VA[*read];
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
testb $0x3, %sil
setne %al
orb %cl, %al
jne 0x141f4
movl %esi, %eax
leaq 0x55eb(%rip), %rcx      # 0x197a0
leaq -0x2(%rdi,%rax), %rax
cmpq %rax, %rdi
jae 0x141cd
movzbl (%rdi), %edx
incq %rdi
cmpb $0x0, (%rdx,%rcx)
jne 0x141ba
jmp 0x141f4
movzbl (%rdi), %eax
cmpq $0x3d, %rax
jne 0x141de
cmpb $0x3d, 0x1(%rdi)
sete %al
retq
cmpb $0x1, (%rax,%rcx)
jne 0x141f4
movzbl 0x1(%rdi), %edx
movb $0x1, %al
cmpq $0x3d, %rdx
je 0x141dd
movb (%rdx,%rcx), %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_crypto.c
// Function: cf_RIPEMD160
int
cf_RIPEMD160(const unsigned char* input, size_t ilen, unsigned char* output)
{
	int ret;
	cf_RIPEMD160_CTX ctx;

	if ((ret = cf_RIPEMD160_Init(&ctx)) != 0) {
		return ret;
	}

	if ((ret = cf_RIPEMD160_Update(&ctx, input, ilen)) != 0) {
		return ret;
	}

	if ((ret = cf_RIPEMD160_Final(output, &ctx)) != 0) {
		return ret;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movaps 0x53e8(%rip), %xmm1     # 0x198a0
movq %rsp, %r14
xorps %xmm0, %xmm0
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
movq %r14, %rdi
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movl $0x0, 0x58(%r14)
movq $0x0, 0x50(%r14)
movups %xmm1, 0x8(%r14)
movl $0xc3d2e1f0, 0x18(%r14) # imm = 0xC3D2E1F0
callq 0x8440
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85a0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_crypto.c
// Function: cf_RIPEMD160_Update
int
cf_RIPEMD160_Update(cf_RIPEMD160_CTX* ctx, const void* v_input, size_t ilen)
{
	const unsigned char* input = (const unsigned char*)v_input;

	int ret;

	if (ilen == 0) {
		return 0;
	}

	size_t left = ctx->total[0] & 0x3F;
	uint32_t fill = (uint32_t)(64 - left);

	ctx->total[0] += (uint32_t) ilen;
	ctx->total[0] &= 0xFFFFFFFF;

	if (ctx->total[0] < (uint32_t) ilen) {
		ctx->total[1]++;
	}

	if (left && ilen >= fill) {
		memcpy((void*)(ctx->buffer + left), input, fill);

		if ((ret = cf_ripemd160_process(ctx, ctx->buffer)) != 0) {
			return ret;
		}

		input += fill;
		ilen  -= fill;
		left = 0;
	}

	while (ilen >= 64) {
		if ((ret = cf_ripemd160_process(ctx, input)) != 0) {
			return ret;
		}

		input += 64;
		ilen  -= 64;
	}

	if (ilen > 0) {
		memcpy((void*)(ctx->buffer + left), input, ilen);
	}

	return 0;
}

// Assembly:
testq %rdx, %rdx
je 0x145e6
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rdi), %ecx
movq %rsi, %rbx
movl %edx, %esi
movq %rdi, %r14
movl %ecx, %eax
andl $0x3f, %eax
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x14565
incl 0x4(%r14)
testl %eax, %eax
je 0x14580
movl $0x40, %ecx
movq %rdx, %r15
subl %eax, %ecx
movl %ecx, %r12d
subq %r12, %r15
jae 0x14585
movq %rdx, %r15
jmp 0x145cd
movq %rdx, %r15
jmp 0x145a7
leaq 0x1c(%r14,%rax), %rdi
movq %rbx, %rsi
movq %r12, %rdx
leaq 0x1c(%r14), %r13
callq 0x85c0
movq %r14, %rdi
movq %r13, %rsi
callq 0x1470c
addq %r12, %rbx
cmpq $0x40, %r15
jb 0x145c6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1470c
addq $-0x40, %r15
addq $0x40, %rbx
cmpq $0x3f, %r15
ja 0x145ad
testq %r15, %r15
je 0x145dd
xorl %eax, %eax
leaq 0x1c(%r14,%rax), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x85c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_crypto.c
// Function: cf_RIPEMD160_Final
int
cf_RIPEMD160_Final(unsigned char* output, cf_RIPEMD160_CTX* ctx)
{
	uint32_t high = (ctx->total[0] >> 29) | (ctx->total[1] <<  3);
	uint32_t low  = (ctx->total[0] <<  3);

	unsigned char msglen[8];

	PUT_UINT32_LE(low,  msglen, 0);
	PUT_UINT32_LE(high, msglen, 4);

	uint32_t last = ctx->total[0] & 0x3F;
	uint32_t padn = (last < 56) ? (56 - last) : (120 - last);

	int ret = cf_RIPEMD160_Update(ctx, cf_ripemd160_padding, padn);

	if (ret != 0) {
		return ret;
	}

	ret = cf_RIPEMD160_Update(ctx, msglen, 8);

	if (ret != 0) {
		return ret;
	}

	PUT_UINT32_LE(ctx->state[0], output,  0);
	PUT_UINT32_LE(ctx->state[1], output,  4);
	PUT_UINT32_LE(ctx->state[2], output,  8);
	PUT_UINT32_LE(ctx->state[3], output, 12);
	PUT_UINT32_LE(ctx->state[4], output, 16);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl (%rsi), %eax
leaq 0x8(%rsp), %r15
movl 0x4(%rsi), %ecx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x52e7(%rip), %rsi      # 0x198f0
movq %r14, %rdi
leal (,%rax,8), %edx
shldl $0x3, %eax, %ecx
movb %dl, (%r15)
movl %eax, %edx
shrl $0x5, %edx
movb %dl, 0x1(%r15)
movl %eax, %edx
shrl $0xd, %edx
movb %dl, 0x2(%r15)
movl %eax, %edx
andl $0x3f, %eax
shrl $0x15, %edx
movb %dl, 0x3(%r15)
movl %ecx, %edx
movb %cl, 0x4(%r15)
movb %ch, 0xd(%rsp)
shrl $0x18, %ecx
shrl $0x10, %edx
movb %dl, 0x6(%r15)
xorl %edx, %edx
cmpl $0x38, %eax
movb %cl, 0x7(%r15)
setae %dl
shll $0x6, %edx
orl $0x38, %edx
subl %eax, %edx
callq 0x8440
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8440
movb 0x8(%r14), %al
movb %al, (%rbx)
movb 0x9(%r14), %al
movb %al, 0x1(%rbx)
movb 0xa(%r14), %al
movb %al, 0x2(%rbx)
movb 0xb(%r14), %al
movb %al, 0x3(%rbx)
movb 0xc(%r14), %al
movb %al, 0x4(%rbx)
movb 0xd(%r14), %al
movb %al, 0x5(%rbx)
movb 0xe(%r14), %al
movb %al, 0x6(%rbx)
movb 0xf(%r14), %al
movb %al, 0x7(%rbx)
movb 0x10(%r14), %al
movb %al, 0x8(%rbx)
movb 0x11(%r14), %al
movb %al, 0x9(%rbx)
movb 0x12(%r14), %al
movb %al, 0xa(%rbx)
movb 0x13(%r14), %al
movb %al, 0xb(%rbx)
movb 0x14(%r14), %al
movb %al, 0xc(%rbx)
movb 0x15(%r14), %al
movb %al, 0xd(%rbx)
movb 0x16(%r14), %al
movb %al, 0xe(%rbx)
movb 0x17(%r14), %al
movb %al, 0xf(%rbx)
movb 0x18(%r14), %al
movb %al, 0x10(%rbx)
movb 0x19(%r14), %al
movb %al, 0x11(%rbx)
movb 0x1a(%r14), %al
movb %al, 0x12(%rbx)
movb 0x1b(%r14), %al
movb %al, 0x13(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_size
uint32_t cf_ll_size(cf_ll *ll) {
	LL_LOCK(ll);
	uint32_t sz = ll->sz;
	LL_UNLOCK(ll);
	return(sz);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb 0x1c(%rdi), %al
movq %rdi, %rbx
cmpb $0x1, %al
jne 0x16335
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movb 0x1c(%rbx), %al
movl 0x18(%rbx), %ebp
testb $0x1, %al
je 0x16348
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_search_lockfree
cf_ll_element * cf_ll_search_lockfree(cf_ll *ll, cf_ll_element *e, bool forward, cf_ll_reduce_fn fn) {
	if (ll->head == NULL) {
		return NULL;
	}
	int rv = 0;
	cf_ll_element *cur = forward ? ll->head : ll->tail;
	
	while (cur) {
		rv = (*fn) (cur, (void*)e);

		if (rv == CF_LL_REDUCE_MATCHED) {
			return cur;
		}
		else if (rv == CF_LL_REDUCE_NOT_MATCHED) {
			cur = forward ? cur->next : cur->prev;
			rv = 0;
		}
		else {
			return NULL;
		}
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x1637c
movq %rcx, %r14
movq %rsi, %r15
testb %dl, %dl
je 0x16370
xorl %r12d, %r12d
jmp 0x1638d
movq 0x8(%rdi), %rbx
movl $0x8, %r12d
jmp 0x1639f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r15, %rsi
callq *%r14
cmpl $0x4, %eax
jne 0x163a6
movq (%rbx,%r12), %rbx
testq %rbx, %rbx
jne 0x1638d
jmp 0x1637c
cmpl $0x3, %eax
jne 0x1637c
jmp 0x1637e
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_search
cf_ll_element * cf_ll_search(cf_ll *ll, cf_ll_element *e, bool forward, cf_ll_reduce_fn fn) 
{
	LL_LOCK(ll);
	
	cf_ll_element * ele = NULL;
	ele = cf_ll_search_lockfree(ll, e, forward, fn);

	LL_UNLOCK(ll);

	return ele;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x1c(%rdi)
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
jne 0x163d2
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movq (%rbx), %r14
testq %r14, %r14
je 0x163f0
testb %bpl, %bpl
je 0x163e4
xorl %r13d, %r13d
jmp 0x16417
movq 0x8(%rbx), %r14
movl $0x8, %r13d
jmp 0x16429
xorl %r14d, %r14d
cmpb $0x1, 0x1c(%rbx)
jne 0x16405
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r12, %rsi
callq *%r15
cmpl $0x4, %eax
jne 0x16430
movq (%r14,%r13), %r14
testq %r14, %r14
jne 0x16417
jmp 0x163f0
cmpl $0x3, %eax
jne 0x163f0
jmp 0x163f3
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_getIterator
cf_ll_iterator * cf_ll_getIterator(cf_ll * ll, bool forward)
{
	cf_ll_iterator *iter = NULL;
	iter = (cf_ll_iterator *)cf_malloc(sizeof(cf_ll_iterator));
	if (iter == NULL) {
		return NULL;
	}
	iter->forward = forward;
	iter->next = iter->forward ? ll->head : ll->tail;
	return iter;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
movl %esi, %ebp
callq 0x8080
testq %rax, %rax
je 0x16461
movb %bpl, 0x8(%rax)
xorb $0x1, %bpl
movzbl %bpl, %ecx
movq (%rbx,%rcx,8), %rcx
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_getNext
cf_ll_element * cf_ll_getNext(cf_ll_iterator *iter)
{
	if (!iter) return NULL;
	cf_ll_element * ele = iter->next;
	if (ele != NULL) {
		iter->next = iter->forward ? ele->next : ele->prev;
	}
	return ele;
}

// Assembly:
testq %rdi, %rdi
je 0x1648e
movq (%rdi), %rax
testq %rax, %rax
je 0x1648e
movzbl 0x8(%rdi), %ecx
xorl $0x1, %ecx
movq (%rax,%rcx,8), %rcx
movq %rcx, (%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_index
cf_ll_element *cf_ll_index(cf_ll *ll, int index)
{
	cf_ll_element *ele = NULL;
	if (index < 0) {
		index = (-index) - 1;
		ele = ll->tail;
		while (index-- && ele) {
			ele = ele->prev;
		}
	}
	else {
		ele = ll->head;
		while (index-- && ele) {
			ele = ele->next;
		}
	}
	return ele;
}

// Assembly:
movq %rdi, %rax
testl %esi, %esi
js 0x164a7
movq (%rax), %rax
addl $-0x1, %esi
jae 0x164b8
testq %rax, %rax
jne 0x16498
jmp 0x164b8
incl %esi
movq 0x8(%rax), %rax
testl %esi, %esi
je 0x164b8
incl %esi
testq %rax, %rax
jne 0x164a9
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_init
int  cf_ll_init(cf_ll *ll, cf_ll_destructor destroy_fn, bool uselock) {
	ll->head = 0;
	ll->tail = 0;
	ll->destroy_fn = destroy_fn;
	ll->sz = 0;
	ll->uselock = uselock;
	if (uselock) {
		pthread_mutex_init(&ll->LOCK, 0);
	}
	return(0);	
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
movq %rax, 0x8(%rdi)
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
movb %dl, 0x1c(%rdi)
je 0x164e4
pushq %rax
addq $0x20, %rdi
xorl %esi, %esi
callq 0x8a90
addq $0x8, %rsp
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_init
bool
cf_queue_init(cf_queue *q, size_t element_sz, uint32_t capacity,
		bool threadsafe)
{
	q->alloc_sz = capacity;
	q->write_offset = q->read_offset = 0;
	q->n_eles = 0;
	q->element_sz = element_sz;
	q->threadsafe = threadsafe;
	q->free_struct = false;

	q->elements = (uint8_t*)cf_malloc(capacity * element_sz);

	if (! q->elements) {
		return false;
	}

	if (! q->threadsafe) {
		return true;
	}

	if (0 != pthread_mutex_init(&q->LOCK, NULL)) {
		cf_free(q->elements);
		return false;
	}

	if (0 != pthread_cond_init(&q->CV, NULL)) {
		pthread_mutex_destroy(&q->LOCK);
		cf_free(q->elements);
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, 0x4(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movb %cl, (%rdi)
movq %rdi, %rbx
movb $0x0, 0x1(%rdi)
movl %edx, %edi
imulq %rsi, %rdi
callq 0x8080
testq %rax, %rax
movq %rax, 0x78(%rbx)
je 0x16559
cmpb $0x1, (%rbx)
movb $0x1, %bpl
jne 0x1655b
leaq 0x20(%rbx), %r14
xorl %esi, %esi
movq %r14, %rdi
callq 0x8a90
testl %eax, %eax
jne 0x16550
leaq 0x48(%rbx), %rdi
xorl %esi, %esi
callq 0x85f0
testl %eax, %eax
je 0x1655b
movq %r14, %rdi
callq 0x82f0
movq 0x78(%rbx), %rdi
callq 0x8940
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_create
cf_queue *
cf_queue_create(size_t element_sz, bool threadsafe)
{
	cf_queue *q = (cf_queue*)cf_malloc(sizeof(cf_queue));

	if (! q) {
		return NULL;
	}

	if (! cf_queue_init(q, element_sz, CF_QUEUE_ALLOCSZ, threadsafe)) {
		cf_free(q);
		return NULL;
	}

	q->free_struct = true;

	return q;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x80, %edi
movl %esi, %ebp
callq 0x8080
testq %rax, %rax
je 0x165a3
movzbl %bpl, %ecx
movq %rax, %rdi
movq %r14, %rsi
movl $0x40, %edx
movq %rax, %rbx
callq 0x8ae0
testb %al, %al
je 0x1659b
movb $0x1, 0x1(%rbx)
jmp 0x165a5
movq %rbx, %rdi
callq 0x8940
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_destroy
void
cf_queue_destroy(cf_queue *q)
{
	if (q->threadsafe) {
		pthread_cond_destroy(&q->CV);
		pthread_mutex_destroy(&q->LOCK);
	}

	cf_free(q->elements);

	if (q->free_struct) {
		memset(q, 0, sizeof(cf_queue));
		cf_free(q);
	}
}

// Assembly:
pushq %rbx
cmpb $0x1, (%rdi)
movq %rdi, %rbx
jne 0x165c8
leaq 0x48(%rbx), %rdi
callq 0x8900
leaq 0x20(%rbx), %rdi
callq 0x82f0
movq 0x78(%rbx), %rdi
callq 0x8940
cmpb $0x1, 0x1(%rbx)
jne 0x165ed
movl $0x10, %ecx
xorl %eax, %eax
movq %rbx, %rdi
rep  stosq %rax, %es:(%rdi)
movq %rbx, %rdi
popq %rbx
jmp 0x8940
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_push
int
cf_queue_push(cf_queue *q, const void *ptr)
{
	cf_queue_lock(q);

	// Check queue length.
	if (CF_Q_SZ(q) == q->alloc_sz) {
		if (0 != cf_queue_resize(q, q->alloc_sz * 2)) {
			cf_queue_unlock(q);
			return CF_QUEUE_ERR;
		}
	}

	// TODO - if queues are power of 2, this can be a shift.
	memcpy(CF_Q_ELEM_PTR(q, q->write_offset), ptr, q->element_sz);
	q->write_offset++;
	q->n_eles++;
	cf_queue_unwrap(q);

	if (q->threadsafe) {
		pthread_cond_signal(&q->CV);
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, (%rdi)
movq %rsi, %r14
movq %rdi, %rbx
jne 0x16607
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movl 0xc(%rbx), %eax
movl 0x4(%rbx), %ecx
movl %eax, %esi
subl 0x8(%rbx), %esi
cmpl %ecx, %esi
jne 0x16636
addl %esi, %esi
movq %rbx, %rdi
callq 0x166aa
testl %eax, %eax
je 0x16630
cmpb $0x0, (%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jne 0x16697
jmp 0x166a3
movl 0x4(%rbx), %ecx
movl 0xc(%rbx), %eax
xorl %edx, %edx
movq %r14, %rsi
divl %ecx
movl %edx, %edi
movq 0x18(%rbx), %rdx
imulq %rdx, %rdi
addq 0x78(%rbx), %rdi
callq 0x85c0
movq 0xc(%rbx), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movd %xmm0, %ecx
movq %xmm0, 0xc(%rbx)
cmpl $0x40000000, %ecx       # imm = 0x40000000
jb 0x16680
movl 0x8(%rbx), %eax
xorl %edx, %edx
subl %eax, %ecx
divl 0x4(%rbx)
addl %edx, %ecx
movl %edx, 0x8(%rbx)
movl %ecx, 0xc(%rbx)
movb (%rbx), %al
cmpb $0x1, %al
jne 0x16691
leaq 0x48(%rbx), %rdi
callq 0x84e0
movb (%rbx), %al
xorl %ebp, %ebp
testb $0x1, %al
je 0x166a3
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_resize
static int
cf_queue_resize(cf_queue *q, uint32_t new_sz)
{
	// The rare case where the queue is not fragmented, and realloc makes sense
	// and none of the offsets need to move.
	if (0 == q->read_offset % q->alloc_sz) {
		q->elements = (uint8_t*)cf_realloc(q->elements, new_sz * q->element_sz);

		if (! q->elements) {
			return CF_QUEUE_ERR;
		}

		q->read_offset = 0;
		q->write_offset = q->alloc_sz;
	}
	else {
		uint8_t *newq = (uint8_t*)cf_malloc(new_sz * q->element_sz);

		if (! newq) {
			return CF_QUEUE_ERR;
		}

		// end_sz is used bytes in old queue from insert point to end.
		size_t end_sz =
				(q->alloc_sz - (q->read_offset % q->alloc_sz)) * q->element_sz;

		memcpy(&newq[0], CF_Q_ELEM_PTR(q, q->read_offset), end_sz);
		memcpy(&newq[end_sz], &q->elements[0],
				(q->alloc_sz * q->element_sz) - end_sz);

		cf_free(q->elements);
		q->elements = newq;

		q->write_offset = q->alloc_sz;
		q->read_offset = 0;
	}

	q->alloc_sz = new_sz;

	return CF_QUEUE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
xorl %edx, %edx
movl %esi, %ebx
movq %rdi, %r14
divl 0x4(%rdi)
testl %edx, %edx
je 0x16740
movl %ebx, %edi
imulq 0x18(%r14), %rdi
callq 0x8080
testq %rax, %rax
je 0x16771
movq %rax, %r15
movl 0x4(%r14), %r12d
movl 0x8(%r14), %eax
xorl %edx, %edx
movq %r15, %rdi
divl %r12d
movq 0x18(%r14), %rsi
subl %edx, %r12d
imulq %rsi, %r12
imulq %rdx, %rsi
addq 0x78(%r14), %rsi
movq %r12, %rdx
callq 0x85c0
movl 0x4(%r14), %edx
movq 0x78(%r14), %rsi
movq %r15, %rdi
addq %r12, %rdi
imulq 0x18(%r14), %rdx
subq %r12, %rdx
callq 0x85c0
movq 0x78(%r14), %rdi
callq 0x8940
movq %r15, 0x78(%r14)
movl 0x4(%r14), %eax
movl %eax, 0xc(%r14)
movl $0x0, 0x8(%r14)
jmp 0x16769
movl %ebx, %esi
movq 0x78(%r14), %rdi
imulq 0x18(%r14), %rsi
callq 0x8510
testq %rax, %rax
movq %rax, 0x78(%r14)
je 0x16771
movl $0x0, 0x8(%r14)
movl 0x4(%r14), %eax
movl %eax, 0xc(%r14)
xorl %eax, %eax
movl %ebx, 0x4(%r14)
jmp 0x16776
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_push_limit
bool
cf_queue_push_limit(cf_queue *q, const void *ptr, uint32_t limit)
{
	cf_queue_lock(q);

	uint32_t size = CF_Q_SZ(q);

	if (size >= limit) {
		cf_queue_unlock(q);
		return false;
	}

	if (size == q->alloc_sz) {
		if (0 != cf_queue_resize(q, q->alloc_sz * 2)) {
			cf_queue_unlock(q);
			return false;
		}
	}

	// TODO - if queues are power of 2, this can be a shift.
	memcpy(CF_Q_ELEM_PTR(q, q->write_offset), ptr, q->element_sz);
	q->write_offset++;
	q->n_eles++;
	cf_queue_unwrap(q);

	if (q->threadsafe) {
		pthread_cond_signal(&q->CV);
	}

	cf_queue_unlock(q);
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, (%rdi)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
jne 0x1679c
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movl 0xc(%rbx), %eax
movl %eax, %esi
subl 0x8(%rbx), %esi
cmpl %ebp, %esi
jae 0x167bd
movl 0x4(%rbx), %ecx
cmpl %ecx, %esi
jne 0x167dd
addl %esi, %esi
movq %rbx, %rdi
callq 0x166aa
testl %eax, %eax
je 0x167d7
xorl %ebp, %ebp
cmpb $0x0, (%rbx)
je 0x167d0
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl 0x4(%rbx), %ecx
movl 0xc(%rbx), %eax
xorl %edx, %edx
movq %r14, %rsi
divl %ecx
movl %edx, %edi
movq 0x18(%rbx), %rdx
imulq %rdx, %rdi
addq 0x78(%rbx), %rdi
callq 0x85c0
movq 0xc(%rbx), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movd %xmm0, %ecx
movq %xmm0, 0xc(%rbx)
cmpl $0x40000000, %ecx       # imm = 0x40000000
jb 0x16827
movl 0x8(%rbx), %eax
xorl %edx, %edx
subl %eax, %ecx
divl 0x4(%rbx)
addl %edx, %ecx
movl %edx, 0x8(%rbx)
movl %ecx, 0xc(%rbx)
movb (%rbx), %al
cmpb $0x1, %al
jne 0x16838
leaq 0x48(%rbx), %rdi
callq 0x84e0
movb (%rbx), %al
movb $0x1, %bpl
testb $0x1, %al
jne 0x167c4
jmp 0x167d0
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_push_unique
int
cf_queue_push_unique(cf_queue *q, const void *ptr)
{
	cf_queue_lock(q);

	// Check if element is already queued.
	if (CF_Q_SZ(q) != 0) {
		for (uint32_t i = q->read_offset; i < q->write_offset; i++) {
			if (0 == memcmp(CF_Q_ELEM_PTR(q, i), ptr, q->element_sz)) {
				// Element is already queued.
				// TODO - return 0 if all callers regard this as normal?
				cf_queue_unlock(q);
				return -2;
			}
		}
	}

	if (CF_Q_SZ(q) == q->alloc_sz) {
		if (0 != cf_queue_resize(q, q->alloc_sz * 2)) {
			cf_queue_unlock(q);
			return CF_QUEUE_ERR;
		}
	}

	// TODO - if queues are power of 2, this can be a shift.
	memcpy(CF_Q_ELEM_PTR(q, q->write_offset), ptr, q->element_sz);
	q->write_offset++;
	q->n_eles++;
	cf_queue_unwrap(q);

	if (q->threadsafe) {
		pthread_cond_signal(&q->CV);
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x1, (%rdi)
movq %rsi, %r14
movq %rdi, %r13
jne 0x16a64
leaq 0x20(%r13), %rdi
callq 0x8ad0
movl 0xc(%r13), %r15d
movl 0x8(%r13), %r12d
movl %r15d, %eax
subl %r12d, %eax
jbe 0x16aba
movq 0x78(%r13), %rbx
movl 0x4(%r13), %ebp
movq %r13, 0x10(%rsp)
movq 0x18(%r13), %r13
movl %eax, 0xc(%rsp)
movl %r12d, %eax
xorl %edx, %edx
movq %r14, %rsi
divl %ebp
imulq %r13, %rdx
leaq (%rdx,%rbx), %rdi
movq %r13, %rdx
callq 0x8770
testl %eax, %eax
je 0x16ad9
incl %r12d
cmpl %r12d, %r15d
jne 0x16a89
movq 0x10(%rsp), %r13
movl 0xc(%rsp), %eax
jmp 0x16abe
movl 0x4(%r13), %ebp
cmpl %ebp, %eax
jne 0x16af7
addl %ebp, %ebp
movq %r13, %rdi
movl %ebp, %esi
callq 0x166aa
testl %eax, %eax
je 0x16aef
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x16ae3
movq 0x10(%rsp), %r13
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
cmpb $0x0, (%r13)
jne 0x16b65
jmp 0x16b71
movl 0x4(%r13), %ebp
movl 0xc(%r13), %r15d
movl %r15d, %eax
xorl %edx, %edx
movq %r14, %rsi
divl %ebp
movl %edx, %edi
movq 0x18(%r13), %rdx
imulq %rdx, %rdi
addq 0x78(%r13), %rdi
callq 0x85c0
movq 0xc(%r13), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movd %xmm0, %ecx
movq %xmm0, 0xc(%r13)
cmpl $0x40000000, %ecx       # imm = 0x40000000
jb 0x16b4a
movl 0x8(%r13), %eax
xorl %edx, %edx
subl %eax, %ecx
divl 0x4(%r13)
addl %edx, %ecx
movl %edx, 0x8(%r13)
movl %ecx, 0xc(%r13)
movb (%r13), %al
cmpb $0x1, %al
jne 0x16b5f
leaq 0x48(%r13), %rdi
callq 0x84e0
movb (%r13), %al
xorl %ebp, %ebp
testb $0x1, %al
je 0x16b71
addq $0x20, %r13
movq %r13, %rdi
callq 0x8630
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_push_head
int
cf_queue_push_head(cf_queue *q, const void *ptr)
{
	cf_queue_lock(q);

	if (CF_Q_SZ(q) == q->alloc_sz) {
		if (0 != cf_queue_resize(q, q->alloc_sz * 2)) {
			cf_queue_unlock(q);
			return CF_QUEUE_ERR;
		}
	}

	if (q->read_offset == 0) {
		q->read_offset += q->alloc_sz;
		q->write_offset += q->alloc_sz;
	}

	q->read_offset--;
	memcpy(CF_Q_ELEM_PTR(q, q->read_offset), ptr, q->element_sz);
	q->n_eles++;
	cf_queue_unwrap(q);

	if (q->threadsafe) {
		pthread_cond_signal(&q->CV);
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, (%rdi)
movq %rsi, %r14
movq %rdi, %rbx
jne 0x16b9a
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movl 0xc(%rbx), %esi
movl 0x8(%rbx), %eax
movl 0x4(%rbx), %ecx
subl %eax, %esi
cmpl %ecx, %esi
jne 0x16bc9
addl %esi, %esi
movq %rbx, %rdi
callq 0x166aa
testl %eax, %eax
je 0x16bc3
cmpb $0x0, (%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jne 0x16c28
jmp 0x16c34
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %eax
testl %eax, %eax
jne 0x16bd2
addl %ecx, 0xc(%rbx)
movl %ecx, %eax
decl %eax
xorl %edx, %edx
movq %r14, %rsi
movl %eax, 0x8(%rbx)
divl %ecx
movl %edx, %edi
movq 0x18(%rbx), %rdx
imulq %rdx, %rdi
addq 0x78(%rbx), %rdi
callq 0x85c0
incl 0x10(%rbx)
movl 0xc(%rbx), %ecx
cmpl $0x40000000, %ecx       # imm = 0x40000000
jb 0x16c11
movl 0x8(%rbx), %eax
xorl %edx, %edx
subl %eax, %ecx
divl 0x4(%rbx)
addl %edx, %ecx
movl %edx, 0x8(%rbx)
movl %ecx, 0xc(%rbx)
movb (%rbx), %al
cmpb $0x1, %al
jne 0x16c22
leaq 0x48(%rbx), %rdi
callq 0x84e0
movb (%rbx), %al
xorl %ebp, %ebp
testb $0x1, %al
je 0x16c34
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_peek
int
cf_queue_peek(cf_queue *q, void *buf)
{
	cf_queue_lock(q);

	if (CF_Q_EMPTY(q)) {
		cf_queue_unlock(q);
		return CF_QUEUE_EMPTY;
	}

	memcpy(buf, CF_Q_ELEM_PTR(q, q->read_offset), q->element_sz);

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, (%rdi)
movq %rsi, %r14
movq %rdi, %rbx
jne 0x16c53
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movl 0x8(%rbx), %eax
cmpl %eax, 0xc(%rbx)
jne 0x16c67
cmpb $0x0, (%rbx)
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
jne 0x16c8d
jmp 0x16c99
xorl %edx, %edx
movq %r14, %rdi
xorl %ebp, %ebp
divl 0x4(%rbx)
movq 0x18(%rbx), %rax
imulq %rax, %rdx
addq 0x78(%rbx), %rdx
movq %rdx, %rsi
movq %rax, %rdx
callq 0x85c0
cmpb $0x1, (%rbx)
jne 0x16c99
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_delete_offset
void
cf_queue_delete_offset(cf_queue *q, uint32_t index)
{
	q->n_eles--;

	index %= q->alloc_sz;

	uint32_t r_index = q->read_offset % q->alloc_sz;
	uint32_t w_index = q->write_offset % q->alloc_sz;

	// Assumes index is validated!

	// If we're deleting the one at the head, just increase the read offset.
	if (index == r_index) {
		q->read_offset++;
		return;
	}

	// If we're deleting the tail just decrease the write offset.
	if (w_index && (index == w_index - 1)) {
		q->write_offset--;
		return;
	}

	if (index > r_index) {
		// The memory copy is overlapping, so must use memmove().
		memmove(&q->elements[(r_index + 1) * q->element_sz],
				&q->elements[r_index * q->element_sz],
				(index - r_index) * q->element_sz);
		q->read_offset++;
		return;
	}

	if (index < w_index) {
		// The memory copy is overlapping, so must use memmove().
		memmove(&q->elements[index * q->element_sz],
				&q->elements[(index + 1) * q->element_sz],
				(w_index - index - 1) * q->element_sz);
		q->write_offset--;
	}
}

// Assembly:
pushq %rbx
decl 0x10(%rdi)
movq %rdi, %rbx
movl %esi, %eax
xorl %edx, %edx
movl 0x4(%rdi), %r9d
movl 0x8(%rdi), %edi
divl %r9d
movl %edi, %eax
movl %edx, %ecx
xorl %edx, %edx
divl %r9d
movl 0xc(%rbx), %r8d
movl %edx, %esi
xorl %edx, %edx
movl %r8d, %eax
divl %r9d
cmpl %esi, %ecx
jne 0x16e31
incl %edi
movl %edi, 0x8(%rbx)
jmp 0x16eae
movl %edx, %eax
addl $-0x1, %eax
setae %dil
cmpl %eax, %ecx
setne %al
orb %dil, %al
jne 0x16e4d
decl %r8d
movl %r8d, 0xc(%rbx)
jmp 0x16eae
movl %ecx, %eax
subl %esi, %eax
jbe 0x16e7f
movq 0x18(%rbx), %rcx
movq 0x78(%rbx), %rdx
leal 0x1(%rsi), %edi
movl %esi, %esi
imulq %rcx, %rdi
imulq %rcx, %rsi
imulq %rcx, %rax
addq %rdx, %rdi
addq %rdx, %rsi
movq %rax, %rdx
callq 0x8850
incl 0x8(%rbx)
jmp 0x16eae
cmpl %edx, %ecx
jae 0x16eae
movq 0x18(%rbx), %rax
movq 0x78(%rbx), %r8
movl %ecx, %edi
leal 0x1(%rcx), %esi
notl %ecx
addl %ecx, %edx
imulq %rax, %rdi
imulq %rax, %rsi
imulq %rax, %rdx
addq %r8, %rdi
addq %r8, %rsi
callq 0x8850
decl 0xc(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_reduce
int
cf_queue_reduce(cf_queue *q, cf_queue_reduce_fn cb, void *udata)
{
	cf_queue_lock(q);

	if (CF_Q_SZ(q) != 0) {
		for (uint32_t i = q->read_offset; i < q->write_offset; i++) {
			int rv = cb(CF_Q_ELEM_PTR(q, i), udata);

			if (rv == 0) {
				continue;
			}

			if (rv == -1) {
				// Found what it was looking for, stop reducing.
				break;
			}

			if (rv == -2) {
				// Delete, and stop reducing.
				cf_queue_delete_offset(q, i);
				break;
			}
		}
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
jne 0x16ece
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movl 0x8(%rbx), %ebp
cmpl 0xc(%rbx), %ebp
jae 0x16f06
movl %ebp, %eax
xorl %edx, %edx
movq %r14, %rsi
divl 0x4(%rbx)
movl %edx, %edi
imulq 0x18(%rbx), %rdi
addq 0x78(%rbx), %rdi
callq *%r15
cmpl $-0x1, %eax
je 0x16f06
cmpl $-0x2, %eax
je 0x16efc
incl %ebp
jmp 0x16ed1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8320
cmpb $0x1, (%rbx)
jne 0x16f17
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_reduce_reverse
int
cf_queue_reduce_reverse(cf_queue *q, cf_queue_reduce_fn cb, void *udata)
{
	cf_queue_lock(q);

	if (CF_Q_SZ(q) != 0) {
		for (int i = (int)q->write_offset - 1; i >= (int)q->read_offset; i--) {
			int rv = cb(CF_Q_ELEM_PTR(q, i), udata);

			if (rv == 0) {
				continue;
			}

			if (rv == -1) {
				// Found what it was looking for, stop reducing.
				break;
			}

			if (rv == -2) {
				// Delete, and stop reducing.
				cf_queue_delete_offset(q, i);
				break;
			}
		}
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
jne 0x17100
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movl 0xc(%rbx), %ebp
cmpl 0x8(%rbx), %ebp
je 0x1713b
cmpl 0x8(%rbx), %ebp
jle 0x1713b
decl %ebp
xorl %edx, %edx
movq %r14, %rsi
movl %ebp, %eax
divl 0x4(%rbx)
movl %edx, %edi
imulq 0x18(%rbx), %rdi
addq 0x78(%rbx), %rdi
callq *%r15
cmpl $-0x1, %eax
je 0x1713b
cmpl $-0x2, %eax
jne 0x17108
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8320
cmpb $0x1, (%rbx)
jne 0x1714c
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_delete
int
cf_queue_delete(cf_queue *q, const void *ptr, bool only_one)
{
	cf_queue_lock(q);

	bool found = false;

	if (CF_Q_SZ(q) != 0) {
		for (uint32_t i = q->read_offset; i < q->write_offset; i++) {
			int rv = 0;

			// If buf is null, rv is always 0 and we delete all elements.
			if (ptr) {
				rv = memcmp(CF_Q_ELEM_PTR(q, i), ptr, q->element_sz);
			}

			if (rv == 0) {
				cf_queue_delete_offset(q, i);
				found = true;

				if (only_one) {
					break;
				}
			}
		}
	}

	cf_queue_unlock(q);
	return found ? CF_QUEUE_OK : CF_QUEUE_EMPTY;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
jne 0x1717b
leaq 0x20(%rbx), %rdi
callq 0x8ad0
movl 0x8(%rbx), %r12d
movl 0xc(%rbx), %r13d
movl $0xfffffffe, 0x4(%rsp)  # imm = 0xFFFFFFFE
cmpl %r13d, %r12d
jae 0x171e6
xorl %ebp, %ebp
testq %r15, %r15
je 0x171b9
movl %r12d, %eax
xorl %edx, %edx
movq %r15, %rsi
divl 0x4(%rbx)
movl %edx, %edi
movq 0x18(%rbx), %rdx
imulq %rdx, %rdi
addq 0x78(%rbx), %rdi
callq 0x8770
testl %eax, %eax
jne 0x171d0
movq %rbx, %rdi
movl %r12d, %esi
callq 0x8320
testb %r14b, %r14b
jne 0x171de
movl 0xc(%rbx), %r13d
movb $0x1, %bpl
incl %r12d
cmpl %r13d, %r12d
jb 0x17192
testb $0x1, %bpl
je 0x171e6
movl $0x0, 0x4(%rsp)
cmpb $0x1, (%rbx)
jne 0x171f7
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8630
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_random.c
// Function: cf_get_rand_buf
int
cf_get_rand_buf(uint8_t *buf, int len)
{
	if ((uint32_t)len >= sizeof(rand_buf))  return(-1);

	pthread_mutex_lock(&rand_buf_lock);

	if (rand_buf_off < (uint32_t)len ) {
		if (-1 == cf_rand_reload()) {
			pthread_mutex_unlock(&rand_buf_lock);
			return(-1);
		}
	}

	rand_buf_off -= len;
	memcpy(buf, &rand_buf[rand_buf_off] ,len);

	pthread_mutex_unlock(&rand_buf_lock);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $0x1fff, %esi           # imm = 0x1FFF
ja 0x1727c
movq %rdi, %rbx
leaq 0x93d0(%rip), %rdi      # 0x20600
movl %esi, %ebp
callq 0x8ad0
movl 0x93eb(%rip), %eax      # 0x20628
cmpl %ebp, %eax
jae 0x17251
callq 0x1728c
cmpl $-0x1, %eax
je 0x17284
movl 0x93d7(%rip), %eax      # 0x20628
subl %ebp, %eax
leaq 0x93d6(%rip), %rsi      # 0x20630
movl %ebp, %edx
movq %rbx, %rdi
addq %rax, %rsi
movl %eax, 0x93c0(%rip)      # 0x20628
callq 0x85c0
xorl %r14d, %r14d
leaq 0x9389(%rip), %rdi      # 0x20600
callq 0x8630
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x17270
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_random.c
// Function: cf_rand_reload
static int
cf_rand_reload(void)
{
	if (seeded == 0) {
		int rfd = open("/dev/urandom", O_RDONLY);

		if (rfd < 0) {
#if ! defined ENHANCED_ALLOC
			as_log_error("Failed to open '/dev/urandom'");
#endif

			return -1;
		}

		int rsz = (int)read(rfd, rand_buf, SEED_SZ);

		if (rsz < SEED_SZ) {
#if ! defined ENHANCED_ALLOC
			as_log_error("Failed to seed random number generator");
#endif
			close(rfd);

			return -1;
		}

		close(rfd);
		RAND_seed(rand_buf, rsz);
		seeded = 1;
	}

	if (RAND_bytes(rand_buf, sizeof(rand_buf)) != 1) {
#if ! defined ENHANCED_ALLOC
		as_log_error("Failed to reload random buffer");
#endif
		return -1;
	}

	rand_buf_off = sizeof(rand_buf);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0xb399(%rip)      # 0x22630
jne 0x17365
leaq 0x26a0(%rip), %rdi      # 0x19944
xorl %esi, %esi
xorl %eax, %eax
callq 0x8840
testl %eax, %eax
js 0x17311
leaq 0x9378(%rip), %rsi      # 0x20630
movl $0x40, %edx
movl %eax, %edi
movl %eax, %ebx
callq 0x8460
movq %rax, %r14
cmpl $0x3f, %r14d
jg 0x17348
movq 0x8cea(%rip), %rax      # 0x1ffc0
movq 0x8(%rax), %r9
testq %r9, %r9
je 0x17300
leaq 0x266b(%rip), %rsi      # 0x19951
leaq 0x2673(%rip), %rdx      # 0x19960
leaq 0x26aa(%rip), %r8       # 0x1999e
xorl %edi, %edi
movl $0x37, %ecx
xorl %eax, %eax
callq *%r9
movl %ebx, %edi
callq 0x8430
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x173bf
movq 0x8ca8(%rip), %rax      # 0x1ffc0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x8(%rax), %r9
testq %r9, %r9
je 0x173bf
leaq 0x2620(%rip), %rsi      # 0x19951
leaq 0x2628(%rip), %rdx      # 0x19960
leaq 0x2641(%rip), %r8       # 0x19980
xorl %edi, %edi
movl $0x2d, %ecx
jmp 0x173ba
movl %ebx, %edi
callq 0x8430
leaq 0x92da(%rip), %rdi      # 0x20630
movl %r14d, %esi
callq 0x8140
movb $0x1, 0xb2cb(%rip)      # 0x22630
leaq 0x92c4(%rip), %rdi      # 0x20630
movl $0x2000, %esi           # imm = 0x2000
callq 0x8280
cmpl $0x1, %eax
jne 0x17389
xorl %ebx, %ebx
movl $0x2000, 0x92a1(%rip)   # imm = 0x2000
jmp 0x173bf
movq 0x8c30(%rip), %rax      # 0x1ffc0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x8(%rax), %r9
testq %r9, %r9
je 0x173bf
leaq 0x25ac(%rip), %rsi      # 0x19951
leaq 0x25b4(%rip), %rdx      # 0x19960
leaq 0x2612(%rip), %r8       # 0x199c5
xorl %edi, %edi
movl $0x45, %ecx
xorl %eax, %eax
callq *%r9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_random.c
// Function: cf_get_rand64
uint64_t
cf_get_rand64(void)
{
	pthread_mutex_lock(&rand_buf_lock);

	if (rand_buf_off < sizeof(uint64_t) ) {
		if (cf_rand_reload() == -1) {
			pthread_mutex_unlock(&rand_buf_lock);
			return 0;
		}
	}

	rand_buf_off -= sizeof(uint64_t);

	uint64_t r = *(uint64_t *) (&rand_buf[rand_buf_off]);

	pthread_mutex_unlock(&rand_buf_lock);

	return r;
}

// Assembly:
pushq %rbx
leaq 0x922f(%rip), %rdi      # 0x20600
callq 0x8ad0
movl 0x924c(%rip), %eax      # 0x20628
cmpl $0x7, %eax
ja 0x173f1
callq 0x1728c
cmpl $-0x1, %eax
je 0x17416
movl 0x9237(%rip), %eax      # 0x20628
addl $-0x8, %eax
leaq 0x9235(%rip), %rcx      # 0x20630
movq (%rax,%rcx), %rbx
movl %eax, 0x9223(%rip)      # 0x20628
leaq 0x91f4(%rip), %rdi      # 0x20600
callq 0x8630
movq %rbx, %rax
popq %rbx
retq
xorl %ebx, %ebx
jmp 0x17405
// File: /workspace/github_c_makefile_star2_O3/aerospike[P]aerospike-common/src/main/citrusleaf/cf_random.c
// Function: cf_get_rand32
uint32_t
cf_get_rand32(void)
{
	pthread_mutex_lock(&rand_buf_lock);

	if (rand_buf_off < sizeof(uint64_t) ) {
		if (cf_rand_reload() == -1) {
			pthread_mutex_unlock(&rand_buf_lock);
			return 0;
		}
	}

	rand_buf_off -= sizeof(uint64_t);

	uint64_t r = *(uint64_t *) (&rand_buf[rand_buf_off]);

	pthread_mutex_unlock(&rand_buf_lock);

	return (uint32_t)r;
}

// Assembly:
pushq %rbx
leaq 0x91de(%rip), %rdi      # 0x20600
callq 0x8ad0
movl 0x91fb(%rip), %eax      # 0x20628
cmpl $0x7, %eax
ja 0x17442
callq 0x1728c
cmpl $-0x1, %eax
je 0x17465
movl 0x91e6(%rip), %eax      # 0x20628
addl $-0x8, %eax
leaq 0x91e4(%rip), %rcx      # 0x20630
leaq 0x91ad(%rip), %rdi      # 0x20600
movl (%rax,%rcx), %ebx
movl %eax, 0x91cc(%rip)      # 0x20628
callq 0x8630
movl %ebx, %eax
popq %rbx
retq
leaq 0x9194(%rip), %rdi      # 0x20600
callq 0x8630
xorl %ebx, %ebx
jmp 0x17461
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: str2int
char str2int(char c)
{
        switch (c)
        {
                case 'A':
                        return 0;
                case 'C':
                        return 1;
                case 'G':
                        return 2;
                case 'T':
                        return 3;
        }
        return 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x46, %edi
jg 0x1303
cmpl $0x41, %edi
je 0x1315
cmpl $0x43, %edi
jne 0x1311
movb $0x1, %al
jmp 0x131b
cmpl $0x47, %edi
je 0x1319
cmpl $0x54, %edi
jne 0x1311
movb $0x3, %al
jmp 0x131b
movb $0x4, %al
jmp 0x131b
xorl %eax, %eax
jmp 0x131b
movb $0x2, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: generate
void generate(char *seq,char out[],int pos,int length)
{
	int i;
	for(i=0;i<length;i++)
	{
		out[i]=seq[pos+i];
	}
	out[i]='\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %ecx, %ecx
jle 0x95e3
movslq %edx, %rdx
movl %ecx, %eax
addq %rdx, %rdi
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x95d3
jmp 0x95e5
xorl %eax, %eax
movb $0x0, (%rsi,%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: gc
float gc(char seq[],int length)
{
	int i,number;
	float gc;

	number=0;
	for(i=0;i<length;i++)
	{
		if(seq[i]=='C')
		{
			number++;
			continue;
		}
	
		if(seq[i]=='G')
		{
			number++;
		}
	}

	gc=1.0*number/length*100;
	return gc;
}

// Assembly:
testl %esi, %esi
jle 0x9616
movl %esi, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movzbl (%rdi,%rcx), %r8d
cmpl $0x47, %r8d
je 0x9606
cmpl $0x43, %r8d
jne 0x9608
incl %edx
incq %rcx
cmpq %rcx, %rax
jne 0x95f5
cvtsi2sd %edx, %xmm0
jmp 0x961a
xorpd %xmm0, %xmm0
pushq %rbp
movq %rsp, %rbp
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
mulsd 0x2a62(%rip), %xmm0     # 0xc090
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: translate
int translate(char a)
{
	if(a=='A')
		return 0;
	if(a=='T')
		return 1;
	if(a=='C')
		return 2;
	return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x41, %edi
je 0x9655
cmpl $0x43, %edi
je 0x964e
cmpl $0x54, %edi
jne 0x9659
movl $0x1, %eax
jmp 0x965e
movl $0x2, %eax
jmp 0x965e
xorl %eax, %eax
jmp 0x965e
movl $0x3, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: tm
float tm(char seq[],float deltah[],float deltas[],int length)
{
	int i,pos;
	float total_deltah,total_deltas,result;

	total_deltah=0;
	total_deltas=0;
	for(i=0;i<length-1;i++)
	{
		pos=translate(seq[i]);
		pos=pos*4+translate(seq[i+1]);
		total_deltah+=deltah[pos];
		total_deltas+=deltas[pos];
	}

	total_deltah=(-1.0)*total_deltah;
	total_deltas=(-1.0)*total_deltas;
	if((seq[0]=='A')||(seq[0]=='T'))
	{
		total_deltah+=2.3;
		total_deltas+=4.1;
	}
	else
	{
		total_deltah+=0.1;
		total_deltas-=2.8;
	}
        if((seq[length-1]=='A')||(seq[length-1]=='T'))
        {
                total_deltah+=2.3;
                total_deltas+=4.1;
        }
        else
        {
                total_deltah+=0.1;
                total_deltas-=2.8;
        }
	result=1000.0*total_deltah/(total_deltas-0.6656578*(length-1)-36.1585064)-273.15;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leal -0x1(%rcx), %eax
movb (%rdi), %r10b
movzbl %r10b, %r8d
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
cmpl $0x2, %ecx
jl 0x96f7
movl %eax, %ecx
xorl %r9d, %r9d
cmpb $0x41, %r10b
je 0x96a5
movzbl %r10b, %r10d
cmpl $0x43, %r10d
je 0x969d
cmpl $0x54, %r10d
jne 0x96aa
movl $0x4, %r11d
jmp 0x96b0
movl $0x8, %r11d
jmp 0x96b0
xorl %r11d, %r11d
jmp 0x96b0
movl $0xc, %r11d
movzbl 0x1(%rdi,%r9), %r10d
cmpl $0x41, %r10d
je 0x96d6
cmpl $0x43, %r10d
je 0x96cf
cmpl $0x54, %r10d
jne 0x96da
movl $0x1, %ebx
jmp 0x96df
movl $0x2, %ebx
jmp 0x96df
xorl %ebx, %ebx
jmp 0x96df
movl $0x3, %ebx
orl %r11d, %ebx
shll $0x2, %ebx
addss (%rsi,%rbx), %xmm1
incq %r9
addss (%rdx,%rbx), %xmm0
cmpq %r9, %rcx
jne 0x967f
movsd 0x29a9(%rip), %xmm2     # 0xc0a8
movsd 0x29a9(%rip), %xmm3     # 0xc0b0
movapd %xmm3, %xmm5
movapd %xmm2, %xmm4
cmpl $0x41, %r8d
je 0x9733
movapd %xmm3, %xmm5
movapd %xmm2, %xmm4
cmpl $0x54, %r8d
je 0x9733
movsd 0x298d(%rip), %xmm4     # 0xc0b8
movsd 0x298d(%rip), %xmm5     # 0xc0c0
movslq %eax, %rcx
movzbl (%rdi,%rcx), %ecx
cmpl $0x41, %ecx
je 0x9754
cmpl $0x54, %ecx
je 0x9754
movsd 0x296c(%rip), %xmm2     # 0xc0b8
movsd 0x296c(%rip), %xmm3     # 0xc0c0
cvtss2sd %xmm1, %xmm1
subsd %xmm1, %xmm5
xorps %xmm1, %xmm1
cvtsd2ss %xmm5, %xmm1
cvtss2sd %xmm0, %xmm0
subsd %xmm0, %xmm4
xorps %xmm0, %xmm0
cvtsd2ss %xmm4, %xmm0
cvtss2sd %xmm1, %xmm1
addsd %xmm3, %xmm1
cvtss2sd %xmm0, %xmm0
addsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
mulsd 0x2932(%rip), %xmm1     # 0xc0c8
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
mulsd 0x292b(%rip), %xmm2     # 0xc0d0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm2
addsd 0x2923(%rip), %xmm2     # 0xc0d8
divsd %xmm2, %xmm1
addsd 0x289f(%rip), %xmm1     # 0xc060
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: check_long_ploy
int check_long_ploy(char primer[],int length)
{
	int i,same;
	char ref;

	same=1;
	ref=primer[0];
	for(i=1;i<length;i++)
	{
		if(primer[i]==ref)
			same++;
		else
		{
			if(same>=6)
				return 0;
			same=1;
			ref=primer[i];
		}
	}
	if(same>=6)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpl $0x2, %esi
jl 0x9893
movb (%rdi), %r8b
movl %esi, %eax
movl $0x1, %ecx
movl $0x1, %edx
movb (%rdi,%rdx), %sil
cmpb %r8b, %sil
jne 0x9872
incl %ecx
movl %r8d, %esi
jmp 0x987c
cmpl $0x5, %ecx
movl $0x1, %ecx
jg 0x9891
incq %rdx
movl %esi, %r8d
cmpq %rdx, %rax
jne 0x9862
xorl %eax, %eax
cmpl $0x6, %ecx
setl %al
jmp 0x9893
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/single.c
// Function: GContent
float GContent(char primer[],int length)
{
	int i,G;
	G=0;
	for(i=0;i<length;i++)
	{
		if(primer[i]=='G')
			G++;
	}
	return 1.0*G/length*100;
}

// Assembly:
testl %esi, %esi
jle 0x98bb
movl %esi, %eax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
cmpb $0x47, (%rdi,%rcx)
sete %r8b
addl %r8d, %edx
incq %rcx
cmpq %rcx, %rax
jne 0x989f
cvtsi2sd %edx, %xmm0
jmp 0x98bf
xorpd %xmm0, %xmm0
pushq %rbp
movq %rsp, %rbp
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
mulsd 0x27bd(%rip), %xmm0     # 0xc090
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq