LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/sysendian.h
// Function: libcperciva_be64enc
static inline void
be64enc(void * pp, uint64_t x)
{
	uint8_t * p = (uint8_t *)pp;

	p[7] = x & 0xff;
	p[6] = (x >> 8) & 0xff;
	p[5] = (x >> 16) & 0xff;
	p[4] = (x >> 24) & 0xff;
	p[3] = (x >> 32) & 0xff;
	p[2] = (x >> 40) & 0xff;
	p[1] = (x >> 48) & 0xff;
	p[0] = (x >> 56) & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
shrq $0x28, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
shrq $0x30, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
shrq $0x38, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/wire/wire_writepacket.c
// Function: wire_writepacket_done
int
wire_writepacket_done(struct netbuf_write * W, uint8_t * wbuf, size_t len)
{
	CRC32C_CTX ctx;
	uint8_t cbuf[4];
	size_t i;
	uint8_t * header_crc;

	/*
	 * This is safe due to the requirement that ${wbuf} be the pointer
	 * returned by wire_writepacket_getbuf -- that function returns
	 * &wbuf[16], so position [-4] in the new buffer is still within
	 * the allocated memory.
	 */
	header_crc = &wbuf[-4];

	/* Compute the CRC32C of the packet data. */
	CRC32C_Init(&ctx);
	CRC32C_Update(&ctx, wbuf, len);
	CRC32C_Final(cbuf, &ctx);

	/* Write the trailer. */
	for (i = 0; i < 4; i++)
		wbuf[len + i] = cbuf[i] ^ header_crc[i];

	/* We've finished constructing the packet. */
	if (netbuf_write_consume(W, len + 20))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x38(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x9ff0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rdi
callq 0xa190
leaq -0x28(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xa300
movq $0x0, -0x30(%rbp)
cmpq $0x4, -0x30(%rbp)
jae 0x9edc
movq -0x30(%rbp), %rax
movzbl -0x28(%rbp,%rax), %eax
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
addq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9e9f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x14, %rsi
callq 0xbf90
cmpl $0x0, %eax
je 0x9ef4
jmp 0x9efd
movl $0x0, -0x4(%rbp)
jmp 0x9f04
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/wire/wire_writepacket.c
// Function: wire_writepacket
int
wire_writepacket(struct netbuf_write * W, const struct wire_packet * packet)
{
	uint8_t * wbuf;

	/* Write the packet header. */
	if ((wbuf =
	    wire_writepacket_getbuf(W, packet->ID, packet->len)) == NULL)
		goto err0;

	/* Copy the packet data into place. */
	memcpy(wbuf, packet->buf, packet->len);

	/* Write the packet trailer. */
	if (wire_writepacket_done(W, wbuf, packet->len))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x9c10
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x9f44
jmp 0x9f82
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2210
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x9e50
cmpl $0x0, %eax
je 0x9f79
jmp 0x9f82
movl $0x0, -0x4(%rbp)
jmp 0x9f89
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/crc32c.c
// Function: init
static void
init(void)
{
	size_t i;
	uint32_t r;

	/* Fill in tables. */
	for (i = 0; i < 256; i++) {
		r = reverse((uint32_t)i);
		T0[i] = reverse(r = times256(r));
		T1[i] = reverse(r = times256(r));
		T2[i] = reverse(r = times256(r));
		T3[i] = reverse(r = times256(r));

		(void)r; /* r is not used beyond this point. */
	}

	/* Make sure we optimized correctly. */
	assert(T0[0x80] == T_0_0x80);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0x100, -0x8(%rbp)      # imm = 0x100
jae 0xa0f5
movq -0x8(%rbp), %rax
movl %eax, %edi
callq 0xa370
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0xa410
movl %eax, %edi
movl %edi, -0xc(%rbp)
callq 0xa370
movl %eax, %edx
movq -0x8(%rbp), %rcx
leaq 0x3b665(%rip), %rax     # 0x456e0
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %edi
callq 0xa410
movl %eax, %edi
movl %edi, -0xc(%rbp)
callq 0xa370
movl %eax, %edx
movq -0x8(%rbp), %rcx
leaq 0x3ba43(%rip), %rax     # 0x45ae0
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %edi
callq 0xa410
movl %eax, %edi
movl %edi, -0xc(%rbp)
callq 0xa370
movl %eax, %edx
movq -0x8(%rbp), %rcx
leaq 0x3be21(%rip), %rax     # 0x45ee0
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %edi
callq 0xa410
movl %eax, %edi
movl %edi, -0xc(%rbp)
callq 0xa370
movl %eax, %edx
movq -0x8(%rbp), %rcx
leaq 0x3c1ff(%rip), %rax     # 0x462e0
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xa040
cmpl $0x82f63b78, 0x3b7e1(%rip) # imm = 0x82F63B78
jne 0xa103
jmp 0xa122
leaq 0x5e91(%rip), %rdi      # 0xff9b
leaq 0x5e9f(%rip), %rsi      # 0xffb0
movl $0x61, %edx
leaq 0x5eaf(%rip), %rcx      # 0xffcc
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/crc32c.c
// Function: hwaccel_init
static void
hwaccel_init(void)
{

	/* If we've already set hwaccel, we're finished. */
	if (hwaccel != HW_UNSET)
		return;

	/* Default to software. */
	hwaccel = HW_SOFTWARE;

#if defined(CPUSUPPORT_X86_SSE42)
	CPUSUPPORT_VALIDATE(hwaccel, HW_X86_CRC32, cpusupport_x86_sse42(),
	    hwtest());
#endif
#if defined(CPUSUPPORT_ARM_CRC32_64)
	CPUSUPPORT_VALIDATE(hwaccel, HW_ARM_CRC32_64, cpusupport_arm_crc32_64(),
	    hwtest());
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, 0xb415(%rip)      # 0x15550
je 0xa13f
jmp 0xa18a
movl $0x0, 0xb407(%rip)      # 0x15550
callq 0xa460
cmpl $0x0, %eax
je 0xa188
callq 0xa4d0
cmpl $0x0, %eax
jne 0xa169
movl $0x1, 0xb3e9(%rip)      # 0x15550
jmp 0xa18a
jmp 0xa16b
leaq 0x5e6a(%rip), %rdi      # 0xffdc
movb $0x0, %al
callq 0x6a10
callq 0x20a0
movl $0x0, (%rax)
jmp 0xa186
jmp 0xa188
jmp 0xa18a
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/crc32c.c
// Function: CRC32C_Update
void
CRC32C_Update(CRC32C_CTX * ctx, const uint8_t * buf, size_t len)
{

#if defined(CPUSUPPORT_X86_SSE42)
	if ((len >= 8) && (hwaccel == HW_X86_CRC32)) {
		ctx->state = CRC32C_Update_SSE42(ctx->state, buf, len);
		return;
	}
#endif
#if defined(CPUSUPPORT_ARM_CRC32_64)
	if ((len >= 8) && (hwaccel == HW_ARM_CRC32_64)) {
		ctx->state = CRC32C_Update_ARM(ctx->state, buf, len);
		return;
	}
#endif

	/* Handle blocks of 4 bytes. */
	for (; len >= 4; len -= 4, buf += 4) {
		ctx->state =
		    T0[((ctx->state >> 24) & 0xff) ^ buf[3]] ^
		    T1[((ctx->state >> 16) & 0xff) ^ buf[2]] ^
		    T2[((ctx->state >> 8)  & 0xff) ^ buf[1]] ^
		    T3[((ctx->state)       & 0xff) ^ buf[0]];
	}

	/* Handle individual bytes. */
	for (; len > 0; len--, buf++) {
		ctx->state = (ctx->state >> 8) ^
		    T0[((ctx->state) & 0xff) ^ buf[0]];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jb 0xa1d4
cmpl $0x1, 0xb39e(%rip)      # 0x15550
jne 0xa1d4
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa580
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0xa2ec
jmp 0xa1d6
cmpq $0x4, -0x18(%rbp)
jb 0xa298
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x18, %eax
andl $0xff, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
xorl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3b4dc(%rip), %rax     # 0x456e0
movl (%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
andl $0xff, %eax
movq -0x10(%rbp), %rdx
movzbl 0x2(%rdx), %edx
xorl %edx, %eax
movl %eax, %eax
movl %eax, %edx
leaq 0x3b8b6(%rip), %rax     # 0x45ae0
xorl (%rax,%rdx,4), %ecx
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
movq -0x10(%rbp), %rdx
movzbl 0x1(%rdx), %edx
xorl %edx, %eax
movl %eax, %eax
movl %eax, %edx
leaq 0x3bc90(%rip), %rax     # 0x45ee0
xorl (%rax,%rdx,4), %ecx
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movq -0x10(%rbp), %rdx
movzbl (%rdx), %edx
xorl %edx, %eax
movl %eax, %eax
movl %eax, %edx
leaq 0x3c06e(%rip), %rax     # 0x462e0
xorl (%rax,%rdx,4), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0xa1d6
jmp 0xa29a
cmpq $0x0, -0x18(%rbp)
jbe 0xa2ec
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shrl $0x8, %ecx
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movq -0x10(%rbp), %rdx
movzbl (%rdx), %edx
xorl %edx, %eax
movl %eax, %eax
movl %eax, %edx
leaq 0x3b417(%rip), %rax     # 0x456e0
xorl (%rax,%rdx,4), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa29a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/crc32c.c
// Function: CRC32C_Final
void
CRC32C_Final(uint8_t cbuf[4], const CRC32C_CTX * ctx)
{

	/* Copy state out. */
	cbuf[0] = ctx->state & 0xff;
	cbuf[1] = (ctx->state >> 8) & 0xff;
	cbuf[2] = (ctx->state >> 16) & 0xff;
	cbuf[3] = (ctx->state >> 24) & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/crc32c.c
// Function: reverse
static uint32_t
reverse(uint32_t x)
{

	x = ((x & 0xffff0000) >> 16) | ((x & 0x0000ffff) << 16);
	x = ((x & 0xff00ff00) >> 8)  | ((x & 0x00ff00ff) << 8);
	x = ((x & 0xf0f0f0f0) >> 4)  | ((x & 0x0f0f0f0f) << 4);
	x = ((x & 0xcccccccc) >> 2)  | ((x & 0x33333333) << 2);
	x = ((x & 0xaaaaaaaa) >> 1)  | ((x & 0x55555555) << 1);

	return (x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xffff0000, %eax       # imm = 0xFFFF0000
shrl $0x10, %eax
movl -0x4(%rbp), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff00ff00, %eax       # imm = 0xFF00FF00
shrl $0x8, %eax
movl -0x4(%rbp), %ecx
andl $0xff00ff, %ecx         # imm = 0xFF00FF
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xf0f0f0f0, %eax       # imm = 0xF0F0F0F0
shrl $0x4, %eax
movl -0x4(%rbp), %ecx
andl $0xf0f0f0f, %ecx        # imm = 0xF0F0F0F
shll $0x4, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xcccccccc, %eax       # imm = 0xCCCCCCCC
shrl $0x2, %eax
movl -0x4(%rbp), %ecx
andl $0x33333333, %ecx       # imm = 0x33333333
shll $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xaaaaaaaa, %eax       # imm = 0xAAAAAAAA
shrl %eax
movl -0x4(%rbp), %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
shll %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/crc32c.c
// Function: times256
static uint32_t
times256(uint32_t r)
{
	int k;

	/* Shift left one bit at a time. */
	for (k = 0; k < 8; k++) {
		if (r & 0x80000000)
			r = (r << 1) ^ 0x1EDC6F41;
		else
			r = (r << 1);
	}

	return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jge 0xa455
movl -0x4(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0xa440
movl -0x4(%rbp), %eax
shll %eax
xorl $0x1edc6f41, %eax       # imm = 0x1EDC6F41
movl %eax, -0x4(%rbp)
jmp 0xa448
movl -0x4(%rbp), %eax
shll %eax
movl %eax, -0x4(%rbp)
jmp 0xa44a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa41e
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/crc32c.c
// Function: hwtest
static int
hwtest(void)
{
	uint32_t state = T_0_0x80;

	/* Test hardware transform function. */
#if defined(CPUSUPPORT_X86_SSE42)
	state = CRC32C_Update_SSE42(state, (const uint8_t *)testcase.buf,
	    strlen(testcase.buf));
#elif defined(CPUSUPPORT_ARM_CRC32_64)
	state = CRC32C_Update_ARM(state, (const uint8_t *)testcase.buf,
	    strlen(testcase.buf));
#endif

	/* Is the output correct? */
	return (memcmp(&state, testcase.crc, 4));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x82f63b78, -0x4(%rbp) # imm = 0x82F63B78
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movq 0xb06c(%rip), %rax      # 0x15558
movq %rax, -0x10(%rbp)
movq 0xb061(%rip), %rdi      # 0x15558
callq 0x2120
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0xa580
movl %eax, -0x4(%rbp)
leaq 0xb04b(%rip), %rsi      # 0x15560
leaq -0x4(%rbp), %rdi
movl $0x4, %edx
callq 0x21e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/seqptrmap.c
// Function: seqptrmap_init
struct seqptrmap *
seqptrmap_init(void)
{
	struct seqptrmap * M;

	/* Allocate structure. */
	if ((M = malloc(sizeof(struct seqptrmap))) == NULL)
		goto err0;

	/* Nothing in here yet. */
	M->offset = 0;
	M->len = 0;

	/* Allocate empty queue. */
	if ((M->ptrs = elasticqueue_init(sizeof(void *))) == NULL)
		goto err1;

	/* Success! */
	return (M);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x2230
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xaf1e
jmp 0xaf62
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x8, %edi
callq 0xda10
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xaf4f
jmp 0xaf59
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaf6a
movq -0x10(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/seqptrmap.c
// Function: seqptrmap_add
int64_t
seqptrmap_add(struct seqptrmap * M, void * ptr)
{

	/* Add the pointer to the end of the queue. */
	if (elasticqueue_add(M->ptrs, &ptr))
		goto err0;
	M->len += 1;

	/* Check for overflow. */
#if SIZE_MAX > INT64_MAX
	assert(M->len <= (uint64_t)INT64_MAX);
#endif
	assert(INT64_MAX - (int64_t)M->len >= M->offset);

	/* Return associated integer. */
	return (M->offset + (int64_t)M->len - 1);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0xdad0
cmpl $0x0, %eax
je 0xafaa
jmp 0xb046
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
ja 0xafd0
jmp 0xafef
leaq 0x51e8(%rip), %rdi      # 0x101bf
leaq 0x51ff(%rip), %rsi      # 0x101dd
movl $0x3e, %edx
leaq 0x5219(%rip), %rcx      # 0x10203
callq 0x21a0
movq -0x10(%rbp), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
subq 0x10(%rcx), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0xb00d
jmp 0xb02c
leaq 0x5221(%rip), %rdi      # 0x10235
leaq 0x51c2(%rip), %rsi      # 0x101dd
movl $0x40, %edx
leaq 0x51dc(%rip), %rcx      # 0x10203
callq 0x21a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xb04e
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/seqptrmap.c
// Function: seqptrmap_get
void *
seqptrmap_get(struct seqptrmap * M, int64_t i)
{

	/* No valid pointer is less than the offset. */
	if (i < M->offset)
		return (NULL);

	/*
	 * If the provided integer is not within the bounds of our elastic
	 * queue, there is no associated pointer and we return NULL.
	 */
	if ((uint64_t)(i - M->offset) >= (uint64_t)(M->len))
		return (NULL);

	/*
	 * Since the provided integer is within the bounds of our elastic
	 * queue, look up the pointer.
	 */
	return (*(void **)elasticqueue_get(M->ptrs, (size_t)(i - M->offset)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0xb088
movq $0x0, -0x8(%rbp)
jmp 0xb0c7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xb0a8
movq $0x0, -0x8(%rbp)
jmp 0xb0c7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0xdc50
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/seqptrmap.c
// Function: seqptrmap_delete
void
seqptrmap_delete(struct seqptrmap * M, int64_t i)
{

	/* No valid pointer is less than the offset. */
	if (i < M->offset)
		return;

	/*
	 * If the provided integer is not within the bounds of our elastic
	 * queue, return without taking any action.
	 */
	if ((uint64_t)(i - M->offset) >= (uint64_t)(M->len))
		return;

	/* Delete the specified pointer by setting it to NULL. */
	*(void **)elasticqueue_get(M->ptrs, (size_t)(i - M->offset)) = NULL;

	/* Delete leading NULLs from the queue. */
	while ((elasticqueue_getlen(M->ptrs) > 0) &&
	    (*(void **)elasticqueue_get(M->ptrs, 0) == NULL)) {
		elasticqueue_delete(M->ptrs);
		M->offset += 1;
		M->len -= 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0xb143
jmp 0xb1e8
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x8(%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xb15e
jmp 0xb1e8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0xdc50
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xdc30
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x11(%rbp)
jbe 0xb1b1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdc50
cmpq $0x0, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xb1ba
jmp 0xb1e8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xdb30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xb17d
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/seqptrmap.c
// Function: seqptrmap_free
void
seqptrmap_free(struct seqptrmap * M)
{

	/* Behave consistently with free(NULL). */
	if (M == NULL)
		return;

	elasticqueue_free(M->ptrs);
	free(M);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb205
jmp 0xb21a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xdcb0
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_read.c
// Function: netbuf_read_init2
struct netbuf_read *
netbuf_read_init2(int s, struct network_ssl_ctx * ssl)
{
	struct netbuf_read * R;

	/* Bake a cookie. */
	if ((R = malloc(sizeof(struct netbuf_read))) == NULL)
		goto err0;
	R->s = s;
	R->ssl = ssl;
	R->read_cookie = NULL;
	R->immediate_cookie = NULL;

	/* Allocate buffer. */
	R->buflen = 4096;
	if ((R->buf = malloc(R->buflen)) == NULL)
		goto err1;
	R->bufpos = 0;
	R->datalen = 0;

	/* Success! */
	return (R);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x50, %edi
callq 0x2230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xb608
jmp 0xb689
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x1000, 0x38(%rax)     # imm = 0x1000
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2230
movq -0x20(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0xb65e
jmp 0xb680
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb691
movq -0x20(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_read.c
// Function: callback_success
static int
callback_success(void * cookie)
{
	struct netbuf_read * R = cookie;

	/* Sanity-check: We should be expecting this callback. */
	assert(R->immediate_cookie != NULL);

	/* This callback is no longer pending. */
	R->immediate_cookie = NULL;

	/* Perform callback. */
	return ((R->callback)(R->cookie, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xb941
jmp 0xb960
leaq 0x4a3f(%rip), %rdi      # 0x10387
leaq 0x4926(%rip), %rsi      # 0x10275
movl $0xd0, %edx
leaq 0x4a48(%rip), %rcx      # 0x103a3
callq 0x21a0
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_read.c
// Function: netbuf_read_resize_buffer
static int
netbuf_read_resize_buffer(struct netbuf_read * R, size_t len)
{
	uint8_t * nbuf;
	size_t nbuflen;

	/* Compute new buffer size. */
	nbuflen = R->buflen * 2;
	if (nbuflen < len)
		nbuflen = len;

	/* Allocate new buffer. */
	if ((nbuf = malloc(nbuflen)) == NULL)
		goto err0;

	/* Copy data into new buffer. */
	memcpy(nbuf, &R->buf[R->bufpos], R->datalen - R->bufpos);

	/* Free old buffer and use new buffer. */
	free(R->buf);
	R->buf = nbuf;
	R->buflen = nbuflen;
	R->datalen -= R->bufpos;
	R->bufpos = 0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb9c1
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xb9d6
jmp 0xba50
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x10(%rbp), %rax
subq 0x40(%rax), %rdx
callq 0x2210
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xba57
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_read.c
// Function: callback_read
static int
callback_read(void * cookie, ssize_t lenread)
{
	struct netbuf_read * R = cookie;

	/* Sanity-check: We should be reading. */
	assert(R->read_cookie != NULL);

	/* This callback is no longer pending. */
	R->read_cookie = NULL;

	/* Did the read fail? */
	if (lenread < 0)
		goto failed;

	/* Did we hit EOF? */
	if (lenread == 0)
		goto eof;

	/* We've got more data. */
	R->datalen += (size_t)lenread;

	/* Perform callback. */
	return ((R->callback)(R->cookie, 0));

eof:
	/* Perform EOF callback. */
	return ((R->callback)(R->cookie, 1));

failed:
	/* Perform failure callback. */
	return ((R->callback)(R->cookie, -1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xba85
jmp 0xbaa4
leaq 0x4934(%rip), %rdi      # 0x103c0
leaq 0x47e2(%rip), %rsi      # 0x10275
movl $0xe0, %edx
leaq 0x4938(%rip), %rcx      # 0x103d7
callq 0x21a0
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
cmpq $0x0, -0x18(%rbp)
jge 0xbab9
jmp 0xbb07
cmpq $0x0, -0x18(%rbp)
jne 0xbac2
jmp 0xbaeb
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x48(%rax), %rcx
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rdi
xorl %esi, %esi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xbb21
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rdi
movl $0x1, %esi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xbb21
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_read.c
// Function: netbuf_read_wait_cancel
void
netbuf_read_wait_cancel(struct netbuf_read * R)
{

	/* If we have an in-progress read, cancel it. */
	if (R->read_cookie != NULL) {
		if (R->ssl)
			(netbuf_read_ssl_cancel_func)(R->read_cookie);
		else
			network_read_cancel(R->read_cookie);
		R->read_cookie = NULL;
	}

	/* If we have an immediate callback pending, cancel it. */
	if (R->immediate_cookie != NULL) {
		events_immediate_cancel(R->immediate_cookie);
		R->immediate_cookie = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xbb7e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xbb65
movq 0x3ab97(%rip), %rax     # 0x466f0
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
jmp 0xbb72
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xc7e0
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xbba2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3100
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_read.c
// Function: netbuf_read_free
void
netbuf_read_free(struct netbuf_read * R)
{

	/* Behave consistently with free(NULL). */
	if (R == NULL)
		return;

	/* Can't free a reader which is busy. */
	assert(R->read_cookie == NULL);
	assert(R->immediate_cookie == NULL);

	/* Free the buffer and the reader. */
	free(R->buf);
	free(R);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbc25
jmp 0xbc93
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xbc32
jmp 0xbc51
leaq 0x4625(%rip), %rdi      # 0x1025e
leaq 0x4635(%rip), %rsi      # 0x10275
movl $0x132, %edx            # imm = 0x132
leaq 0x470f(%rip), %rcx      # 0x1035b
callq 0x21a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xbc5e
jmp 0xbc7d
leaq 0x4685(%rip), %rdi      # 0x102ea
leaq 0x4609(%rip), %rsi      # 0x10275
movl $0x133, %edx            # imm = 0x133
leaq 0x46e3(%rip), %rcx      # 0x1035b
callq 0x21a0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_write.c
// Function: netbuf_write_init2
struct netbuf_write *
netbuf_write_init2(int s, struct network_ssl_ctx * ssl,
    int (* fail_callback)(void *), void * fail_cookie)
{
	struct netbuf_write * W;
	int val;

	/* Bake a cookie. */
	if ((W = malloc(sizeof(struct netbuf_write))) == NULL)
		goto err0;
	W->s = s;
	W->ssl = ssl;
	W->reserved = 0;
	W->failed = 0;
	W->fail_callback = (fail_callback != NULL) ? fail_callback : dummyfail;
	W->fail_cookie = fail_cookie;
	STAILQ_INIT(&W->buffers);
	W->write_cookie = NULL;
	W->curr = NULL;

	/* Additional configuration if we're using a socket. */
	if (W->ssl == NULL) {
		/* Sanity check. */
		assert(W->s >= 0);

		/*
		 * Request that the OS not attempt to coalesce small segments.
		 * We do this ourselves, and we're smarter than the OS is.  We
		 * don't check the error code here, because POSIX does not
		 * require that TCP_NODELAY be implemented (although it must
		 * be defined); and we might not even be operating on a TCP
		 * socket.
		 */
		val = 1;
		(void)setsockopt(W->s, IPPROTO_TCP, TCP_NODELAY, &val,
		    sizeof(int));
	}

	/* Success! */
	return (W);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x48, %edi
callq 0x2230
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xbd00
jmp 0xbdfa
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x14(%rax)
cmpq $0x0, -0x20(%rbp)
je 0xbd3c
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xbd49
leaq 0xcd(%rip), %rax        # 0xbe10
movq %rax, -0x40(%rbp)
jmp 0xbd49
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x30(%rbp), %rcx
addq $0x28, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xbdf0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jl 0xbdab
jmp 0xbdca
leaq 0x4648(%rip), %rdi      # 0x103fa
leaq 0x464b(%rip), %rsi      # 0x10404
movl $0xc3, %edx
leaq 0x4664(%rip), %rcx      # 0x10429
callq 0x21a0
movl $0x1, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x34(%rbp), %rcx
movl $0x4, %r8d
callq 0x20f0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbe02
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_write.c
// Function: netbuf_write_reserve
uint8_t *
netbuf_write_reserve(struct netbuf_write * W, size_t len)
{
	struct writebuf * WB;

	/* Sanity-check: No calls while buffer space reserved. */
	assert(W->reserved == 0);

	/* We're reserving some space. */
	W->reserved = 1;

	/* Do we have a buffer with enough space?  Return it. */
	if ((WB = STAILQ_LAST(&W->buffers, writebuf, entries)) != NULL) {
		if (WB->buflen - WB->datalen >= len)
			goto oldbuf;
	}

	/* We need to add a new buffer to the queue. */
	if ((WB = malloc(sizeof(struct writebuf))) == NULL)
		goto err0;

	/* We want to hold this write or WBUFLEN of small writes. */
	if (len > WBUFLEN)
		WB->buflen = len;
	else
		WB->buflen = WBUFLEN;

	/* Allocate memory. */
	if ((WB->buf = malloc(WB->buflen)) == NULL)
		goto err1;

	/* No data in this buffer yet. */
	WB->datalen = 0;

	/* Add this buffer to the queue. */
	STAILQ_INSERT_TAIL(&W->buffers, WB, entries);

	/* Return a pointer to the new buffer. */
	return (WB->buf);

oldbuf:
	/* Return a pointer into the old buffer. */
	return (&WB->buf[WB->datalen]);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xbe3c
jmp 0xbe5b
leaq 0x4646(%rip), %rdi      # 0x10489
leaq 0x45ba(%rip), %rsi      # 0x10404
movl $0xe8, %edx
leaq 0x4644(%rip), %rcx      # 0x1049a
callq 0x21a0
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xbe79
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0xbe89
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
addq $-0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbeb4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
subq 0x10(%rcx), %rax
cmpq -0x18(%rbp), %rax
jb 0xbeb2
jmp 0xbf51
jmp 0xbeb4
movl $0x20, %edi
callq 0x2230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xbecd
jmp 0xbf6f
cmpq $0x1000, -0x18(%rbp)    # imm = 0x1000
jbe 0xbee5
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xbef1
movq -0x20(%rbp), %rax
movq $0x1000, 0x8(%rax)      # imm = 0x1000
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2230
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xbf0d
jmp 0xbf66
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbf77
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0xbf77
movq -0x20(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_write.c
// Function: netbuf_write_consume
int
netbuf_write_consume(struct netbuf_write * W, size_t len)
{
	struct writebuf * WB;

	/* Sanity-check: We must have space reserved. */
	assert(W->reserved == 1);

	/* Get the old buffer. */
	WB = STAILQ_LAST(&W->buffers, writebuf, entries);

	/* Sanity-check: We must have a buffer. */
	assert(WB != NULL);

	/* Sanity-check: We must have enough space reserved. */
	assert(WB->buflen - WB->datalen >= len);

	/*
	 * Advance the buffer pointer, unless we've failed -- if we've failed
	 * there's no point since we're never going to look at the buffered
	 * data anyway.
	 */
	if (W->failed == 0)
		WB->datalen += len;

	/* We no longer have space reserved. */
	W->reserved = 0;

	/* Poke the queue to see if we can launch more writing now. */
	return (poke(W));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0xbfac
jmp 0xbfcb
leaq 0x4524(%rip), %rdi      # 0x104d7
leaq 0x444a(%rip), %rsi      # 0x10404
movl $0x120, %edx            # imm = 0x120
leaq 0x4522(%rip), %rcx      # 0x104e8
callq 0x21a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xbfde
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0xbfee
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
addq $-0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbfff
jmp 0xc01e
leaq 0x451a(%rip), %rdi      # 0x10520
leaq 0x43f7(%rip), %rsi      # 0x10404
movl $0x126, %edx            # imm = 0x126
leaq 0x44cf(%rip), %rcx      # 0x104e8
callq 0x21a0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
cmpq -0x10(%rbp), %rax
jb 0xc036
jmp 0xc055
leaq 0x44ee(%rip), %rdi      # 0x1052b
leaq 0x43c0(%rip), %rsi      # 0x10404
movl $0x129, %edx            # imm = 0x129
leaq 0x4498(%rip), %rcx      # 0x104e8
callq 0x21a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0xc06f
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0xc090
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_write.c
// Function: netbuf_write_write
int
netbuf_write_write(struct netbuf_write * W, const uint8_t * buf, size_t buflen)
{
	uint8_t * wbuf;

	/* If we've failed, just silently discard writes. */
	if (W->failed)
		return (0);

	/* Reserve space to write the data into. */
	if ((wbuf = netbuf_write_reserve(W, buflen)) == NULL)
		goto err0;

	/* Copy data into the returned buffer. */
	memcpy(wbuf, buf, buflen);

	/* Consume the reservation. */
	if (netbuf_write_consume(W, buflen))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0xc287
movl $0x0, -0x4(%rbp)
jmp 0xc2d5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xbe20
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xc2a0
jmp 0xc2ce
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2210
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xbf90
cmpl $0x0, %eax
je 0xc2c5
jmp 0xc2ce
movl $0x0, -0x4(%rbp)
jmp 0xc2d5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_write.c
// Function: netbuf_write_free
void
netbuf_write_free(struct netbuf_write * W)
{
	struct writebuf * WB;

	/* Behave consistently with free(NULL). */
	if (W == NULL)
		return;

	/* Cancel any in-progress write. */
	if (W->write_cookie != NULL) {
		if (W->ssl)
			(netbuf_write_ssl_cancel_func)(W->write_cookie);
		else
			network_write_cancel(W->write_cookie);
		free(W->curr->buf);
		free(W->curr);
	}

	/* Free write buffers. */
	while (!STAILQ_EMPTY(&W->buffers)) {
		WB = STAILQ_FIRST(&W->buffers);
		STAILQ_REMOVE_HEAD(&W->buffers, entries);
		free(WB->buf);
		free(WB);
	}

	/* Free the buffered writer. */
	free(W);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc2f8
jmp 0xc3b9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xc34b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc321
movq 0x3a3eb(%rip), %rax     # 0x46700
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
jmp 0xc32e
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xcdd0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2040
jmp 0xc34d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc361
jmp 0xc3b0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0xc397
movq -0x8(%rbp), %rcx
addq $0x28, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0xc399
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x2040
jmp 0xc34d
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/netbuf/netbuf_write.c
// Function: writbuf
static int
writbuf(void * cookie, ssize_t writelen)
{
	struct netbuf_write * W = cookie;
	struct writebuf * WB = W->curr;

	/* Sanity-check: No callbacks while buffer space reserved. */
	assert(W->reserved == 0);

	/* Sanity-check: We must have had a write in progress. */
	assert(W->write_cookie != NULL);
	assert(W->curr != NULL);

	/* This write is no longer in progress. */
	W->write_cookie = NULL;
	W->curr = NULL;

	/* Sanity-check: We can't get here if we've previously failed. */
	assert(W->failed == 0);

	/*
	 * If we didn't write the correct number of bytes, mark the queue as
	 * failed.  Note that since datalen can't be equal to (size_t)(-1)
	 * this also handles the case of writelen == -1.
	 */
	if ((size_t)(writelen) != WB->datalen)
		W->failed = 1;

	/* Free this buffer. */
	free(WB->buf);
	free(WB);

	/* If we failed, invoke the failure callback. */
	if (W->failed)
		return ((W->fail_callback)(W->fail_cookie));

	/* Poke the queue to launch more writes. */
	return (poke(W));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xc3f0
jmp 0xc40f
leaq 0x4092(%rip), %rdi      # 0x10489
leaq 0x4006(%rip), %rsi      # 0x10404
movl $0x42, %edx
leaq 0x4171(%rip), %rcx      # 0x1057b
callq 0x21a0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xc41c
jmp 0xc43b
leaq 0x4175(%rip), %rdi      # 0x10598
leaq 0x3fda(%rip), %rsi      # 0x10404
movl $0x45, %edx
leaq 0x4145(%rip), %rcx      # 0x1057b
callq 0x21a0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xc448
jmp 0xc467
leaq 0x4161(%rip), %rdi      # 0x105b0
leaq 0x3fae(%rip), %rsi      # 0x10404
movl $0x46, %edx
leaq 0x4119(%rip), %rcx      # 0x1057b
callq 0x21a0
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0xc48b
jmp 0xc4aa
leaq 0x412e(%rip), %rdi      # 0x105c0
leaq 0x3f6b(%rip), %rsi      # 0x10404
movl $0x4d, %edx
leaq 0x40d6(%rip), %rcx      # 0x1057b
callq 0x21a0
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xc4c3
movq -0x20(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0xc4f9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xc505
movq -0x20(%rbp), %rdi
callq 0xc090
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network/network_write.c
// Function: network_write
void *
network_write(int fd, const uint8_t * buf, size_t buflen, size_t minwrite,
    int (* callback)(void *, ssize_t), void * cookie)
{
	struct network_write_cookie * C;

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

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

	/* Bake a cookie. */
	if ((C = mpool_network_write_cookie_malloc()) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;
	C->fd = fd;
	C->buf = buf;
	C->buflen = buflen;
	C->minlen = minwrite;
	C->bufpos = 0;

	/* Register a callback for network readiness. */
	if (events_network_register(callback_buf, C, C->fd,
	    EVENTS_NETWORK_OP_WRITE))
		goto err1;

	/* Success! */
	return (C);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcb18
jmp 0xcb37
leaq 0x3ab0(%rip), %rdi      # 0x105cf
leaq 0x3b74(%rip), %rsi      # 0x1069a
movl $0x9f, %edx
leaq 0x3b8f(%rip), %rcx      # 0x106c1
callq 0x21a0
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x20(%rbp)
ja 0xcb49
jmp 0xcb68
leaq 0x3b06(%rip), %rdi      # 0x10656
leaq 0x3b43(%rip), %rsi      # 0x1069a
movl $0xa2, %edx
leaq 0x3b5e(%rip), %rcx      # 0x106c1
callq 0x21a0
callq 0xcc20
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0xcb7c
jmp 0xcc03
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x40(%rbp), %rsi
movq -0x40(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x61(%rip), %rdi        # 0xcc40
movl $0x1, %ecx
callq 0x3550
cmpl $0x0, %eax
je 0xcbf0
jmp 0xcbfa
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc0b
movq -0x40(%rbp), %rdi
callq 0xcda0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/sysendian.h
// Function: libcperciva_be64dec
static inline uint64_t
be64dec(const void * pp)
{
	const uint8_t * p = (uint8_t const *)pp;

	return ((uint64_t)(p[7]) | ((uint64_t)(p[6]) << 8) |
	    ((uint64_t)(p[5]) << 16) | ((uint64_t)(p[4]) << 24) |
	    ((uint64_t)(p[3]) << 32) | ((uint64_t)(p[2]) << 40) |
	    ((uint64_t)(p[1]) << 48) | ((uint64_t)(p[0]) << 56));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shlq $0x30, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
shlq $0x38, %rcx
orq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)