LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: network_ssl_write
void *
network_ssl_write(struct network_ssl_ctx * ssl, const uint8_t * buf,
    size_t buflen, size_t minwrite,
    int (* callback)(void *, ssize_t), void * cookie)
{

	/* We must be initialized before we get here. */
	assert(ctx != NULL);

	/* Make sure buflen is non-zero. */
	assert(buflen != 0);

	/* Sanity-check: # bytes must fit into a ssize_t. */
	assert(buflen <= SSIZE_MAX);

	/* Sanity-check: Must not have a write already in progress. */
	assert(ssl->write_callback == NULL);

	/* Record details of the pending request. */
	ssl->write_callback = callback;
	ssl->write_cookie = cookie;
	ssl->write_buf = buf;
	ssl->write_buflen = buflen;
	ssl->write_minlen = minwrite;
	ssl->write_bufpos = 0;
	ssl->write_needs_r = 0;
	ssl->write_needs_w = 0;

	/* Poke the SSL stack. */
	if (ssl->immediate_cookie == NULL) {
		if ((ssl->immediate_cookie = events_immediate_register(
		    callback_immediate, ssl, 0)) == NULL)
			goto err0;
	}

	/* Success! */
	return (ssl);

err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x1bc45(%rip)     # 0x288e0
je 0xccfc
testq %rdx, %rdx
je 0xcd1b
js 0xcd3a
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
jne 0xcd59
movq %r8, 0x58(%rbx)
movq %r9, 0x60(%rbx)
movq %rsi, 0x68(%rbx)
movq %rdx, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
cmpq $0x0, 0x18(%rbx)
jne 0xccf7
leaq -0x166(%rip), %rdi      # 0xcb7c
movq %rbx, %rsi
xorl %edx, %edx
callq 0x42e8
movq %rax, 0x18(%rbx)
testq %rax, %rax
cmoveq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x52bb(%rip), %rdi      # 0x11fbe
leaq 0x52c0(%rip), %rsi      # 0x11fca
leaq 0x536b(%rip), %rcx      # 0x1207c
movl $0x288, %edx            # imm = 0x288
callq 0x3210
leaq 0x474f(%rip), %rdi      # 0x11471
leaq 0x52a1(%rip), %rsi      # 0x11fca
leaq 0x534c(%rip), %rcx      # 0x1207c
movl $0x28b, %edx            # imm = 0x28B
callq 0x3210
leaq 0x47b7(%rip), %rdi      # 0x114f8
leaq 0x5282(%rip), %rsi      # 0x11fca
leaq 0x532d(%rip), %rcx      # 0x1207c
movl $0x28e, %edx            # imm = 0x28E
callq 0x3210
leaq 0x5391(%rip), %rdi      # 0x120f1
leaq 0x5263(%rip), %rsi      # 0x11fca
leaq 0x530e(%rip), %rcx      # 0x1207c
movl $0x291, %edx            # imm = 0x291
callq 0x3210
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: network_ssl_close
void
network_ssl_close(struct network_ssl_ctx * ssl)
{

	/* Sanity check. */
	assert(ssl != NULL);

	/* Cancel a pending immediate event. */
	if (ssl->immediate_cookie)
		events_immediate_cancel(ssl->immediate_cookie);

	/* Must not have operations in progress. */
	assert(ssl->read_callback == NULL);
	assert(ssl->write_callback == NULL);

	/* It should be impossible for us to have any events registered. */
	assert(ssl->waiting_r == 0);
	assert(ssl->waiting_w == 0);

	/* Shut down and free the SSL context. */
	SSL_shutdown(ssl->ssl);
	SSL_free(ssl->ssl);

	/* Free our state structure. */
	free(ssl);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xcdde
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xcda1
callq 0x43d3
cmpq $0x0, 0x20(%rbx)
jne 0xcdfd
cmpq $0x0, 0x58(%rbx)
jne 0xce1c
cmpl $0x0, 0x10(%rbx)
jne 0xce3b
cmpl $0x0, 0x14(%rbx)
jne 0xce5a
movq 0x8(%rbx), %rdi
callq 0x3420
movq 0x8(%rbx), %rdi
callq 0x31d0
movq %rbx, %rdi
popq %rbx
jmp 0x3460
leaq 0x5328(%rip), %rdi      # 0x1210d
leaq 0x51de(%rip), %rsi      # 0x11fca
leaq 0x5326(%rip), %rcx      # 0x12119
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x3210
leaq 0x525d(%rip), %rdi      # 0x12061
leaq 0x51bf(%rip), %rsi      # 0x11fca
leaq 0x5307(%rip), %rcx      # 0x12119
movl $0x2d6, %edx            # imm = 0x2D6
callq 0x3210
leaq 0x52ce(%rip), %rdi      # 0x120f1
leaq 0x51a0(%rip), %rsi      # 0x11fca
leaq 0x52e8(%rip), %rcx      # 0x12119
movl $0x2d7, %edx            # imm = 0x2D7
callq 0x3210
leaq 0x5308(%rip), %rdi      # 0x1214a
leaq 0x5181(%rip), %rsi      # 0x11fca
leaq 0x52c9(%rip), %rcx      # 0x12119
movl $0x2da, %edx            # imm = 0x2DA
callq 0x3210
leaq 0x52fd(%rip), %rdi      # 0x1215e
leaq 0x5162(%rip), %rsi      # 0x11fca
leaq 0x52aa(%rip), %rcx      # 0x12119
movl $0x2db, %edx            # imm = 0x2DB
callq 0x3210
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/util/hexify.c
// Function: hexify
void
hexify(const uint8_t * in, char * out, size_t len)
{
	char * p = out;
	size_t i;

	for (i = 0; i < len; i++) {
		*p++ = hexchars[in[i] >> 4];
		*p++ = hexchars[in[i] & 0x0f];
	}
	*p = '\0';
}

// Assembly:
xorl %eax, %eax
leaq 0xb357(%rip), %rcx      # 0x186d0
cmpq %rax, %rdx
je 0xd3a6
movzbl (%rdi,%rax), %r8d
shrl $0x4, %r8d
movb (%r8,%rcx), %r8b
movb %r8b, (%rsi,%rax,2)
movzbl (%rdi,%rax), %r8d
andl $0xf, %r8d
movb (%r8,%rcx), %r8b
movb %r8b, 0x1(%rsi,%rax,2)
incq %rax
jmp 0xd379
movb $0x0, (%rsi,%rax,2)
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/util/hexify.c
// Function: unhexify
int
unhexify(const char * in, uint8_t * out, size_t len)
{
	size_t i;
	ptrdiff_t pos;

	/* Make sure we have at least 2 * ${len} hex characters. */
	for (i = 0; i < 2 * len; i++) {
		if ((in[i] == '\0') || (strchr(hexchars, in[i]) == NULL))
			goto err0;
	}

	/* Process all pairs of characters. */
	for (i = 0; i < len; i++) {
		/* Convert first character. */
		pos = strchr(hexchars, in[2 * i]) - hexchars;
		out[i] = (uint8_t)((pos & 0x0f) << 4);

		/* Convert second character. */
		pos = strchr(hexchars, in[2 * i + 1]) - hexchars;
		out[i] = (uint8_t)(out[i] + (pos & 0x0f));
	}

	/* Success! */
	return (0);

err0:
	/* Bad input string. */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq (%rdx,%rdx), %rbx
xorl %ebp, %ebp
pushq $-0x1
popq %rax
movq %rax, (%rsp)
leaq 0xb2fd(%rip), %r13      # 0x186d0
cmpq %rbp, %rbx
je 0xd404
movsbl (%r12,%rbp), %esi
testl %esi, %esi
je 0xd3f1
movq %r13, %rdi
callq 0x3160
incq %rbp
testq %rax, %rax
jne 0xd3d3
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, (%rsp)
leaq 0xb2bd(%rip), %r13      # 0x186d0
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0xd3f1
movsbl (%r12,%rbx,2), %esi
movq %r13, %rdi
callq 0x3160
movq %rax, %rbp
shlb $0x4, %bpl
movb %bpl, (%r15,%rbx)
movsbl 0x1(%r12,%rbx,2), %esi
movq %r13, %rdi
callq 0x3160
andb $0xf, %al
orb %bpl, %al
movb %al, (%r15,%rbx)
incq %rbx
jmp 0xd415
nop
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: libcperciva_SHA256_Init
void
SHA256_Init(SHA256_CTX * ctx)
{

	/* Zero bits processed so far. */
	ctx->count = 0;

	/* Initialize state. */
	memcpy(ctx->state, initial_state, sizeof(initial_state));

#ifdef HWACCEL
	/* Ensure that we've chosen the type of hardware acceleration. */
	hwaccel_init();
#endif
}

// Assembly:
andq $0x0, 0x20(%rdi)
movaps 0x4ed4(%rip), %xmm0     # 0x12330
movups %xmm0, 0x10(%rdi)
movaps 0x4eb9(%rip), %xmm0     # 0x12320
movups %xmm0, (%rdi)
cmpl $0x3, 0xb283(%rip)      # 0x186f4
jne 0xd59e
pushq %r14
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
andl $0x0, 0xb26c(%rip)      # 0x186f4
xorl %eax, %eax
cmpq $0x40, %rax
je 0xd499
movb %al, 0x20(%rsp,%rax)
incq %rax
jmp 0xd48a
leaq 0x1b448(%rip), %rbx     # 0x288e8
cmpl $0x0, (%rbx)
je 0xd4ea
leaq 0x1b44c(%rip), %rbx     # 0x288f8
cmpl $0x0, (%rbx)
je 0xd50b
leaq 0x92c(%rip), %rcx       # 0xdde4
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
callq 0xdd58
testl %eax, %eax
je 0xd58a
leaq 0x4f08(%rip), %rdi      # 0x123e1
xorl %eax, %eax
callq 0x553c
callq 0x3040
andl $0x0, (%rax)
jmp 0xd51c
leaq 0x1b3fb(%rip), %r14     # 0x288ec
cmpl $0x0, (%r14)
jne 0xd51c
callq 0xf704
movl %eax, (%rbx)
movl $0x1, (%r14)
testl %eax, %eax
jne 0xd4a5
jmp 0xd51c
leaq 0x1b3ea(%rip), %r14     # 0x288fc
cmpl $0x0, (%r14)
je 0xd59f
leaq 0x1b3cd(%rip), %rbx     # 0x288f0
cmpl $0x0, (%rbx)
je 0xd55d
leaq 0x189d(%rip), %rcx      # 0xedcc
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
callq 0xdd58
testl %eax, %eax
je 0xd57e
leaq 0x4ec4(%rip), %rdi      # 0x12410
xorl %eax, %eax
callq 0x553c
callq 0x3040
andl $0x0, (%rax)
jmp 0xd594
leaq 0x1b390(%rip), %r14     # 0x288f4
cmpl $0x0, (%r14)
jne 0xd594
callq 0xf72c
movl %eax, (%rbx)
movl $0x1, (%r14)
testl %eax, %eax
jne 0xd528
jmp 0xd594
movl $0x2, 0xb16c(%rip)      # 0x186f4
jmp 0xd594
movl $0x1, 0xb160(%rip)      # 0x186f4
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r14
retq
callq 0xf754
movl %eax, (%rbx)
movl $0x1, (%r14)
testl %eax, %eax
jne 0xd4b1
jmp 0xd51c
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: SHA256_Update_internal
static void
SHA256_Update_internal(SHA256_CTX * ctx, const void * in, size_t len,
    uint32_t tmp32[static restrict 72])
{
	uint32_t r;
	const uint8_t * src = in;

	/* Return immediately if we have nothing to do. */
	if (len == 0)
		return;

	/* Number of bytes left in the buffer from previous updates. */
	r = (ctx->count >> 3) & 0x3f;

	/* Update number of bits. */
	ctx->count += (uint64_t)(len) << 3;

	/* Handle the case where we don't need to perform any transforms. */
	if (len < 64 - r) {
		memcpy(&ctx->buf[r], src, len);
		return;
	}

	/* Finish the current block. */
	memcpy(&ctx->buf[r], src, 64 - r);
	SHA256_Transform(ctx->state, ctx->buf, &tmp32[0], &tmp32[64]);
	src += 64 - r;
	len -= 64 - r;

	/* Perform complete blocks. */
	while (len >= 64) {
		SHA256_Transform(ctx->state, src, &tmp32[0], &tmp32[64]);
		src += 64;
		len -= 64;
	}

	/* Copy left over data into buffer. */
	memcpy(ctx->buf, src, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xd630
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rdi), %rax
leaq (%rax,%rdx,8), %rcx
shrl $0x3, %eax
andl $0x3f, %eax
movq %rcx, 0x20(%rdi)
pushq $0x40
popq %r13
subl %eax, %r13d
movq %rdx, %r12
addq %rax, %rdi
addq $0x28, %rdi
subq %r13, %r12
jae 0xd63f
movq %rbx, %rsi
jmp 0xd699
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%r15), %rax
movq %rax, (%rsp)
movq %rbx, %rsi
movq %r13, %rdx
callq 0x3290
leaq 0x100(%r14), %rbp
movq %r15, %rdi
movq (%rsp), %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0xdde9
addq %r13, %rbx
cmpq $0x40, %r12
jb 0xd68f
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0xdde9
addq $0x40, %rbx
addq $-0x40, %r12
jmp 0xd66e
movq (%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3290
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: SHA256_Final_internal
static void
SHA256_Final_internal(uint8_t digest[32], SHA256_CTX * ctx,
    uint32_t tmp32[static restrict 72])
{

	/* Add padding. */
	SHA256_Pad(ctx, tmp32);

	/* Write the hash. */
	be32enc_vect(digest, ctx->state, 32);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rsi), %eax
shrl $0x3, %eax
andl $0x3f, %eax
leaq 0x28(%rsi), %r12
leaq (%rsi,%rax), %rdi
addq $0x28, %rdi
cmpl $0x37, %eax
ja 0xd731
pushq $0x38
popq %rdx
subq %rax, %rdx
leaq 0x4e16(%rip), %rsi      # 0x12540
callq 0x3290
jmp 0xd772
pushq $0x40
popq %rdx
subq %rax, %rdx
leaq 0x4e02(%rip), %rsi      # 0x12540
callq 0x3290
leaq 0x100(%r15), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xdde9
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
andq $0x0, 0x30(%r12)
movq 0x20(%rbx), %rax
bswapq %rax
movq %rax, 0x60(%rbx)
leaq 0x100(%r15), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xdde9
xorl %eax, %eax
cmpq $0x8, %rax
je 0xd7a8
movl (%rbx,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
jmp 0xd794
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: libcperciva_SHA256_Buf
void
SHA256_Buf(const void * in, size_t len, uint8_t digest[32])
{
	SHA256_CTX ctx;
	uint32_t tmp32[72];

	SHA256_Init(&ctx);
	SHA256_Update_internal(&ctx, in, len, tmp32);
	SHA256_Final_internal(digest, &ctx, tmp32);

	/* Clean the stack. */
	insecure_memzero(&ctx, sizeof(SHA256_CTX));
	insecure_memzero(tmp32, sizeof(uint32_t) * 72);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xd450
leaq 0x70(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0xd5ea
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd6f2
leaq 0xadd3(%rip), %rbx      # 0x185d8
movq (%rbx), %rax
pushq $0x68
popq %rsi
movq %r12, %rdi
callq *%rax
movq (%rbx), %rax
movl $0x120, %esi            # imm = 0x120
movq %r13, %rdi
callq *%rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: libcperciva_HMAC_SHA256_Init
void
HMAC_SHA256_Init(HMAC_SHA256_CTX * ctx, const void * K, size_t Klen)
{
	uint32_t tmp32[72];
	uint8_t pad[64];
	uint8_t khash[32];

	/* Call the real function. */
	HMAC_SHA256_Init_internal(ctx, K, Klen, tmp32, pad, khash);

	/* Clean the stack. */
	insecure_memzero(tmp32, sizeof(uint32_t) * 72);
	insecure_memzero(khash, 32);
	insecure_memzero(pad, 64);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
leaq 0x60(%rsp), %rbx
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %rbx, %rcx
movq %r14, %r8
movq %r15, %r9
callq 0xd893
leaq 0xad7a(%rip), %r12      # 0x185d8
movq (%r12), %rax
movl $0x120, %esi            # imm = 0x120
movq %rbx, %rdi
callq *%rax
movq (%r12), %rax
pushq $0x20
popq %rsi
movq %r15, %rdi
callq *%rax
movq (%r12), %rax
pushq $0x40
popq %rsi
movq %r14, %rdi
callq *%rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: HMAC_SHA256_Init_internal
static void
HMAC_SHA256_Init_internal(HMAC_SHA256_CTX * ctx, const void * _k, size_t Klen,
    uint32_t tmp32[static restrict 72], uint8_t pad[static restrict 64],
    uint8_t khash[static restrict 32])
{
	const uint8_t * K = _k;
	size_t i;

	/* If Klen > 64, the key is really SHA256(K). */
	if (Klen > 64) {
		SHA256_Init(&ctx->ictx);
		SHA256_Update_internal(&ctx->ictx, K, Klen, tmp32);
		SHA256_Final_internal(khash, &ctx->ictx, tmp32);
		K = khash;
		Klen = 32;
	}

	/* Inner SHA256 operation is SHA256(K xor [block of 0x36] || data). */
	SHA256_Init(&ctx->ictx);
	memset(pad, 0x36, 64);
	for (i = 0; i < Klen; i++)
		pad[i] ^= K[i];
	SHA256_Update_internal(&ctx->ictx, pad, 64, tmp32);

	/* Outer SHA256 operation is SHA256(K xor [block of 0x5c] || hash). */
	SHA256_Init(&ctx->octx);
	memset(pad, 0x5c, 64);
	for (i = 0; i < Klen; i++)
		pad[i] ^= K[i];
	SHA256_Update_internal(&ctx->octx, pad, 64, tmp32);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
cmpq $0x41, %rdx
jb 0xd8e3
movq %r9, %r15
movq %r12, %rdi
callq 0xd450
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xd5ea
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xd6f2
pushq $0x20
popq %r13
jmp 0xd8e6
movq %rbp, %r15
movq %r12, %rdi
callq 0xd450
movaps 0x4a0b(%rip), %xmm0     # 0x12300
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
xorl %eax, %eax
cmpq %rax, %r13
je 0xd91c
movb (%r15,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
jmp 0xd90a
pushq $0x40
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0xd5ea
addq $0x68, %r12
movq %r12, %rdi
callq 0xd450
movaps 0x49d0(%rip), %xmm0     # 0x12310
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
xorl %eax, %eax
cmpq %rax, %r13
je 0xd967
movb (%r15,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
jmp 0xd955
pushq $0x40
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd5ea
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: HMAC_SHA256_Final_internal
static void
HMAC_SHA256_Final_internal(uint8_t digest[32], HMAC_SHA256_CTX * ctx,
    uint32_t tmp32[static restrict 72], uint8_t ihash[static restrict 32])
{

	/* Finish the inner SHA256 operation. */
	SHA256_Final_internal(ihash, &ctx->ictx, tmp32);

	/* Feed the inner hash to the outer SHA256 operation. */
	SHA256_Update_internal(&ctx->octx, ihash, 32, tmp32);

	/* Finish the outer SHA256 operation. */
	SHA256_Final_internal(digest, &ctx->octx, tmp32);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0xd6f2
addq $0x68, %r15
pushq $0x20
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0xd5ea
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd6f2
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: libcperciva_HMAC_SHA256_Buf
void
HMAC_SHA256_Buf(const void * K, size_t Klen, const void * in, size_t len,
    uint8_t digest[32])
{
	HMAC_SHA256_CTX ctx;
	uint32_t tmp32[72];
	uint8_t tmp8[96];

	HMAC_SHA256_Init_internal(&ctx, K, Klen, tmp32, &tmp8[0], &tmp8[64]);
	HMAC_SHA256_Update_internal(&ctx, in, len, tmp32);
	HMAC_SHA256_Final_internal(digest, &ctx, tmp32, &tmp8[0]);

	/* Clean the stack. */
	insecure_memzero(&ctx, sizeof(HMAC_SHA256_CTX));
	insecure_memzero(tmp32, sizeof(uint32_t) * 72);
	insecure_memzero(tmp8, 96);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x40(%rsp), %r9
leaq 0x60(%rsp), %rbp
leaq 0x130(%rsp), %r14
movq %rsp, %rbx
movq %rbp, %rdi
movq %r14, %rcx
movq %rbx, %r8
callq 0xd893
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xd5ea
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xda18
leaq 0xab0a(%rip), %r15      # 0x185d8
movq (%r15), %rax
movl $0xd0, %esi
movq %rbp, %rdi
callq *%rax
movq (%r15), %rax
movl $0x120, %esi            # imm = 0x120
movq %r14, %rdi
callq *%rax
movq (%r15), %rax
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq *%rax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: hwtest
static int
hwtest(const uint32_t state[static restrict 8],
    const uint8_t block[static restrict 64],
    uint32_t W[static restrict 64], uint32_t S[static restrict 8],
    void (* func)(uint32_t state[static restrict 8],
    const uint8_t block[static restrict 64], uint32_t W[static restrict 64],
    uint32_t S[static restrict 8]))
{
	uint32_t state_sw[8];
	uint32_t state_hw[8];

	/* Software transform. */
	memcpy(state_sw, state, sizeof(state_sw));
	SHA256_Transform(state_sw, block, W, S);

	/* Hardware transform. */
	memcpy(state_hw, state, sizeof(state_hw));
	func(state_hw, block, W, S);

	/* Do the results match? */
	return (memcmp(state_sw, state_hw, sizeof(state_sw)));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movaps 0x45a7(%rip), %xmm0     # 0x12320
leaq 0x20(%rsp), %r13
movaps %xmm0, (%r13)
movaps 0x45a6(%rip), %xmm0     # 0x12330
movaps %xmm0, 0x10(%r13)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xdde9
movq %rsp, %rbp
movaps 0x4586(%rip), %xmm0     # 0x12330
movaps %xmm0, 0x10(%rbp)
movaps 0x456b(%rip), %xmm0     # 0x12320
movaps %xmm0, (%rbp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
pushq $0x20
popq %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x31a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256_sse2.c
// Function: MSG4
static inline __m128i
MSG4(__m128i X0, __m128i X1, __m128i X2, __m128i X3)
{
	__m128i X4;
	__m128i Xj_minus_seven, Xj_minus_fifteen;

	/* Set up variables which span X values. */
	Xj_minus_seven = SPAN_ONE_THREE(X2, X3);
	Xj_minus_fifteen = SPAN_ONE_THREE(X0, X1);

	/* Begin computing X4. */
	X4 = _mm_add_epi32(X0, Xj_minus_seven);
	X4 = _mm_add_epi32(X4, s0_128(Xj_minus_fifteen));

	/* First half of s1. */
	X4 = _mm_add_epi32(X4, s1_128_low(X3));

	/* Second half of s1; this depends on the above value of X4. */
	X4 = _mm_add_epi32(X4, s1_128_high(X4));

	return (X4);
}

// Assembly:
pshufd $0xfa, %xmm3, %xmm4     # xmm4 = xmm3[2,2,3,3]
shufps $0x30, %xmm2, %xmm3     # xmm3 = xmm3[0,0],xmm2[3,0]
shufps $0x29, %xmm3, %xmm2     # xmm2 = xmm2[1,2],xmm3[2,0]
shufps $0x30, %xmm0, %xmm1     # xmm1 = xmm1[0,0],xmm0[3,0]
paddd %xmm0, %xmm2
shufps $0x29, %xmm1, %xmm0     # xmm0 = xmm0[1,2],xmm1[2,0]
movaps %xmm0, %xmm1
psrld $0x7, %xmm1
movaps %xmm0, %xmm3
pslld $0x19, %xmm3
por %xmm1, %xmm3
movaps %xmm0, %xmm1
psrld $0x12, %xmm1
movaps %xmm0, %xmm5
pslld $0xe, %xmm5
por %xmm1, %xmm5
pxor %xmm3, %xmm5
psrld $0x3, %xmm0
pxor %xmm5, %xmm0
movdqa %xmm4, %xmm1
psrlq $0x11, %xmm1
movdqa %xmm4, %xmm3
psrlq $0x13, %xmm3
pxor %xmm1, %xmm3
psrld $0xa, %xmm4
pxor %xmm3, %xmm4
pxor %xmm1, %xmm1
shufps $0x48, %xmm1, %xmm4     # xmm4 = xmm4[0,2],xmm1[0,1]
paddd %xmm2, %xmm4
paddd %xmm4, %xmm0
pshufd $0x50, %xmm0, %xmm2     # xmm2 = xmm0[0,0,1,1]
movdqa %xmm2, %xmm3
psrlq $0x11, %xmm3
movdqa %xmm2, %xmm4
psrlq $0x13, %xmm4
pxor %xmm3, %xmm4
psrld $0xa, %xmm2
pxor %xmm4, %xmm2
shufps $0x8e, %xmm2, %xmm1     # xmm1 = xmm1[2,3],xmm2[0,2]
paddd %xmm1, %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistCreate
quicklist *quicklistCreate(void) {
    struct quicklist *quicklist;

    quicklist = zmalloc(sizeof(*quicklist));
    quicklist->head = quicklist->tail = NULL;
    quicklist->len = 0;
    quicklist->count = 0;
    quicklist->compress = 0;
    quicklist->fill = -2;
    return quicklist;
}

// Assembly:
pushq %rax
pushq $0x20
popq %rdi
callq 0x327b9
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movl $0xfffe, 0x1c(%rax)     # imm = 0xFFFE
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistCreateNode
REDIS_STATIC quicklistNode *quicklistCreateNode(void) {
    quicklistNode *node;
    node = zmalloc(sizeof(*node));
    node->zl = NULL;
    node->count = 0;
    node->sz = 0;
    node->next = node->prev = NULL;
    node->encoding = QUICKLIST_NODE_ENCODING_RAW;
    node->container = QUICKLIST_NODE_CONTAINER_ZIPLIST;
    node->recompress = 0;
    return node;
}

// Assembly:
pushq %rax
pushq $0x20
popq %rdi
callq 0x327b9
andq $0x0, 0x10(%rax)
andl $0x0, 0x18(%rax)
movl $0xffe00000, %ecx       # imm = 0xFFE00000
andl 0x1c(%rax), %ecx
orl $0x90000, %ecx          # imm = 0x90000
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ecx, 0x1c(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistRelease
void quicklistRelease(quicklist *quicklist) {
    unsigned long len;
    quicklistNode *current, *next;

    current = quicklist->head;
    len = quicklist->len;
    while (len--) {
        next = current->next;

        zfree(current->zl);
        quicklist->count -= current->count;

        zfree(current);

        quicklist->len--;
        current = next;
    }
    zfree(quicklist);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movl 0x18(%rdi), %r15d
subq $0x1, %r15
jb 0x27299
movq 0x8(%r14), %r12
movq 0x10(%r14), %rdi
callq 0x328f9
movzwl 0x1c(%r14), %eax
subq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x328f9
decl 0x18(%rbx)
movq %r12, %r14
jmp 0x2726d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x328f9
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: _quicklistCompressNode
REDIS_STATIC int __quicklistCompressNode(quicklistNode *node) {
#ifdef REDIS_TEST
    node->attempted_compress = 1;
#endif

    /* Don't bother compressing small values */
    if (node->sz < MIN_COMPRESS_BYTES)
        return 0;

    quicklistLZF *lzf = zmalloc(sizeof(*lzf) + node->sz);

    /* Cancel if compression fails or doesn't compress small enough */
    if (((lzf->sz = lzf_compress(node->zl, node->sz, lzf->compressed,
                                 node->sz)) == 0) ||
        lzf->sz + MIN_COMPRESS_IMPROVE >= node->sz) {
        /* lzf_compress aborts/rejects compression if value not compressable. */
        zfree(lzf);
        return 0;
    }
    lzf = zrealloc(lzf, sizeof(*lzf) + lzf->sz);
    zfree(node->zl);
    node->zl = (unsigned char *)lzf;
    node->encoding = QUICKLIST_NODE_ENCODING_LZF;
    node->recompress = 0;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %edi
xorl %ebp, %ebp
cmpq $0x30, %rdi
jb 0x27326
addq $0x4, %rdi
callq 0x327b9
movq %rax, %r14
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %ecx
leaq 0x4(%rax), %rdx
movl %ecx, %esi
callq 0x32be0
movl %eax, (%r14)
testl %eax, %eax
je 0x2731e
leal 0x8(%rax), %ecx
cmpl 0x18(%rbx), %ecx
jae 0x2731e
movl %eax, %esi
addq $0x4, %rsi
movq %r14, %rdi
callq 0x32863
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x328f9
movq %r14, 0x10(%rbx)
movl $0xffecffff, %eax       # imm = 0xFFECFFFF
andl 0x1c(%rbx), %eax
orl $0x20000, %eax          # imm = 0x20000
movl %eax, 0x1c(%rbx)
pushq $0x1
popq %rbp
jmp 0x27326
movq %r14, %rdi
callq 0x328f9
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: _quicklistDecompressNode
REDIS_STATIC int __quicklistDecompressNode(quicklistNode *node) {
#ifdef REDIS_TEST
    node->attempted_compress = 0;
#endif

    void *decompressed = zmalloc(node->sz);
    quicklistLZF *lzf = (quicklistLZF *)node->zl;
    if (lzf_decompress(lzf->compressed, lzf->sz, decompressed, node->sz) == 0) {
        /* Someone requested decompress, but we can't decompress.  Not good. */
        zfree(decompressed);
        return 0;
    }
    zfree(lzf);
    node->zl = decompressed;
    node->encoding = QUICKLIST_NODE_ENCODING_RAW;
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %edi
callq 0x327b9
movq %rax, %r14
movq 0x10(%rbx), %r15
leaq 0x4(%r15), %rdi
movl (%r15), %esi
movl 0x18(%rbx), %ecx
movq %rax, %rdx
callq 0x33010
testl %eax, %eax
je 0x2737b
movq %r15, %rdi
callq 0x328f9
movq %r14, 0x10(%rbx)
movl $0xfffcffff, %eax       # imm = 0xFFFCFFFF
andl 0x1c(%rbx), %eax
orl $0x10000, %eax          # imm = 0x10000
movl %eax, 0x1c(%rbx)
pushq $0x1
popq %rax
jmp 0x27385
movq %r14, %rdi
callq 0x328f9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: _quicklistInsertNode
REDIS_STATIC void __quicklistInsertNode(quicklist *quicklist,
                                        quicklistNode *old_node,
                                        quicklistNode *new_node, int after) {
    if (after) {
        new_node->prev = old_node;
        if (old_node) {
            new_node->next = old_node->next;
            if (old_node->next)
                old_node->next->prev = new_node;
            old_node->next = new_node;
        }
        if (quicklist->tail == old_node)
            quicklist->tail = new_node;
    } else {
        new_node->next = old_node;
        if (old_node) {
            new_node->prev = old_node->prev;
            if (old_node->prev)
                old_node->prev->next = new_node;
            old_node->prev = new_node;
        }
        if (quicklist->head == old_node)
            quicklist->head = new_node;
    }
    /* If this insert creates the only element so far, initialize head/tail. */
    if (quicklist->len == 0) {
        quicklist->head = quicklist->tail = new_node;
    }

    if (old_node)
        quicklistCompress(quicklist, old_node);

    quicklist->len++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %ecx, %ecx
je 0x274f9
movq %rsi, (%rdx)
testq %rsi, %rsi
je 0x274ed
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdx)
testq %rax, %rax
je 0x274e9
movq %rdx, (%rax)
movq %rdx, 0x8(%rsi)
cmpq %rsi, 0x8(%rbx)
jne 0x2751f
leaq 0x8(%rbx), %rax
jmp 0x2751c
movq %rsi, 0x8(%rdx)
testq %rsi, %rsi
je 0x27514
movq (%rsi), %rax
movq %rax, (%rdx)
testq %rax, %rax
je 0x27511
movq %rdx, 0x8(%rax)
movq %rdx, (%rsi)
movq %rbx, %rax
cmpq %rsi, (%rbx)
jne 0x2751f
movq %rdx, (%rax)
cmpl $0x0, 0x18(%rbx)
jne 0x2752c
movq %rdx, 0x8(%rbx)
movq %rdx, (%rbx)
testq %rsi, %rsi
je 0x27558
movl 0x1c(%rsi), %eax
btl $0x14, %eax
jb 0x27544
movq %rbx, %rdi
callq 0x27399
jmp 0x27558
andl $0x30000, %eax          # imm = 0x30000
cmpl $0x10000, %eax          # imm = 0x10000
jne 0x27558
movq %rsi, %rdi
callq 0x272ac
incl 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistNodeAllowInsert
REDIS_STATIC int _quicklistNodeAllowInsert(const quicklistNode *node,
                                           const int fill, const size_t sz) {
    if (unlikely(!node))
        return 0;

    int ziplist_overhead;
    /* size of previous offset */
    if (sz < 254)
        ziplist_overhead = 1;
    else
        ziplist_overhead = 5;

    /* size of forward offset */
    if (sz < 64)
        ziplist_overhead += 1;
    else if (likely(sz < 16384))
        ziplist_overhead += 2;
    else
        ziplist_overhead += 5;

    /* new_sz overestimates if 'sz' encodes to an integer type */
    unsigned int new_sz = node->sz + sz + ziplist_overhead;
    if (likely(_quicklistNodeSizeMeetsOptimizationRequirement(new_sz, fill)))
        return 1;
    else if (!sizeMeetsSafetyLimit(new_sz))
        return 0;
    else if ((int)node->count < fill)
        return 1;
    else
        return 0;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x275f0
xorl %ecx, %ecx
cmpq $0xfe, %rdx
setae %cl
cmpq $0x4000, %rdx           # imm = 0x4000
leal 0x3(,%rcx,4), %ecx
pushq $0xa
popq %r8
cmovbl %ecx, %r8d
cmpq $0x40, %rdx
pushq $0x2
popq %rcx
cmovael %r8d, %ecx
addl %ecx, %edx
addl 0x18(%rdi), %edx
cmpl $-0x5, %esi
jb 0x275dd
movl %edx, %ecx
movl %esi, %r8d
notl %r8d
leaq 0x86a3d(%rip), %r9      # 0xae010
cmpq %rcx, (%r9,%r8,8)
jb 0x275dd
pushq $0x1
popq %rax
retq
cmpl $0x2000, %edx           # imm = 0x2000
ja 0x275f0
movzwl 0x1c(%rdi), %ecx
xorl %eax, %eax
cmpl %esi, %ecx
setl %al
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistNodeAllowMerge
REDIS_STATIC int _quicklistNodeAllowMerge(const quicklistNode *a,
                                          const quicklistNode *b,
                                          const int fill) {
    if (!a || !b)
        return 0;

    /* approximate merged ziplist size (- 11 to remove one ziplist
     * header/trailer) */
    unsigned int merge_sz = a->sz + b->sz - 11;
    if (likely(_quicklistNodeSizeMeetsOptimizationRequirement(merge_sz, fill)))
        return 1;
    else if (!sizeMeetsSafetyLimit(merge_sz))
        return 0;
    else if ((int)(a->count + b->count) <= fill)
        return 1;
    else
        return 0;
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x2764a
movl 0x18(%rdi), %ecx
movl 0x18(%rsi), %r8d
addl %r8d, %ecx
addl $-0xb, %ecx
cmpl $-0x5, %edx
jb 0x27631
movl %ecx, %r8d
movl %edx, %r9d
notl %r9d
leaq 0x869e9(%rip), %r10     # 0xae010
cmpq %r8, (%r10,%r9,8)
jb 0x27631
pushq $0x1
popq %rax
retq
cmpl $0x2000, %ecx           # imm = 0x2000
ja 0x2764a
movzwl 0x1c(%rdi), %eax
movzwl 0x1c(%rsi), %ecx
addl %eax, %ecx
xorl %eax, %eax
cmpl %edx, %ecx
setle %al
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistPushHead
int quicklistPushHead(quicklist *quicklist, void *value, size_t sz) {
    quicklistNode *orig_head = quicklist->head;
    if (likely(
            _quicklistNodeAllowInsert(quicklist->head, quicklist->fill, sz))) {
        quicklist->head->zl =
            ziplistPush(quicklist->head->zl, value, sz, ZIPLIST_HEAD);
        quicklistNodeUpdateSz(quicklist->head);
    } else {
        quicklistNode *node = quicklistCreateNode();
        node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_HEAD);

        quicklistNodeUpdateSz(node);
        _quicklistInsertNodeBefore(quicklist, quicklist->head, node);
    }
    quicklist->count++;
    quicklist->head->count++;
    return (orig_head != quicklist->head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r14
movswl 0x1c(%rdi), %esi
movq %r14, %rdi
callq 0x27586
testl %eax, %eax
je 0x276b0
movq 0x10(%r14), %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x35aa8
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rax, %rdi
callq 0x35f52
movq (%rbx), %rcx
movl %eax, 0x18(%rcx)
incq 0x10(%rbx)
incw 0x1c(%rcx)
xorl %eax, %eax
cmpq (%rbx), %r14
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2722c
movq %rax, %r13
callq 0x3540c
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x35aa8
movq %rax, 0x10(%r13)
movq %rax, %rdi
callq 0x35f52
movl %eax, 0x18(%r13)
movq (%rbx), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2755d
movq (%rbx), %rcx
jmp 0x27696
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistPushTail
int quicklistPushTail(quicklist *quicklist, void *value, size_t sz) {
    quicklistNode *orig_tail = quicklist->tail;
    if (likely(
            _quicklistNodeAllowInsert(quicklist->tail, quicklist->fill, sz))) {
        quicklist->tail->zl =
            ziplistPush(quicklist->tail->zl, value, sz, ZIPLIST_TAIL);
        quicklistNodeUpdateSz(quicklist->tail);
    } else {
        quicklistNode *node = quicklistCreateNode();
        node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_TAIL);

        quicklistNodeUpdateSz(node);
        _quicklistInsertNodeAfter(quicklist, quicklist->tail, node);
    }
    quicklist->count++;
    quicklist->tail->count++;
    return (orig_tail != quicklist->tail);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movswl 0x1c(%rdi), %esi
movq %r14, %rdi
callq 0x27586
testl %eax, %eax
je 0x2775a
movq 0x10(%r14), %rdi
pushq $0x1
popq %rcx
movq %r12, %rsi
movl %r15d, %edx
callq 0x35aa8
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rax, %rdi
callq 0x35f52
movq 0x8(%rbx), %rcx
movl %eax, 0x18(%rcx)
incq 0x10(%rbx)
incw 0x1c(%rcx)
xorl %eax, %eax
cmpq 0x8(%rbx), %r14
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2722c
movq %rax, %r13
callq 0x3540c
pushq $0x1
popq %rcx
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x35aa8
movq %rax, 0x10(%r13)
movq %rax, %rdi
callq 0x35f52
movl %eax, 0x18(%r13)
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x27564
movq 0x8(%rbx), %rcx
jmp 0x2773f
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistAppendZiplist
void quicklistAppendZiplist(quicklist *quicklist, unsigned char *zl) {
    quicklistNode *node = quicklistCreateNode();

    node->zl = zl;
    node->count = ziplistLen(node->zl);
    node->sz = ziplistBlobLen(zl);

    _quicklistInsertNodeAfter(quicklist, quicklist->tail, node);
    quicklist->count += node->count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2722c
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %rbx, %rdi
callq 0x35f0c
movw %ax, 0x1c(%r15)
movq %rbx, %rdi
callq 0x35f52
movl %eax, 0x18(%r15)
movq 0x8(%r14), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x27564
movzwl 0x1c(%r15), %eax
addq %rax, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistAppendValuesFromZiplist
quicklist *quicklistAppendValuesFromZiplist(quicklist *quicklist,
                                            unsigned char *zl) {
    unsigned char *value;
    unsigned int sz;
    long long longval;
    char longstr[32] = {0};

    unsigned char *p = ziplistIndex(zl, 0);
    while (ziplistGet(p, &value, &sz, &longval)) {
        if (!value) {
            /* Write the longval as a string so we can re-add it */
            sz = ll2string(longstr, sizeof(longstr), longval);
            value = (unsigned char *)longstr;
        }
        quicklistPushTail(quicklist, value, sz);
        p = ziplistNext(zl, p);
    }
    zfree(zl);
    return quicklist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x35aca
movq %rax, %rbp
leaq 0xc(%rsp), %r13
leaq 0x18(%rsp), %r12
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x35be8
testl %eax, %eax
je 0x27884
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2784e
movl 0xc(%rsp), %eax
jmp 0x2786a
movq 0x18(%rsp), %rdx
movq %r15, %rdi
pushq $0x20
popq %rsi
callq 0x39796
movl %eax, 0xc(%rsp)
movq %r15, 0x10(%rsp)
movq %r15, %rsi
movl %eax, %edx
movq %rbx, %rdi
callq 0x276f0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x35b60
movq %rax, %rbp
jmp 0x27827
movq %r14, %rdi
callq 0x328f9
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: _quicklistDelNode
REDIS_STATIC void __quicklistDelNode(quicklist *quicklist,
                                     quicklistNode *node) {
    if (node->next)
        node->next->prev = node->prev;
    if (node->prev)
        node->prev->next = node->next;

    if (node == quicklist->tail) {
        quicklist->tail = node->prev;
    }

    if (node == quicklist->head) {
        quicklist->head = node->next;
    }

    /* If we deleted a node within our compress depth, we
     * now have compressed nodes needing to be decompressed. */
    __quicklistCompress(quicklist, NULL);

    quicklist->count -= node->count;

    zfree(node->zl);
    zfree(node);
    quicklist->len--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x278cc
movq %rax, (%rcx)
testq %rax, %rax
je 0x278d5
movq %rcx, 0x8(%rax)
cmpq %r14, 0x8(%rbx)
jne 0x278df
movq %rax, 0x8(%rbx)
cmpq %r14, (%rbx)
jne 0x278eb
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x27399
movzwl 0x1c(%r14), %eax
subq %rax, 0x10(%rbx)
movq 0x10(%r14), %rdi
callq 0x328f9
movq %r14, %rdi
callq 0x328f9
decl 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistDelIndex
REDIS_STATIC int quicklistDelIndex(quicklist *quicklist, quicklistNode *node,
                                   unsigned char **p) {
    int gone = 0;

    node->zl = ziplistDelete(node->zl, p);
    node->count--;
    if (node->count == 0) {
        gone = 1;
        __quicklistDelNode(quicklist, node);
    } else {
        quicklistNodeUpdateSz(node);
    }
    quicklist->count--;
    /* If we deleted the node, the original node is no longer valid */
    return gone ? 1 : 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
movq %rdx, %rsi
callq 0x35c78
movq %rax, 0x10(%r14)
movl 0x1c(%r14), %ebp
decl %ebp
movw %bp, 0x1c(%r14)
andl $0xffff, %ebp           # imm = 0xFFFF
je 0x27955
movq %rax, %rdi
callq 0x35f52
movl %eax, 0x18(%r14)
jmp 0x27960
movq %rbx, %rdi
movq %r14, %rsi
callq 0x278b3
xorl %eax, %eax
testl %ebp, %ebp
sete %al
decq 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistDelEntry
void quicklistDelEntry(quicklistIter *iter, quicklistEntry *entry) {
    quicklistNode *prev = entry->node->prev;
    quicklistNode *next = entry->node->next;
    int deleted_node = quicklistDelIndex((quicklist *)entry->quicklist,
                                         entry->node, &entry->zi);

    /* after delete, the zi is now invalid for any future usage. */
    iter->zi = NULL;

    /* If current node is deleted, we must update iterator node and offset. */
    if (deleted_node) {
        if (iter->direction == AL_START_HEAD) {
            iter->current = next;
            iter->offset = 0;
        } else if (iter->direction == AL_START_TAIL) {
            iter->current = prev;
            iter->offset = -1;
        }
    }
    /* else if (!deleted_node), no changes needed.
     * we already reset iter->zi above, and the existing iter->offset
     * doesn't move again because:
     *   - [1, 2, 3] => delete offset 1 => [1, 3]: next element still offset 1
     *   - [1, 2, 3] => delete offset 0 => [2, 3]: next element still offset 0
     *  if we deleted the last element at offet N and now
     *  length of this ziplist is N-1, the next call into
     *  quicklistNext() will jump to the next node. */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
leaq 0x10(%rsi), %rdx
movq %rax, %rsi
callq 0x2791a
andq $0x0, 0x10(%rbx)
testl %eax, %eax
je 0x279b8
movl 0x20(%rbx), %eax
testq %rax, %rax
je 0x279ad
cmpl $0x1, %eax
jne 0x279b8
pushq $-0x1
popq %rax
jmp 0x279b0
movq %r15, %r14
movq %r14, 0x8(%rbx)
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistReplaceAtIndex
int quicklistReplaceAtIndex(quicklist *quicklist, long index, void *data,
                            int sz) {
    quicklistEntry entry;
    if (likely(quicklistIndex(quicklist, index, &entry))) {
        /* quicklistIndex provides an uncompressed node */
        entry.node->zl = ziplistDelete(entry.node->zl, &entry.zi);
        entry.node->zl = ziplistInsert(entry.node->zl, entry.zi, data, sz);
        quicklistNodeUpdateSz(entry.node);
        quicklistCompress(quicklist, entry.node);
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x27a60
testl %eax, %eax
je 0x27a5c
leaq 0x18(%rsp), %r15
movq -0x8(%r15), %rax
movq 0x10(%rax), %rdi
movq %r15, %rsi
callq 0x35c78
movq -0x8(%r15), %rcx
movq %rax, 0x10(%rcx)
movq (%r15), %rsi
movq %rax, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x35c73
movq -0x8(%r15), %rcx
movq %rax, 0x10(%rcx)
movq %rax, %rdi
callq 0x35f52
movq -0x8(%r15), %rsi
movl %eax, 0x18(%rsi)
movl 0x1c(%rsi), %eax
btl $0x14, %eax
jb 0x27a38
movq %rbx, %rdi
callq 0x27399
pushq $0x1
popq %rbx
jmp 0x27a4f
andl $0x30000, %eax          # imm = 0x30000
pushq $0x1
popq %rbx
cmpl $0x10000, %eax          # imm = 0x10000
jne 0x27a4f
movq %rsi, %rdi
callq 0x272ac
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x27a4f
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/quicklist.c
// Function: quicklistIndex
int quicklistIndex(const quicklist *quicklist, const long long idx,
                   quicklistEntry *entry) {
    quicklistNode *n;
    unsigned long long accum = 0;
    unsigned long long index;
    int forward = idx < 0 ? 0 : 1; /* < 0 -> reverse, 0+ -> forward */

    initEntry(entry);
    entry->quicklist = quicklist;

    if (!forward) {
        index = (-idx) - 1;
        n = quicklist->tail;
    } else {
        index = idx;
        n = quicklist->head;
    }

    if (index >= quicklist->count)
        return 0;

    while (likely(n)) {
        if ((accum + n->count) > index) {
            break;
        } else {
            D("Skipping over (%p) %u at accum %lld", (void *)n, n->count,
              accum);
            accum += n->count;
            n = forward ? n->next : n->prev;
        }
    }

    if (!n)
        return 0;

    D("Found node: %p at accum %llu, idx %llu, sub+ %llu, sub- %llu", (void *)n,
      accum, index, index - accum, (-index) - 1 + accum);

    entry->node = n;
    if (forward) {
        /* forward = normal head-to-tail offset. */
        entry->offset = index - accum;
    } else {
        /* reverse = need negative offset for tail-to-head, so undo
         * the result of the original if (index < 0) above. */
        entry->offset = (-index) - 1 + accum;
    }

    quicklistDecompressNodeForUse(entry->node);
    entry->zi = ziplistIndex(entry->node->zl, entry->offset);
    ziplistGet(entry->zi, &entry->value, &entry->sz, &entry->longval);
    /* The caller will use our result, so we don't re-compress here.
     * The caller can recompress or delete the node as needed. */
    return 1;
}

// Assembly:
movq %rsi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
movq $-0x75bcd15, 0x20(%rdx) # imm = 0xF8A432EB
andq $0x0, 0x8(%rdx)
movabsq $0x75bcd1500000000, %rax # imm = 0x75BCD1500000000
movq %rax, 0x28(%rdx)
movq %rdi, (%rdx)
sarq $0x3f, %rsi
xorq %rcx, %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
jae 0x27b58
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
leaq 0x18(%rdx), %rbx
leaq 0x10(%rdx), %r13
leaq 0x20(%rdx), %r14
leaq 0x28(%rdx), %r12
xorl %edx, %edx
testq %rcx, %rcx
setns %dl
movq %rcx, %rax
shrq $0x3f, %rax
leaq (%rdi,%rax,8), %rdi
shll $0x3, %edx
xorl %eax, %eax
xorl %r8d, %r8d
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x27b4f
movzwl 0x1c(%rdi), %r9d
addq %r8, %r9
cmpq %rsi, %r9
ja 0x27aef
addq %rdx, %rdi
movq %r9, %r8
jmp 0x27ad2
movl %esi, %eax
notl %eax
addl %r8d, %eax
subl %r8d, %esi
testq %rcx, %rcx
movq %rdi, 0x8(%r15)
cmovsl %eax, %esi
movl %esi, 0x2c(%r15)
movl $0x30000, %eax          # imm = 0x30000
andl 0x1c(%rdi), %eax
cmpl $0x20000, %eax          # imm = 0x20000
jne 0x27b2e
callq 0x2732d
movq 0x8(%r15), %rax
orl $0x100000, 0x1c(%rax)   # imm = 0x100000
movq 0x8(%r15), %rdi
movl 0x2c(%r15), %esi
movq 0x10(%rdi), %rdi
callq 0x35aca
movq %rax, (%r13)
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x35be8
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq