LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/daemonize.c
// Function: writepid
static int
writepid(const char * spid)
{
	FILE * f;

	/* Write our pid to a file. */
	if ((f = fopen(spid, "w")) == NULL) {
		warnp("fopen(%s)", spid);
		goto err0;
	}
	if (fprintf(f, "%jd", (intmax_t)getpid()) < 0) {
		warnp("fprintf");
		goto err1;
	}
	if (fclose(f)) {
		warnp("fclose");
		goto err0;
	}

	/* Success! */
	return (0);

err1:
	if (fclose(f))
		warnp("fclose");
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x988f(%rip), %rsi      # 0x1e1f6
callq 0x2330
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x149ba
jmp 0x14978
callq 0x20a0
cmpl $0x0, (%rax)
je 0x149a1
movq -0x10(%rbp), %rsi
leaq 0xba3e(%rip), %rdi      # 0x203cb
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x149b3
movq -0x10(%rbp), %rsi
leaq 0xba1f(%rip), %rdi      # 0x203cb
movb $0x0, %al
callq 0x182f0
jmp 0x149b5
jmp 0x14ab3
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2150
movq -0x20(%rbp), %rdi
movslq %eax, %rdx
leaq 0xba00(%rip), %rsi      # 0x203d5
movb $0x0, %al
callq 0x2270
cmpl $0x0, %eax
jge 0x14a1a
jmp 0x149e3
callq 0x20a0
cmpl $0x0, (%rax)
je 0x14a08
leaq 0xb9e5(%rip), %rdi      # 0x203d9
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x14a16
leaq 0xb9ca(%rip), %rdi      # 0x203d9
movb $0x0, %al
callq 0x182f0
jmp 0x14a18
jmp 0x14a6a
movq -0x18(%rbp), %rdi
callq 0x2160
cmpl $0x0, %eax
je 0x14a61
jmp 0x14a2a
callq 0x20a0
cmpl $0x0, (%rax)
je 0x14a4f
leaq 0xb9a6(%rip), %rdi      # 0x203e1
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x14a5d
leaq 0xb98b(%rip), %rdi      # 0x203e1
movb $0x0, %al
callq 0x182f0
jmp 0x14a5f
jmp 0x14ab3
movl $0x0, -0x4(%rbp)
jmp 0x14aba
movq -0x18(%rbp), %rdi
callq 0x2160
cmpl $0x0, %eax
je 0x14ab1
jmp 0x14a7a
callq 0x20a0
cmpl $0x0, (%rax)
je 0x14a9f
leaq 0xb956(%rip), %rdi      # 0x203e1
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x14aad
leaq 0xb93b(%rip), %rdi      # 0x203e1
movb $0x0, %al
callq 0x182f0
jmp 0x14aaf
jmp 0x14ab1
jmp 0x14ab3
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/util/humansize.c
// Function: humansize
char *
humansize(uint64_t size)
{
	char * s;
	char prefix;
	int shiftcnt;
	int rc;

	/* Special-case for size < 1000. */
	if (size < 1000) {
		rc = asprintf(&s, "%d B", (int)size);
	} else {
		/* Keep 10 * size / 1000^(3n) in size. */
		for (size /= 100, shiftcnt = 1; size >= 10000; shiftcnt++)
			size /= 1000;

		/*
		 * Figure out what prefix to use.  Since 1 EB = 10^18 B and
		 * the maximum value of a uint64_t is 2^64 which is roughly
		 * 18.4 * 10^18, this cannot reference beyond the end of the
		 * string.
		 */
		prefix = " kMGTPE"[shiftcnt];

		/* Construct the string. */
		if (size < 100)
			rc = asprintf(&s, "%d.%d %cB", (int)size / 10,
			    (int)size % 10, prefix);
		else
			rc = asprintf(&s, "%d %cB", (int)size / 10, prefix);
	}

	if (rc == -1) {
		warnp("asprintf");
		goto err0;
	}

	/* Success! */
	return (s);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x3e8, -0x10(%rbp)     # imm = 0x3E8
jae 0x15816
movq -0x10(%rbp), %rax
movl %eax, %edx
leaq -0x18(%rbp), %rdi
leaq 0xaf11(%rip), %rsi      # 0x20718
movb $0x0, %al
callq 0x146c0
movl %eax, -0x24(%rbp)
jmp 0x158d3
movq -0x10(%rbp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movl $0x1, -0x20(%rbp)
cmpq $0x2710, -0x10(%rbp)    # imm = 0x2710
jb 0x15856
movq -0x10(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1582f
movslq -0x20(%rbp), %rcx
leaq 0xaebc(%rip), %rax      # 0x2071d
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
cmpq $0x64, -0x10(%rbp)
jae 0x158aa
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x28(%rbp), %edx
movsbl -0x19(%rbp), %r8d
leaq -0x18(%rbp), %rdi
leaq 0xae87(%rip), %rsi      # 0x20725
movb $0x0, %al
callq 0x146c0
movl %eax, -0x24(%rbp)
jmp 0x158d1
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %edx
movsbl -0x19(%rbp), %ecx
leaq -0x18(%rbp), %rdi
leaq 0xae61(%rip), %rsi      # 0x20728
movb $0x0, %al
callq 0x146c0
movl %eax, -0x24(%rbp)
jmp 0x158d3
cmpl $-0x1, -0x24(%rbp)
jne 0x15912
jmp 0x158db
callq 0x20a0
cmpl $0x0, (%rax)
je 0x15900
leaq 0x8b48(%rip), %rdi      # 0x1e434
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1590e
leaq 0x8b2d(%rip), %rdi      # 0x1e434
movb $0x0, %al
callq 0x182f0
jmp 0x15910
jmp 0x1591c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15924
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/ipc_sync.c
// Function: ipc_sync_init
struct ipc_sync *
ipc_sync_init(void)
{
	struct ipc_sync * IS;

	/* Allocate the cookie. */
	if ((IS = malloc(sizeof(struct ipc_sync))) == NULL) {
		warnp("malloc");
		goto err0;
	}

	/* Set up synchronization. */
	if (pipe(IS->fd)) {
		warnp("pipe");
		goto err1;
	}

	/* Success! */
	return (IS);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x8, %edi
callq 0x22a0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x15bd5
jmp 0x15b9e
callq 0x20a0
cmpl $0x0, (%rax)
je 0x15bc3
leaq 0xab80(%rip), %rdi      # 0x2072f
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x15bd1
leaq 0xab65(%rip), %rdi      # 0x2072f
movb $0x0, %al
callq 0x182f0
jmp 0x15bd3
jmp 0x15c2f
movq -0x10(%rbp), %rdi
callq 0x2200
cmpl $0x0, %eax
je 0x15c1c
jmp 0x15be5
callq 0x20a0
cmpl $0x0, (%rax)
je 0x15c0a
leaq 0xab52(%rip), %rdi      # 0x20748
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x15c18
leaq 0xab37(%rip), %rdi      # 0x20748
movb $0x0, %al
callq 0x182f0
jmp 0x15c1a
jmp 0x15c26
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15c37
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/util/ipc_sync.c
// Function: ipc_sync_prep
static int
ipc_sync_prep(struct ipc_sync * IS, int num)
{

	/* Bail if there's nothing to do. */
	if (IS->fd[num] == -1)
		return (0);

	/*
	 * Close the indicated end of pipe so that if the other process dies,
	 * we will notice the pipe being reset.
	 */
	if (ipc_sync_close(IS->fd[num]))
		goto err0;
	IS->fd[num] = -1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x15cb6
movl $0x0, -0x4(%rbp)
jmp 0x15cec
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x15f70
cmpl $0x0, %eax
je 0x15ccd
jmp 0x15ce5
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
jmp 0x15cec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/ipc_sync.c
// Function: readbyte
static inline int
readbyte(int fd)
{
	char dummy;
	char done = 0;

	/* Loop until done. */
	do {
		switch (read(fd, &dummy, 1)) {
		case -1:
			/* Anything other than EINTR is bad. */
			if (errno != EINTR) {
				warnp("read");
				goto err0;
			}

			/* Otherwise, loop and read again. */
			break;
		case 0:
			warn0("Unexpected EOF in pipe");
			goto err0;
		case 1:
			/* Expected value; quit the loop. */
			done = 1;
		}
	} while (!done);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movb $0x0, -0xa(%rbp)
movl -0x8(%rbp), %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
subq $-0x1, %rax
je 0x15d46
jmp 0x15d2f
movq -0x18(%rbp), %rax
testq %rax, %rax
je 0x15d8b
jmp 0x15d3a
movq -0x18(%rbp), %rax
subq $0x1, %rax
je 0x15da8
jmp 0x15dac
callq 0x20a0
cmpl $0x4, (%rax)
je 0x15d89
jmp 0x15d52
callq 0x20a0
cmpl $0x0, (%rax)
je 0x15d77
leaq 0x9e41(%rip), %rdi      # 0x1fba4
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x15d85
leaq 0x9e26(%rip), %rdi      # 0x1fba4
movb $0x0, %al
callq 0x182f0
jmp 0x15d87
jmp 0x15dc8
jmp 0x15dac
jmp 0x15d8d
leaq 0xa9a2(%rip), %rdi      # 0x20736
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x15dc8
movb $0x1, -0xa(%rbp)
jmp 0x15dae
cmpb $0x0, -0xa(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15d0f
movl $0x0, -0x4(%rbp)
jmp 0x15dcf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/ipc_sync.c
// Function: writebyte
static inline int
writebyte(int fd)
{
	char dummy = 0;

	/* Do the write. */
	if (noeintr_write(fd, &dummy, 1) == -1) {
		warnp("write");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl -0x8(%rbp), %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x16310
cmpq $-0x1, %rax
jne 0x15e7f
jmp 0x15e48
callq 0x20a0
cmpl $0x0, (%rax)
je 0x15e6d
leaq 0xa8f4(%rip), %rdi      # 0x2074d
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x15e7b
leaq 0xa8d9(%rip), %rdi      # 0x2074d
movb $0x0, %al
callq 0x182f0
jmp 0x15e7d
jmp 0x15e88
movl $0x0, -0x4(%rbp)
jmp 0x15e8f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/ipc_sync.c
// Function: ipc_sync_done
int
ipc_sync_done(struct ipc_sync * IS)
{

	/* Close any open file descriptors. */
	if ((IS->fd[W] != -1) && ipc_sync_close(IS->fd[W]))
		goto err1;
	if ((IS->fd[R] != -1) && ipc_sync_close(IS->fd[R]))
		goto err2;

	/* Clean up. */
	free(IS);

	/* Success! */
	return (0);

err2:
	if (IS->fd[R] != -1)
		ipc_sync_close(IS->fd[R]);
err1:
	free(IS);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
je 0x15f09
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x15f70
cmpl $0x0, %eax
je 0x15f09
jmp 0x15f4c
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x15f24
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x15f70
cmpl $0x0, %eax
je 0x15f24
jmp 0x15f36
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x15f5c
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x15f4a
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x15f70
jmp 0x15f4c
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/ipc_sync.c
// Function: ipc_sync_close
static inline int
ipc_sync_close(int fd)
{

	/* Loop until closed. */
	while (close(fd)) {
		if (errno == EINTR)
			continue;
		warnp("close");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x21f0
cmpl $0x0, %eax
je 0x15fcd
callq 0x20a0
cmpl $0x4, (%rax)
jne 0x15f94
jmp 0x15f7b
jmp 0x15f96
callq 0x20a0
cmpl $0x0, (%rax)
je 0x15fbb
leaq 0xa43b(%rip), %rdi      # 0x203e2
movb $0x0, %al
callq 0x180a0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x15fc9
leaq 0xa420(%rip), %rdi      # 0x203e2
movb $0x0, %al
callq 0x182f0
jmp 0x15fcb
jmp 0x15fd6
movl $0x0, -0x4(%rbp)
jmp 0x15fdd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/kvhash.c
// Function: kvhash_init
struct kvhash *
kvhash_init(void)
{
	struct kvhash * H;

	/* Allocate a kvhash. */
	if ((H = malloc(sizeof(struct kvhash))) == NULL)
		goto err0;

	/* We start with 4 slots. */
	H->nslots = 4;
	if (IMALLOC(H->pairs, H->nslots, struct kvpair_const))
		goto err1;
	if (IMALLOC(H->hashes, H->nslots, uint32_t))
		goto err2;

	/* This table is empty. */
	H->nkeys = 0;
	memset(H->pairs, 0, H->nslots * sizeof(struct kvpair_const));

	/* Success! */
	return (H);

err2:
	free(H->pairs);
err1:
	free(H);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x22a0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x187b1
jmp 0x1885b
movq -0x10(%rbp), %rax
movq $0x4, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x10, %esi
callq 0x18870
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x187e9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x187e9
jmp 0x18852
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x18870
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x18816
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x18816
jmp 0x18846
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
shlq $0x4, %rdx
xorl %esi, %esi
callq 0x21e0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x18863
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/kvhash.c
// Function: kvhash_search
struct kvpair_const *
kvhash_search(struct kvhash * H, const struct kvldskey * k)
{
	size_t pos;
	uint32_t h;

	/* Compute the hash. */
	h = hash(k);

	/* Scan the table until we find an empty slot or the key. */
	pos = h & (H->nslots - 1);
	do {
		/* If this slot is empty, stop. */
		if (H->pairs[pos].k == NULL)
			break;

		/* If the hash and key match, stop. */
		if ((H->hashes[pos] == h) &&
		    (kvldskey_cmp(k, H->pairs[pos].k) == 0))
			break;

		/* Move on to the next slot. */
		pos = (pos + 1) & (H->nslots - 1);
	} while (1);

	/*
	 * Write the hash here.  If the key is already present, this has no
	 * effect; if the key is not present, this ensures that they hash is
	 * in place if/when the key is added.
	 */
	H->hashes[pos] = h;

	/* Return a pointer to the kvpair struct. */
	return (&H->pairs[pos]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x189f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x1895c
jmp 0x189b8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jne 0x18995
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x18660
cmpl $0x0, %eax
jne 0x18995
jmp 0x189b8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x18942
jmp 0x189b8
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/kvhash.c
// Function: hash
static uint32_t
hash(const struct kvldskey * k)
{
	CRC32C_CTX ctx;
	uint32_t h;

	/* Compute CRC32C(k). */
	CRC32C_Init(&ctx);
	CRC32C_Update(&ctx, k->buf, k->len);
	CRC32C_Final((uint8_t *)&h, &ctx);

	/* Return hash value. */
	return (h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1c330
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %edx
leaq -0xc(%rbp), %rdi
callq 0x1c4d0
leaq -0x10(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x1c640
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/kvhash.c
// Function: kvhash_postadd
int
kvhash_postadd(struct kvhash * H)
{

	/* We've added an entry to the hash table. */
	H->nkeys += 1;

	/* Rehash if the table is more than 3/4 full. */
	if (H->nkeys + H->nslots / 4 > H->nslots) {
		if (rehash(H))
			goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x2, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x18a8f
movq -0x10(%rbp), %rdi
callq 0x18ab0
cmpl $0x0, %eax
je 0x18a8d
jmp 0x18a98
jmp 0x18a8f
movl $0x0, -0x4(%rbp)
jmp 0x18a9f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/kvhash.c
// Function: kvhash_free
void
kvhash_free(struct kvhash * H)
{

	/* Be compatible with free(NULL). */
	if (H == NULL)
		return;

	/* Free the hash table. */
	free(H->hashes);
	free(H->pairs);
	free(H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x18d05
jmp 0x18d27
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq (%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/../lib/datastruct/kvpair.c
// Function: kvpair_cmp
int
kvpair_cmp(void * cookie, const void * _x, const void * _y)
{
	const struct kvpair * x = _x;
	const struct kvpair * y = _y;
	size_t * mlen = cookie;

	return (kvldskey_cmp2(x->k, y->k, *mlen));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
callq 0x18690
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/pool.c
// Function: pool_init
struct pool *
pool_init(size_t nrec, size_t offset)
{
	struct pool * P;

	/* Allocate a pool structure. */
	if ((P = malloc(sizeof(struct pool))) == NULL)
		goto err0;

	/* Initialize. */
	P->size = nrec;
	P->used = 0;
	P->evict_head = P->evict_tail = NULL;
	P->offset = offset;

	/* Success! */
	return (P);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x28, %edi
callq 0x22a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x18e56
jmp 0x18e9b
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x18ea3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/pool.c
// Function: pool_rec_add
int
pool_rec_add(struct pool * P, void * rec, void ** evict)
{

	/* Create a pool_elem structure for this record. */
	if ((get_pool_elem(P, rec) =
	    malloc(sizeof(struct pool_elem))) == NULL)
		goto err0;
	get_pool_elem(P, rec)->wire_count = 1;

	/* Add the record to the pool. */
	P->used += 1;

	/* Evict a record if necessary and possible. */
	if ((P->used > P->size) && (P->evict_head != NULL)) {
		/* Grab the record at the head of the evict queue. */
		*evict = P->evict_head;

		/* Remove said record from the queue. */
		pool_delqueue(P, *evict);

		/* Remove the record from the pool. */
		free(get_pool_elem(P, *evict));
		P->used -= 1;
	} else {
		*evict = NULL;
	}

	/* 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 %rdx, -0x20(%rbp)
movl $0x18, %edi
callq 0x22a0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
movq %rax, (%rcx,%rdx)
cmpq $0x0, %rax
jne 0x18ee9
jmp 0x18f89
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rax,%rcx), %rax
movq $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x18f75
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x18f75
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x18fa0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rax,%rcx), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x18f80
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x18f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/pool.c
// Function: pool_delqueue
void
pool_delqueue(struct pool * P, void * rec)
{
	void * next = get_pool_elem(P, rec)->next;
	void * prev = get_pool_elem(P, rec)->prev;

	/* If this is the only record in the queue, it becomes empty. */
	if ((P->evict_head == rec) && (P->evict_tail == rec)) {
		P->evict_head = P->evict_tail = NULL;
	} else
	/* If this is the head, we have a new head. */
	    if (P->evict_head == rec) {
		P->evict_head = next;
		get_pool_elem(P, next)->prev = NULL;
	} else
	/* If this is the tail, we have a new tail. */
	    if (P->evict_tail == rec) {
		P->evict_tail = prev;
		get_pool_elem(P, prev)->next = NULL;
	} else
	/* This is in the middle; point prev and next to each other. */
	    {
		get_pool_elem(P, next)->prev = prev;
		get_pool_elem(P, prev)->next = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rax,%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rax,%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x19015
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x19015
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x190b1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x19049
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rax,%rcx), %rax
movq $0x0, 0x10(%rax)
jmp 0x190af
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1907d
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rax,%rcx), %rax
movq $0x0, 0x8(%rax)
jmp 0x190ad
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
movq (%rax,%rdx), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
movq (%rax,%rdx), %rax
movq %rcx, 0x8(%rax)
jmp 0x190af
jmp 0x190b1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/pool.c
// Function: pool_free
void
pool_free(struct pool * P)
{

	/* Be compatible with free(NULL). */
	if (P == NULL)
		return;

	/* Make sure the pool is empty. */
	assert(P->used == 0);

	/* Free the pool. */
	free(P);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x19185
jmp 0x191ba
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x19192
jmp 0x191b1
leaq 0x7bd9(%rip), %rdi      # 0x20d72
leaq 0x7b8f(%rip), %rsi      # 0x20d2f
movl $0x7a, %edx
leaq 0x7bd3(%rip), %rcx      # 0x20d7f
callq 0x21d0
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/pool.c
// Function: pool_addqueue
void
pool_addqueue(struct pool * P, void * rec)
{

	/* This record has no successor. */
	get_pool_elem(P, rec)->next = NULL;

	/* This record's predecessor is the current last record (if any). */
	get_pool_elem(P, rec)->prev = P->evict_tail;

	/* Add this record to the queue. */
	if (P->evict_head == NULL)
		P->evict_head = rec;
	else
		get_pool_elem(P, P->evict_tail)->next = rec;

	/* This record is now the last record in the queue. */
	P->evict_tail = rec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rax,%rcx), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
movq (%rax,%rdx), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x19219
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x19235
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
movq (%rax,%rdx), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_kvlds/proto_kvlds_server.c
// Function: proto_kvlds_request_read
int
proto_kvlds_request_read(struct netbuf_read * R,
    struct proto_kvlds_request * req)
{
	struct wire_packet P;

	/* Try to grab a packet from the buffered reader. */
	if (wire_readpacket_peek(R, &P))
		goto err0;

	/* Do we have a packet? */
	if (P.buf == NULL)
		goto nopacket;

	/* Parse this packet. */
	if (proto_kvlds_request_parse(&P, req))
		goto err0;

	/* Consume the packet. */
	wire_readpacket_consume(R, &P);

	/* Success! */
	return (0);

nopacket:
	/* Record that no request was available. */
	req->type = PROTO_KVLDS_NONE;

	/* 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), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ae20
cmpl $0x0, %eax
je 0x192a4
jmp 0x192eb
cmpq $0x0, -0x20(%rbp)
jne 0x192ad
jmp 0x192d7
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x19300
cmpl $0x0, %eax
je 0x192c1
jmp 0x192eb
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1b2f0
movl $0x0, -0x4(%rbp)
jmp 0x192f2
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
jmp 0x192f2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_kvlds/proto_kvlds_server.c
// Function: proto_kvlds_response_params
int
proto_kvlds_response_params(struct netbuf_write * Q, uint64_t ID,
    uint32_t kmax, uint32_t vmax)
{
	uint8_t * wbuf;

	/* Get a packet data buffer. */
	if ((wbuf = wire_writepacket_getbuf(Q, ID, 8)) == NULL)
		goto err0;

	/* Write the packet data. */
	be32enc(&wbuf[0], kmax);
	be32enc(&wbuf[4], vmax);

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, 8))
		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)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x1bf50
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x19894
jmp 0x198d2
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x198f0
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
movl -0x20(%rbp), %esi
callq 0x198f0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x1c190
cmpl $0x0, %eax
je 0x198c9
jmp 0x198d2
movl $0x0, -0x4(%rbp)
jmp 0x198d9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_kvlds/proto_kvlds_server.c
// Function: proto_kvlds_response_status
int
proto_kvlds_response_status(struct netbuf_write * Q, uint64_t ID,
    int status)
{
	uint8_t * wbuf;

	/* Sanity check. */
	assert((status == 0) || (status == 1));

	/* Get a packet data buffer. */
	if ((wbuf = wire_writepacket_getbuf(Q, ID, 4)) == NULL)
		goto err0;

	/* Write the packet data. */
	be32enc(&wbuf[0], (uint32_t)status);

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, 4))
		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)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1997f
cmpl $0x1, -0x1c(%rbp)
jne 0x19981
jmp 0x199a0
leaq 0x74e0(%rip), %rdi      # 0x20e68
leaq 0x74f8(%rip), %rsi      # 0x20e87
movl $0xed, %edx
leaq 0x7514(%rip), %rcx      # 0x20eaf
callq 0x21d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1bf50
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x199be
jmp 0x199ec
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x198f0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x4, %edx
callq 0x1c190
cmpl $0x0, %eax
je 0x199e3
jmp 0x199ec
movl $0x0, -0x4(%rbp)
jmp 0x199f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_kvlds/proto_kvlds_server.c
// Function: proto_kvlds_response_get
int
proto_kvlds_response_get(struct netbuf_write * Q, uint64_t ID,
    int status, const struct kvldskey * value)
{
	uint8_t * wbuf;
	size_t len;

	/* Sanity check. */
	assert((status == 0) || (status == 1));

	/* Compute the response length. */
	len = 4;
	if (status == 0)
		len += kvldskey_serial_size(value);

	/* Get a packet data buffer. */
	if ((wbuf = wire_writepacket_getbuf(Q, ID, len)) == NULL)
		goto err0;

	/* Write the packet data. */
	be32enc(&wbuf[0], (uint32_t)status);
	if (status == 0)
		kvldskey_serialize(value, &wbuf[4]);

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, len))
		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)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x19a23
cmpl $0x1, -0x1c(%rbp)
jne 0x19a25
jmp 0x19a44
leaq 0x743c(%rip), %rdi      # 0x20e68
leaq 0x7454(%rip), %rsi      # 0x20e87
movl $0x110, %edx            # imm = 0x110
leaq 0x74b6(%rip), %rcx      # 0x20ef5
callq 0x21d0
movq $0x4, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x19a65
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
addq $0x1, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bf50
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x19a82
jmp 0x19ad3
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x198f0
cmpl $0x0, -0x1c(%rbp)
jne 0x19ab2
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x2280
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1c190
cmpl $0x0, %eax
je 0x19aca
jmp 0x19ad3
movl $0x0, -0x4(%rbp)
jmp 0x19ada
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: proto_lbs_request_params
int
proto_lbs_request_params(struct wire_requestqueue * Q,
    int (* callback)(void *, int, size_t, uint64_t), void * cookie)
{
	struct params_cookie * C;
	uint8_t buf[4];

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

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct params_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Construct request. */
	be32enc(&buf[0], PROTO_LBS_PARAMS);

	/* Send request. */
	if (wire_requestqueue_add(Q, buf, 4, callback_params, C))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
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)
cmpq $0x0, -0x18(%rbp)
je 0x19ffd
jmp 0x1a01c
leaq 0x7041(%rip), %rdi      # 0x21045
leaq 0x704b(%rip), %rsi      # 0x21056
movl $0x41, %edx
leaq 0x7063(%rip), %rcx      # 0x2107a
callq 0x21d0
movl $0x10, %edi
callq 0x22a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1a032
jmp 0x1a08a
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
callq 0x1a0a0
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
movq -0x28(%rbp), %r8
movl $0x4, %edx
leaq 0xa4(%rip), %rcx        # 0x1a110
callq 0x1bb60
cmpl $0x0, %eax
je 0x1a078
jmp 0x1a081
movl $0x0, -0x4(%rbp)
jmp 0x1a091
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: callback_params
static int
callback_params(void * cookie, uint8_t * buf, size_t buflen)
{
	struct params_cookie * C = cookie;
	int failed = 1;
	size_t blklen = 0;
	uint64_t blkno = 0;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen != 12)
			BAD("PARAMS", "bogus length");

		/* Parse the packet. */
		blklen = be32dec(&buf[0]);
		blkno = be64dec(&buf[4]);

		/* We successfully parsed this response. */
		failed = 0;
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed, blklen, blkno);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1a1a5
cmpq $0xc, -0x18(%rbp)
je 0x1a17e
jmp 0x1a153
jmp 0x1a155
leaq 0x717f(%rip), %rdi      # 0x212db
leaq 0x7195(%rip), %rsi      # 0x212f8
leaq 0x7195(%rip), %rdx      # 0x212ff
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a1a7
movq -0x10(%rbp), %rdi
callq 0x1ad50
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x1ad90
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x1a1a7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq *%rax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2040
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: proto_lbs_request_params2
int
proto_lbs_request_params2(struct wire_requestqueue * Q,
    int (* callback)(void *, int, size_t, uint64_t, uint64_t), void * cookie)
{
	struct params2_cookie * C;
	uint8_t buf[4];

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

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct params2_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Construct request. */
	be32enc(&buf[0], PROTO_LBS_PARAMS2);

	/* Send request. */
	if (wire_requestqueue_add(Q, buf, 4, callback_params2, C))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
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)
cmpq $0x0, -0x18(%rbp)
je 0x1a1fd
jmp 0x1a21c
leaq 0x6e41(%rip), %rdi      # 0x21045
leaq 0x6e4b(%rip), %rsi      # 0x21056
movl $0x8d, %edx
leaq 0x6ecc(%rip), %rcx      # 0x210e3
callq 0x21d0
movl $0x10, %edi
callq 0x22a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1a232
jmp 0x1a28d
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x2c(%rbp), %rdi
movl $0x4, %esi
callq 0x1a0a0
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
movq -0x28(%rbp), %r8
movl $0x4, %edx
leaq 0x31(%rip), %rcx        # 0x1a2a0
callq 0x1bb60
cmpl $0x0, %eax
je 0x1a27b
jmp 0x1a284
movl $0x0, -0x4(%rbp)
jmp 0x1a294
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: callback_params2
static int
callback_params2(void * cookie, uint8_t * buf, size_t buflen)
{
	struct params2_cookie * C = cookie;
	int failed = 1;
	size_t blklen = 0;
	uint64_t blkno = 0;
	uint64_t lastblk = (uint64_t)(-1);
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen != 20)
			BAD("PARAMS2", "bogus length");

		/* Parse the packet. */
		blklen = be32dec(&buf[0]);
		blkno = be64dec(&buf[4]);
		lastblk = be64dec(&buf[12]);

		/* We successfully parsed this response. */
		failed = 0;
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed, blklen, blkno, lastblk);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $-0x1, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1a34e
cmpq $0x14, -0x18(%rbp)
je 0x1a316
jmp 0x1a2eb
jmp 0x1a2ed
leaq 0x6fe7(%rip), %rdi      # 0x212db
leaq 0x7011(%rip), %rsi      # 0x2130c
leaq 0x6ffd(%rip), %rdx      # 0x212ff
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a350
movq -0x10(%rbp), %rdi
callq 0x1ad50
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x1ad90
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
callq 0x1ad90
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x1a350
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
callq *%rax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2040
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: proto_lbs_request_get
int
proto_lbs_request_get(struct wire_requestqueue * Q,
    uint64_t blkno, size_t blklen,
    int (* callback)(void *, int, int, const uint8_t *), void * cookie)
{
	struct get_cookie * C;
	uint8_t * buf;

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

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct get_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;
	C->blklen = blklen;

	/* Start writing a request. */
	if ((buf = wire_requestqueue_add_getbuf(Q, 12,
	    callback_get, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(&buf[0], PROTO_LBS_GET);
	be64enc(&buf[4], blkno);

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, buf, 12))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
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 %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1a3b5
jmp 0x1a3d4
leaq 0x6c89(%rip), %rdi      # 0x21045
leaq 0x6c93(%rip), %rsi      # 0x21056
movl $0xdd, %edx
leaq 0x6d88(%rip), %rcx      # 0x21157
callq 0x21d0
movl $0x18, %edi
callq 0x22a0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x1a3ed
jmp 0x1a47f
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rcx
movl $0xc, %esi
leaq 0x6c(%rip), %rdx        # 0x1a490
callq 0x1b970
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x1a435
jmp 0x1a476
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x1a0a0
movq -0x40(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a620
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0xc, %edx
callq 0x1bb00
cmpl $0x0, %eax
je 0x1a46d
jmp 0x1a476
movl $0x0, -0x4(%rbp)
jmp 0x1a486
movq -0x38(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: callback_get
static int
callback_get(void * cookie, uint8_t * buf, size_t buflen)
{
	struct get_cookie * C = cookie;
	int failed = 1;
	int status = 0;
	const uint8_t * blk = NULL;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Is the status code sane? */
		if (buflen < 4)
			BAD("GET", "bogus length");
		if (be32dec(&buf[0]) > 1)
			BAD("GET", "bogus status code");
		status = (int)be32dec(&buf[0]);

		/* Do we have the right packet length? */
		if ((status == 0) && (buflen != 4 + C->blklen))
			BAD("GET", "wrong length for status");
		if ((status == 1) && (buflen != 4))
			BAD("GET", "wrong length for status");

		/* Find the block data, if any. */
		if (status == 0)
			blk = &buf[4];

		/* We successfully parsed this response. */
		failed = 0;
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed, status, blk);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1a5e9
cmpq $0x4, -0x18(%rbp)
jae 0x1a504
jmp 0x1a4d6
jmp 0x1a4d8
leaq 0x6dfc(%rip), %rdi      # 0x212db
leaq 0x6e2e(%rip), %rsi      # 0x21314
leaq 0x6e12(%rip), %rdx      # 0x212ff
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a5eb
movq -0x10(%rbp), %rdi
callq 0x1ad50
cmpl $0x1, %eax
jbe 0x1a542
jmp 0x1a514
jmp 0x1a516
leaq 0x6dbe(%rip), %rdi      # 0x212db
leaq 0x6df0(%rip), %rsi      # 0x21314
leaq 0x6ded(%rip), %rdx      # 0x21318
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a5eb
movq -0x10(%rbp), %rdi
callq 0x1ad50
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x1a596
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq $0x4, %rcx
cmpq %rcx, %rax
je 0x1a596
jmp 0x1a56b
jmp 0x1a56d
leaq 0x6d67(%rip), %rdi      # 0x212db
leaq 0x6d99(%rip), %rsi      # 0x21314
leaq 0x6da8(%rip), %rdx      # 0x2132a
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a5eb
cmpl $0x1, -0x28(%rbp)
jne 0x1a5d0
cmpq $0x4, -0x18(%rbp)
je 0x1a5d0
jmp 0x1a5a5
jmp 0x1a5a7
leaq 0x6d2d(%rip), %rdi      # 0x212db
leaq 0x6d5f(%rip), %rsi      # 0x21314
leaq 0x6d6e(%rip), %rdx      # 0x2132a
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a5eb
cmpl $0x0, -0x28(%rbp)
jne 0x1a5e2
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x1a5eb
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq -0x30(%rbp), %rcx
callq *%rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2040
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_client.c
// Function: callback_append
static int
callback_append(void * cookie, uint8_t * buf, size_t buflen)
{
	struct append_cookie * C = cookie;
	int failed = 1;
	int status = 0;
	uint64_t blkno = 0;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Is the status code sane? */
		if (buflen < 4)
			BAD("APPEND", "bogus length");
		if (be32dec(&buf[0]) > 1)
			BAD("APPEND", "bogus status code");
		status = (int)be32dec(&buf[0]);

		/* Do we have the right packet length? */
		if ((status == 0) && (buflen != 12))
			BAD("APPEND", "wrong length for status");
		if ((status == 1) && (buflen != 4))
			BAD("APPEND", "wrong length for status");

		/* Parse the next block #, if any. */
		if (status == 0)
			blkno = be64dec(&buf[4]);

		/* We successfully parsed this response. */
		failed = 0;
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed, status, blkno);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1a9d0
cmpq $0x4, -0x18(%rbp)
jae 0x1a8f4
jmp 0x1a8c6
jmp 0x1a8c8
leaq 0x6a0c(%rip), %rdi      # 0x212db
leaq 0x6a6c(%rip), %rsi      # 0x21342
leaq 0x6a22(%rip), %rdx      # 0x212ff
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a9d2
movq -0x10(%rbp), %rdi
callq 0x1ad50
cmpl $0x1, %eax
jbe 0x1a932
jmp 0x1a904
jmp 0x1a906
leaq 0x69ce(%rip), %rdi      # 0x212db
leaq 0x6a2e(%rip), %rsi      # 0x21342
leaq 0x69fd(%rip), %rdx      # 0x21318
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a9d2
movq -0x10(%rbp), %rdi
callq 0x1ad50
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x1a978
cmpq $0xc, -0x18(%rbp)
je 0x1a978
jmp 0x1a94d
jmp 0x1a94f
leaq 0x6985(%rip), %rdi      # 0x212db
leaq 0x69e5(%rip), %rsi      # 0x21342
leaq 0x69c6(%rip), %rdx      # 0x2132a
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a9d2
cmpl $0x1, -0x28(%rbp)
jne 0x1a9b2
cmpq $0x4, -0x18(%rbp)
je 0x1a9b2
jmp 0x1a987
jmp 0x1a989
leaq 0x694b(%rip), %rdi      # 0x212db
leaq 0x69ab(%rip), %rsi      # 0x21342
leaq 0x698c(%rip), %rdx      # 0x2132a
movb $0x0, %al
callq 0x182f0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x1a9d2
cmpl $0x0, -0x28(%rbp)
jne 0x1a9c9
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x1ad90
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x1a9d2
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq -0x30(%rbp), %rcx
callq *%rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2040
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)