LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_transfer_noencrypt.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct shared * shared = cookie;
	size_t i;

	/* Send bytes. */
	for (i = 0; i < nreps; i++) {
		if (noeintr_write(shared->in[W], buf, buflen)
		    != (ssize_t)buflen) {
			warnp("network_write");
			goto err0;
		}
	}

	/* We've finished sending data. */
	if (close(shared->in[W])) {
		warnp("close");
		goto err0;
	}

	/* Wait until transfer_data has finished. */
	if (readbyte(shared->finished[R]))
		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 %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3e05
movq -0x30(%rbp), %rax
movl 0x14(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13c60
cmpq -0x20(%rbp), %rax
je 0x3df5
jmp 0x3dbe
callq 0x2340
cmpl $0x0, (%rax)
je 0x3de3
leaq 0x145b6(%rip), %rdi     # 0x18385
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x3df1
leaq 0x1459b(%rip), %rdi     # 0x18385
movb $0x0, %al
callq 0x145e0
jmp 0x3df3
jmp 0x3e6b
jmp 0x3df7
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3d98
movq -0x30(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x3e4f
jmp 0x3e18
callq 0x2340
cmpl $0x0, (%rax)
je 0x3e3d
leaq 0x14645(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x3e4b
leaq 0x1462a(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x3e4d
jmp 0x3e6b
movq -0x30(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x4250
cmpl $0x0, %eax
je 0x3e62
jmp 0x3e6b
movl $0x0, -0x4(%rbp)
jmp 0x3e72
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_transfer_noencrypt.c
// Function: perftest_cleanup
static int
perftest_cleanup(void * cookie)
{
	struct shared * shared = cookie;
	int rc;

	/* Wait for threads to finish. */
	if ((rc = pthread_join(shared->data_thr, NULL))) {
		warn0("pthread_join: %s", strerror(rc));
		goto err0;
	}
	if ((rc = pthread_join(shared->output_thr, NULL))) {
		warn0("pthread_join: %s", strerror(rc));
		goto err0;
	}

	/* Clean up communication. */
	if (close(shared->out[R])) {
		warnp("close");
		goto err0;
	}
	if (close(shared->in[R])) {
		warnp("close");
		goto err0;
	}
	if (close(shared->finished[W])) {
		warnp("close");
		goto err0;
	}
	if (close(shared->finished[R])) {
		warnp("close");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2030
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x3ed7
jmp 0x3eae
movl -0x1c(%rbp), %edi
callq 0x2280
movq %rax, %rsi
leaq 0x144ea(%rip), %rdi     # 0x183aa
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x4052
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2030
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x3f1b
jmp 0x3ef2
movl -0x1c(%rbp), %edi
callq 0x2280
movq %rax, %rsi
leaq 0x144a6(%rip), %rdi     # 0x183aa
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x4052
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x3f68
jmp 0x3f2e
callq 0x2340
cmpl $0x0, (%rax)
je 0x3f53
leaq 0x1452f(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x3f61
leaq 0x14514(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x3f63
jmp 0x4052
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x3fb5
jmp 0x3f7b
callq 0x2340
cmpl $0x0, (%rax)
je 0x3fa0
leaq 0x144e2(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x3fae
leaq 0x144c7(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x3fb0
jmp 0x4052
movq -0x18(%rbp), %rax
movl 0x24(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x3fff
jmp 0x3fc8
callq 0x2340
cmpl $0x0, (%rax)
je 0x3fed
leaq 0x14495(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x3ffb
leaq 0x1447a(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x3ffd
jmp 0x4052
movq -0x18(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x4049
jmp 0x4012
callq 0x2340
cmpl $0x0, (%rax)
je 0x4037
leaq 0x1444b(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x4045
leaq 0x14430(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x4047
jmp 0x4052
movl $0x0, -0x4(%rbp)
jmp 0x4059
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]spiped/perftests/standalone-enc/standalone_transfer_noencrypt.c
// Function: drain_output
static void *
drain_output(void * cookie)
{
	struct shared * shared = cookie;
	char dummy = 0;

	/* Read until we get an EOF. */
	if (fd_drain(shared->out[R]))
		goto err0;

	/* Notify that we've finished. */
	if (noeintr_write(shared->finished[W], &dummy, 1) != 1) {
		warnp("network_write");
		goto err0;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x2ef0
cmpl $0x0, %eax
je 0x409b
jmp 0x40f1
movq -0x10(%rbp), %rax
movl 0x24(%rax), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x13c60
cmpq $0x1, %rax
je 0x40ef
jmp 0x40b8
callq 0x2340
cmpl $0x0, (%rax)
je 0x40dd
leaq 0x142bc(%rip), %rdi     # 0x18385
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x40eb
leaq 0x142a1(%rip), %rdi     # 0x18385
movb $0x0, %al
callq 0x145e0
jmp 0x40ed
jmp 0x40f1
jmp 0x40f1
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_transfer_noencrypt.c
// Function: transfer_data
static void *
transfer_data(void * cookie)
{
	struct shared * shared = cookie;
	uint8_t mybuf[MAXOUTSIZE];
	ssize_t readlen;

	/* Loop until we hit EOF. */
	do {
		/* Get data from ->in, and break on EOF. */
		if ((readlen = read(shared->in[R], mybuf, MAXOUTSIZE)) == -1) {
			warnp("read");
			goto err0;
		}
		if (readlen == 0)
			break;

		/* Send data to ->out. */
		if (noeintr_write(shared->out[W], mybuf, (size_t)readlen)
		    != readlen) {
			warnp("network_write");
			goto err0;
		}
	} while (1);

	/* When ->in received an EOF, close ->out. */
	if (close(shared->out[W])) {
		warnp("close");
		goto err0;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4020, %rsp           # imm = 0x4020
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
leaq -0x4010(%rbp), %rsi
movl $0x4000, %edx           # imm = 0x4000
callq 0x2140
movq %rax, -0x4018(%rbp)
cmpq $-0x1, %rax
jne 0x4178
jmp 0x413e
callq 0x2340
cmpl $0x0, (%rax)
je 0x4163
leaq 0x140c9(%rip), %rdi     # 0x18218
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x4171
leaq 0x140ae(%rip), %rdi     # 0x18218
movb $0x0, %al
callq 0x145e0
jmp 0x4173
jmp 0x423a
cmpq $0x0, -0x4018(%rbp)
jne 0x4184
jmp 0x41ee
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
leaq -0x4010(%rbp), %rsi
movq -0x4018(%rbp), %rdx
callq 0x13c60
cmpq -0x4018(%rbp), %rax
je 0x41e0
jmp 0x41a9
callq 0x2340
cmpl $0x0, (%rax)
je 0x41ce
leaq 0x141cb(%rip), %rdi     # 0x18385
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x41dc
leaq 0x141b0(%rip), %rdi     # 0x18385
movb $0x0, %al
callq 0x145e0
jmp 0x41de
jmp 0x423a
jmp 0x41e2
movb $0x1, %al
testb $0x1, %al
jne 0x4117
jmp 0x41ee
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x4238
jmp 0x4201
callq 0x2340
cmpl $0x0, (%rax)
je 0x4226
leaq 0x1425c(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x4234
leaq 0x14241(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x4236
jmp 0x423a
jmp 0x423a
xorl %eax, %eax
addq $0x4020, %rsp           # imm = 0x4020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: standalone_pipe_socketpair_one
int
standalone_pipe_socketpair_one(const size_t * perfsizes, size_t num_perf,
    size_t nbytes_perftest, size_t nbytes_warmup)
{
	struct pipeinfo pipeinfo_actual;

	/* Report what we're doing. */
	printf("Testing one proto_pipe() over a socketpair\n");

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 0, pipe_init, pipe_func, pipe_cleanup,
	    &pipeinfo_actual)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x1406c(%rip), %rdi     # 0x183bb
movb $0x0, %al
callq 0x2060
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %r8d, %r8d
leaq 0x60(%rip), %r9         # 0x43d0
leaq 0x1e9(%rip), %r11       # 0x4560
leaq 0x312(%rip), %r10       # 0x4690
leaq -0x50(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x13d80
cmpl $0x0, %eax
je 0x43b7
jmp 0x439c
leaq 0x13e8b(%rip), %rdi     # 0x1822e
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x43c0
movl $0x0, -0x4(%rbp)
jmp 0x43c7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_init
static int
pipe_init(void * cookie, uint8_t * buf, size_t buflen)
{
	struct pipeinfo * pipeinfo = cookie;
	uint8_t kbuf[64];
	size_t i;

	/* Set up encryption key. */
	memset(kbuf, 0, 64);
	if ((pipeinfo->k = mkkeypair(kbuf)) == NULL)
		goto err0;

	/* Create socket pairs for the input and output. */
	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipeinfo->in)) {
		warnp("socketpair");
		goto err0;
	}
	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipeinfo->out)) {
		warnp("socketpair");
		goto err0;
	}

	/* Set the input. */
	for (i = 0; i < buflen; i++)
		buf[i] = (uint8_t)(i & 0xff);

	/* We haven't finished the event loop. */
	pipeinfo->done = 0;

	/* Create the pipe processes. */
	if ((pipeinfo->out_pid = fd_drain_fork(pipeinfo->out[R])) == -1)
		goto err0;
	if ((pipeinfo->enc_pid = fork_func(pipe_enc, pipeinfo)) == -1)
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2080
leaq -0x70(%rbp), %rdi
callq 0x4950
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x441a
jmp 0x454b
movq -0x28(%rbp), %rcx
addq $0x10, %rcx
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x2290
cmpl $0x0, %eax
je 0x4471
jmp 0x4437
callq 0x2340
cmpl $0x0, (%rax)
je 0x445c
leaq 0x13f1f(%rip), %rdi     # 0x18367
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x446a
leaq 0x13f04(%rip), %rdi     # 0x18367
movb $0x0, %al
callq 0x145e0
jmp 0x446c
jmp 0x454b
movq -0x28(%rbp), %rcx
addq $0x18, %rcx
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x2290
cmpl $0x0, %eax
je 0x44c8
jmp 0x448e
callq 0x2340
cmpl $0x0, (%rax)
je 0x44b3
leaq 0x13ec8(%rip), %rdi     # 0x18367
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x44c1
leaq 0x13ead(%rip), %rdi     # 0x18367
movb $0x0, %al
callq 0x145e0
jmp 0x44c3
jmp 0x454b
movq $0x0, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x44ff
movq -0x78(%rbp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x78(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x44d0
movq -0x28(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x2fb0
movq -0x28(%rbp), %rcx
movl %eax, 0x8(%rcx)
cmpl $-0x1, %eax
jne 0x4524
jmp 0x454b
movq -0x28(%rbp), %rsi
leaq 0x2d1(%rip), %rdi       # 0x4800
callq 0x13760
movq -0x28(%rbp), %rcx
movl %eax, 0xc(%rcx)
cmpl $-0x1, %eax
jne 0x4542
jmp 0x454b
movl $0x0, -0x4(%rbp)
jmp 0x4552
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_func
static int
pipe_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct pipeinfo * pipeinfo = cookie;
	size_t i;

	/* Send bytes. */
	for (i = 0; i < nreps; i++) {
		if (noeintr_write(pipeinfo->in[W], buf, buflen)
		    != (ssize_t)buflen) {
			warnp("network_write");
			goto err0;
		}
	}

	/* We've finished writing stuff. */
	if (shutdown(pipeinfo->in[W], SHUT_WR)) {
		warnp("shutdown");
		goto err0;
	}

	/* Wait for the processes to finish. */
	if (fork_func_wait(pipeinfo->enc_pid))
		goto err0;
	if (fork_func_wait(pipeinfo->out_pid))
		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 %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x45f8
movq -0x30(%rbp), %rax
movl 0x14(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13c60
cmpq -0x20(%rbp), %rax
je 0x45e8
jmp 0x45ae
callq 0x2340
cmpl $0x0, (%rax)
je 0x45d3
leaq 0x13dc6(%rip), %rdi     # 0x18385
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x45e1
leaq 0x13dab(%rip), %rdi     # 0x18385
movb $0x0, %al
callq 0x145e0
jmp 0x45e3
jmp 0x4676
jmp 0x45ea
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4588
movq -0x30(%rbp), %rax
movl 0x14(%rax), %edi
movl $0x1, %esi
callq 0x2090
cmpl $0x0, %eax
je 0x4647
jmp 0x4610
callq 0x2340
cmpl $0x0, (%rax)
je 0x4635
leaq 0x13dfc(%rip), %rdi     # 0x1841d
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x4643
leaq 0x13de1(%rip), %rdi     # 0x1841d
movb $0x0, %al
callq 0x145e0
jmp 0x4645
jmp 0x4676
movq -0x30(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x13800
cmpl $0x0, %eax
je 0x465a
jmp 0x4676
movq -0x30(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x13800
cmpl $0x0, %eax
je 0x466d
jmp 0x4676
movl $0x0, -0x4(%rbp)
jmp 0x467d
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]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_cleanup
static int
pipe_cleanup(void * cookie)
{
	struct pipeinfo * pipeinfo = cookie;

	/* Clean up encryption key. */
	proto_crypt_free(pipeinfo->k);

	/* Clean up sockets. */
	if (close(pipeinfo->in[W])) {
		warnp("close");
		goto err0;
	}
	if (close(pipeinfo->in[R])) {
		warnp("close");
		goto err0;
	}
	if (close(pipeinfo->out[W])) {
		warnp("close");
		goto err0;
	}
	if (close(pipeinfo->out[R])) {
		warnp("close");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x51f0
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x46fd
jmp 0x46c3
callq 0x2340
cmpl $0x0, (%rax)
je 0x46e8
leaq 0x13d9a(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x46f6
leaq 0x13d7f(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x46f8
jmp 0x47e7
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x474a
jmp 0x4710
callq 0x2340
cmpl $0x0, (%rax)
je 0x4735
leaq 0x13d4d(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x4743
leaq 0x13d32(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x4745
jmp 0x47e7
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x4794
jmp 0x475d
callq 0x2340
cmpl $0x0, (%rax)
je 0x4782
leaq 0x13d00(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x4790
leaq 0x13ce5(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x4792
jmp 0x47e7
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x20a0
cmpl $0x0, %eax
je 0x47de
jmp 0x47a7
callq 0x2340
cmpl $0x0, (%rax)
je 0x47cc
leaq 0x13cb6(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x47da
leaq 0x13c9b(%rip), %rdi     # 0x1846e
movb $0x0, %al
callq 0x145e0
jmp 0x47dc
jmp 0x47e7
movl $0x0, -0x4(%rbp)
jmp 0x47ee
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_enc
static int
pipe_enc(void * cookie)
{
	struct pipeinfo * pipeinfo = cookie;
	void * cancel_cookie;

	/* Create the pipe. */
	if ((cancel_cookie = proto_pipe(pipeinfo->in[R], pipeinfo->out[W], 0,
	    pipeinfo->k, &pipeinfo->status, pipe_callback_status, pipeinfo))
	    == NULL) {
		warn0("proto_pipe");
		goto err0;
	}

	/* Let events happen. */
	if (events_spin(&pipeinfo->done))
		warnp("events_spin");

	/* Clean up the pipe. */
	proto_pipe_cancel(cancel_cookie);

	/* Success! */
	return (0);

err0:
	/* Failure!  This value will be the pid's exit code. */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %r8
addq $0x20, %r8
movq -0x18(%rbp), %rax
xorl %edx, %edx
leaq 0xa2(%rip), %r9         # 0x48e0
movq %rax, (%rsp)
callq 0x14820
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x486e
jmp 0x4853
leaq 0x13b8d(%rip), %rdi     # 0x183e7
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x48cb
movq -0x18(%rbp), %rdi
addq $0x24, %rdi
callq 0x117d0
cmpl $0x0, %eax
je 0x48b9
jmp 0x4882
callq 0x2340
cmpl $0x0, (%rax)
je 0x48a7
leaq 0x13b5f(%rip), %rdi     # 0x183f2
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x48b5
leaq 0x13b44(%rip), %rdi     # 0x183f2
movb $0x0, %al
callq 0x145e0
jmp 0x48b7
jmp 0x48b9
movq -0x20(%rbp), %rdi
callq 0x14c20
movl $0x0, -0x4(%rbp)
jmp 0x48d2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pipe_socketpair_one.c
// Function: pipe_callback_status
static int
pipe_callback_status(void * cookie)
{
	struct pipeinfo * pipeinfo = cookie;

	/* Was there an error? */
	if (pipeinfo->status) {
		warn0("proto_pipe callback status: %d", pipeinfo->status);
		return (-1);
	}

	/* We've finished. */
	pipeinfo->done = 1;

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x4929
jmp 0x4900
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x13af0(%rip), %rdi     # 0x183fe
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x493b
movq -0x18(%rbp), %rax
movl $0x1, 0x24(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: mkkeypair
static struct proto_keys *
mkkeypair(uint8_t kbuf[64])
#endif
{
	struct proto_keys * k;

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

	/* Expand the AES key. */
	if ((k->k_aes = crypto_aes_key_expand(&kbuf[0], 32)) == NULL)
		goto err1;

	/* Initialize the HMAC_SHA256 context. */
	HMAC_SHA256_Init(&k->ctx_init, &kbuf[32], 32);

	/* The first packet will be packet number zero. */
	k->pnum = 0;

	/* Success! */
	return (k);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xe0, %edi
callq 0x2150
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4972
jmp 0x49cb
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0xd790
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x498f
jmp 0x49c2
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movl $0x20, %edx
callq 0x5b30
movq -0x18(%rbp), %rax
movq $0x0, 0xd8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49d3
movq -0x18(%rbp), %rdi
callq 0x2200
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]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_secret_free
void
proto_crypt_secret_free(struct proto_secret * K)
{

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

	/* Clear secret from the memory. */
	insecure_memzero(K, sizeof(struct proto_secret));

	/* Free the key structure. */
	free(K);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4c95
jmp 0x4cac
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x5640
movq -0x8(%rbp), %rdi
callq 0x2200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_dhmac
void
proto_crypt_dhmac(const struct proto_secret * K,
    const uint8_t nonce_l[PCRYPT_NONCE_LEN],
    const uint8_t nonce_r[PCRYPT_NONCE_LEN],
    uint8_t dhmac_l[PCRYPT_DHMAC_LEN], uint8_t dhmac_r[PCRYPT_DHMAC_LEN],
    int decr)
{
	uint8_t nonce_CS[PCRYPT_NONCE_LEN * 2];
	uint8_t dk_1[PCRYPT_DHMAC_LEN * 2];
	const uint8_t * nonce_c, * nonce_s;
	uint8_t * dhmac_c, * dhmac_s;

	/* Figure out how {c, s} maps to {l, r}. */
	nonce_c = decr ? nonce_r : nonce_l;
	dhmac_c = decr ? dhmac_r : dhmac_l;
	nonce_s = decr ? nonce_l : nonce_r;
	dhmac_s = decr ? dhmac_l : dhmac_r;

	/* Copy in nonces (in the right order). */
	memcpy(&nonce_CS[0], nonce_c, PCRYPT_NONCE_LEN);
	memcpy(&nonce_CS[PCRYPT_NONCE_LEN], nonce_s, PCRYPT_NONCE_LEN);

	/* Compute dk_1. */
	PBKDF2_SHA256(K->K, 32, nonce_CS, PCRYPT_NONCE_LEN * 2, 1,
	    dk_1, PCRYPT_DHMAC_LEN * 2);

	/* Copy out diffie-hellman parameter MAC keys (in the right order). */
	memcpy(dhmac_c, &dk_1[0], PCRYPT_DHMAC_LEN);
	memcpy(dhmac_s, &dk_1[PCRYPT_DHMAC_LEN], PCRYPT_DHMAC_LEN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x4cf6
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
jmp 0x4d01
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x4d22
movq -0x28(%rbp), %rax
movq %rax, -0xe0(%rbp)
jmp 0x4d2d
movq -0x20(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0xc8(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x4d4e
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
jmp 0x4d59
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x4d7a
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
jmp 0x4d85
movq -0x28(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xb8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0xc0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rdx
leaq -0xb0(%rbp), %r9
movl $0x20, %esi
movl $0x40, %ecx
movl $0x1, %r8d
movq $0x40, (%rsp)
callq 0x5f40
movq -0xc8(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, (%rax)
movq -0xa8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0xa0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x98(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0xd0(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, (%rax)
movq -0x88(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_dh_validate
int
proto_crypt_dh_validate(const uint8_t yh_r[PCRYPT_YH_LEN],
    const uint8_t dhmac_r[PCRYPT_DHMAC_LEN], int requirepfs)
{
	uint8_t hbuf[32];

	/* Compute HMAC. */
	HMAC_SHA256_Buf(dhmac_r, PCRYPT_DHMAC_LEN, yh_r, CRYPTO_DH_PUBLEN,
	    hbuf);

	/* Check that the MAC matches. */
	if (crypto_verify_bytes(&yh_r[CRYPTO_DH_PUBLEN], hbuf, 32))
		return (1);

	/* Sanity-check the diffie-hellman value. */
	if (crypto_dh_sanitycheck(&yh_r[0]))
		return (1);

	/* If necessary, enforce that the diffie-hellman value is != 1. */
	if (requirepfs) {
		if (! is_not_one(&yh_r[0], CRYPTO_DH_PUBLEN))
			return (1);
	}

	/* Everything is good. */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %r8
movl $0x20, %esi
movl $0x100, %ecx            # imm = 0x100
callq 0x5e70
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
callq 0x114c0
cmpb $0x0, %al
je 0x4ed4
movl $0x1, -0x4(%rbp)
jmp 0x4f16
movq -0x10(%rbp), %rdi
callq 0x10d70
cmpl $0x0, %eax
je 0x4eeb
movl $0x1, -0x4(%rbp)
jmp 0x4f16
cmpl $0x0, -0x1c(%rbp)
je 0x4f0f
movq -0x10(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4f20
cmpl $0x0, %eax
jne 0x4f0d
movl $0x1, -0x4(%rbp)
jmp 0x4f16
jmp 0x4f0f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: is_not_one
static int
is_not_one(const uint8_t * x, size_t len)
{
	size_t i;
	char y;

	for (i = 0, y = 0; i < len - 1; i++) {
		y |= x[i];
	}

	return (y | (x[len - 1] - 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x4f6c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movsbl -0x19(%rbp), %eax
orl %ecx, %eax
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4f38
movsbl -0x19(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq $0x1, %rdx
movzbl (%rcx,%rdx), %ecx
subl $0x1, %ecx
orl %ecx, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_dh_generate
int
proto_crypt_dh_generate(uint8_t yh_l[PCRYPT_YH_LEN], uint8_t x[PCRYPT_X_LEN],
    const uint8_t dhmac_l[PCRYPT_DHMAC_LEN], int nopfs)
{

	/* Are we skipping the diffie-hellman generation? */
	if (nopfs) {
		/* Set y_l to a big-endian 1. */
		memset(yh_l, 0, CRYPTO_DH_PUBLEN - 1);
		yh_l[CRYPTO_DH_PUBLEN - 1] = 1;
	} else {
		/* Generate diffie-hellman parameters x and y. */
		if (crypto_dh_generate(yh_l, x))
			goto err0;
	}

	/* Append an HMAC. */
	HMAC_SHA256_Buf(dhmac_l, PCRYPT_DHMAC_LEN, yh_l, CRYPTO_DH_PUBLEN,
	    &yh_l[CRYPTO_DH_PUBLEN]);

	/* 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)
movl %ecx, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4fca
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0xff, %edx
callq 0x2080
movq -0x10(%rbp), %rax
movb $0x1, 0xff(%rax)
jmp 0x4fe0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c60
cmpl $0x0, %eax
je 0x4fde
jmp 0x500b
jmp 0x4fe0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x100, %r8             # imm = 0x100
movl $0x20, %esi
movl $0x100, %ecx            # imm = 0x100
callq 0x5e70
movl $0x0, -0x4(%rbp)
jmp 0x5012
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]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_free
void
proto_crypt_free(struct proto_keys * k)
{

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

	/* Free the AES key. */
	crypto_aes_key_free(k->k_aes);

	/* Free the key structure. */
	free(k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5205
jmp 0x521a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd8a0
movq -0x8(%rbp), %rdi
callq 0x2200
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_enc
void
proto_crypt_enc(uint8_t * ibuf, size_t len, uint8_t obuf[PCRYPT_ESZ],
    struct proto_keys * k)
{
	HMAC_SHA256_CTX ctx;
	uint8_t pnum_exp[8];

	/* Sanity-check the length. */
	assert(len <= PCRYPT_MAXDSZ);

	/* Copy the decrypted data into the encrypted buffer. */
	memcpy(obuf, ibuf, len);

	/* Pad up to PCRYPT_MAXDSZ with zeroes. */
	memset(&obuf[len], 0, PCRYPT_MAXDSZ - len);

	/* Add the length. */
	be32enc(&obuf[PCRYPT_MAXDSZ], (uint32_t)len);

	/* Encrypt the buffer in-place. */
	crypto_aesctr_buf(k->k_aes, k->pnum, obuf, obuf, PCRYPT_MAXDSZ + 4);

	/* Copy the original (initialized) context. */
	memcpy(&ctx, &k->ctx_init, sizeof(HMAC_SHA256_CTX));

	/* Append an HMAC. */
	be64enc(pnum_exp, k->pnum);
	HMAC_SHA256_Update(&ctx, obuf, PCRYPT_MAXDSZ + 4);
	HMAC_SHA256_Update(&ctx, pnum_exp, 8);
	HMAC_SHA256_Final(&obuf[PCRYPT_MAXDSZ + 4], &ctx);

	/* Increment packet number. */
	k->pnum += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x400, -0x10(%rbp)     # imm = 0x400
ja 0x5247
jmp 0x5266
leaq 0x13226(%rip), %rdi     # 0x18474
leaq 0x13234(%rip), %rsi     # 0x18489
movl $0x14b, %edx            # imm = 0x14B
leaq 0x13246(%rip), %rcx     # 0x184a7
callq 0x2120
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2470
movq -0x18(%rbp), %rdi
addq -0x10(%rbp), %rdi
movl $0x400, %edx            # imm = 0x400
subq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x2080
movq -0x18(%rbp), %rdi
addq $0x400, %rdi            # imm = 0x400
movq -0x10(%rbp), %rax
movl %eax, %esi
callq 0x5360
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x404, %r8d            # imm = 0x404
callq 0xff10
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0xf0(%rbp), %rdi
movl $0xd0, %edx
callq 0x2470
leaq -0xf8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rsi
callq 0x53d0
movq -0x18(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
movl $0x404, %edx            # imm = 0x404
callq 0x5d10
leaq -0xf8(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
movl $0x8, %edx
callq 0x5d10
movq -0x18(%rbp), %rdi
addq $0x404, %rdi            # imm = 0x404
leaq -0xf0(%rbp), %rsi
callq 0x5da0
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd8(%rax)
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/../../lib/proto/proto_crypt.c
// Function: proto_crypt_dec
ssize_t
proto_crypt_dec(uint8_t ibuf[PCRYPT_ESZ], uint8_t * obuf,
    struct proto_keys * k)
{
	HMAC_SHA256_CTX ctx;
	uint8_t hbuf[32];
	uint8_t pnum_exp[8];
	size_t len;

	/* Copy the original (initialized) context. */
	memcpy(&ctx, &k->ctx_init, sizeof(HMAC_SHA256_CTX));

	/* Verify HMAC. */
	be64enc(pnum_exp, k->pnum);
	HMAC_SHA256_Update(&ctx, ibuf, PCRYPT_MAXDSZ + 4);
	HMAC_SHA256_Update(&ctx, pnum_exp, 8);
	HMAC_SHA256_Final(hbuf, &ctx);
	if (crypto_verify_bytes(hbuf, &ibuf[PCRYPT_MAXDSZ + 4], 32))
		return (-1);

	/* Decrypt the buffer in-place. */
	crypto_aesctr_buf(k->k_aes, k->pnum, ibuf, ibuf, PCRYPT_MAXDSZ + 4);

	/* Increment packet number. */
	k->pnum += 1;

	/* Parse length. */
	len = be32dec(&ibuf[PCRYPT_MAXDSZ]);

	/* Make sure nobody is being evil here... */
	if ((len == 0) || (len > PCRYPT_MAXDSZ))
		return (-1);

	/* Copy the bytes into the output buffer. */
	memcpy(obuf, ibuf, len);

	/* Return the decrypted length. */
	return ((ssize_t)len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0xf0(%rbp), %rdi
movl $0xd0, %edx
callq 0x2470
leaq -0x118(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rsi
callq 0x53d0
movq -0x10(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
movl $0x404, %edx            # imm = 0x404
callq 0x5d10
leaq -0x118(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
movl $0x8, %edx
callq 0x5d10
leaq -0x110(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x5da0
leaq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x404, %rsi            # imm = 0x404
movl $0x20, %edx
callq 0x114c0
cmpb $0x0, %al
je 0x5554
movq $-0x1, -0x8(%rbp)
jmp 0x55e8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x404, %r8d            # imm = 0x404
callq 0xff10
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd8(%rax)
movq -0x10(%rbp), %rdi
addq $0x400, %rdi            # imm = 0x400
callq 0x5600
movl %eax, %eax
movq %rax, -0x120(%rbp)
cmpq $0x0, -0x120(%rbp)
je 0x55bf
cmpq $0x400, -0x120(%rbp) # imm = 0x400
jbe 0x55c9
movq $-0x1, -0x8(%rbp)
jmp 0x55e8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x120(%rbp), %rdx
callq 0x2470
movq -0x120(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_dh.c
// Function: crypto_dh_generate_pub
int
crypto_dh_generate_pub(uint8_t pub[CRYPTO_DH_PUBLEN],
    const uint8_t priv[CRYPTO_DH_PRIVLEN])
{
	BIGNUM * two;

	/* Generate BN representation for 2. */
	if ((two = BN_new()) == NULL) {
		warn0("%s", ERR_error_string(ERR_get_error(), NULL));
		goto err0;
	}
	if (!BN_set_word(two, 2)) {
		warn0("%s", ERR_error_string(ERR_get_error(), NULL));
		goto err1;
	}

	/* Compute pub = two^(2^258 + priv). */
	if (blinded_modexp(pub, two, priv))
		goto err1;

	/* Free storage allocated by BN_new. */
	BN_free(two);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x21a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x105e0
jmp 0x105b1
callq 0x2490
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22b0
movq %rax, %rsi
leaq 0x7e9e(%rip), %rdi      # 0x1846a
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x10657
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x2260
cmpl $0x0, %eax
jne 0x10624
jmp 0x105f5
callq 0x2490
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22b0
movq %rax, %rsi
leaq 0x7e5a(%rip), %rdi      # 0x1846a
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x1064e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10670
cmpl $0x0, %eax
je 0x1063c
jmp 0x1064e
movq -0x20(%rbp), %rdi
callq 0x20b0
movl $0x0, -0x4(%rbp)
jmp 0x1065e
movq -0x20(%rbp), %rdi
callq 0x20b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_dh.c
// Function: crypto_dh_generate
int
crypto_dh_generate(uint8_t pub[CRYPTO_DH_PUBLEN],
    uint8_t priv[CRYPTO_DH_PRIVLEN])
{

	/* Generate a random private key. */
	if (crypto_entropy_read(priv, CRYPTO_DH_PRIVLEN))
		goto err0;

	/* Compute the public key. */
	if (crypto_dh_generate_pub(pub, priv))
		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 -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x10df0
cmpl $0x0, %eax
je 0x10c85
jmp 0x10ca2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10590
cmpl $0x0, %eax
je 0x10c99
jmp 0x10ca2
movl $0x0, -0x4(%rbp)
jmp 0x10ca9
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]spiped/liball/../libcperciva/crypto/crypto_dh.c
// Function: crypto_dh_compute
int
crypto_dh_compute(const uint8_t pub[CRYPTO_DH_PUBLEN],
    const uint8_t priv[CRYPTO_DH_PRIVLEN], uint8_t key[CRYPTO_DH_KEYLEN])
{
	BIGNUM * a;

	/* Convert ${pub} into BN representation. */
	if ((a = BN_bin2bn(pub, CRYPTO_DH_PUBLEN, NULL)) == NULL) {
		warn0("%s", ERR_error_string(ERR_get_error(), NULL));
		goto err0;
	}

	/* Compute key = pub^(2^258 + priv). */
	if (blinded_modexp(key, a, priv))
		goto err1;

	/* Free storage allocated by BN_bin2bn. */
	BN_free(a);

	/* Success! */
	return (0);

err1:
	BN_free(a);
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), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
movl %eax, %edx
callq 0x2100
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x10d21
jmp 0x10cf2
callq 0x2490
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22b0
movq %rax, %rsi
leaq 0x775d(%rip), %rdi      # 0x1846a
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x10d54
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10670
cmpl $0x0, %eax
je 0x10d39
jmp 0x10d4b
movq -0x28(%rbp), %rdi
callq 0x20b0
movl $0x0, -0x4(%rbp)
jmp 0x10d5b
movq -0x28(%rbp), %rdi
callq 0x20b0
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]spiped/liball/../libcperciva/crypto/crypto_entropy.c
// Function: crypto_entropy_read
int
crypto_entropy_read(uint8_t * buf, size_t buflen)
{
	size_t bytes_to_provide;

	/* Instantiate if needed. */
	if (instantiated == 0) {
		/* Try to instantiate the PRNG. */
		if (instantiate())
			return (-1);

		/* We have instantiated the PRNG. */
		instantiated = 1;
	}

	/* Loop until we've filled the buffer. */
	while (buflen > 0) {
		/* Do we need to reseed? */
		if (drbg.reseed_counter > RESEED_INTERVAL) {
			if (reseed())
				return (-1);
		}

		/* How much data are we generating in this step? */
		if (buflen > GENERATE_MAXLEN)
			bytes_to_provide = GENERATE_MAXLEN;
		else
			bytes_to_provide = buflen;

		/* Generate bytes. */
		generate(buf, bytes_to_provide);

		/* We've done part of the buffer. */
		buf += bytes_to_provide;
		buflen -= bytes_to_provide;
	}

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0xe86d(%rip)      # 0x1f674
jne 0x10e29
callq 0x10eb0
cmpl $0x0, %eax
je 0x10e1f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10ea0
movl $0x1, 0xe84b(%rip)      # 0x1f674
jmp 0x10e2b
cmpq $0x0, -0x18(%rbp)
jbe 0x10e99
cmpl $0x100, 0xe87c(%rip)    # imm = 0x100
jbe 0x10e53
callq 0x10f50
cmpl $0x0, %eax
je 0x10e51
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10ea0
jmp 0x10e53
cmpq $0x10000, -0x18(%rbp)   # imm = 0x10000
jbe 0x10e67
movq $0x10000, -0x20(%rbp)   # imm = 0x10000
jmp 0x10e6f
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10fc0
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x10e2b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_entropy.c
// Function: instantiate
static int
instantiate(void)
{
	uint8_t seed_material[48];

	/* Obtain random seed_material = (entropy_input || nonce). */
	if (entropy_read(seed_material, 48))
		return (-1);

	/* Initialize Key, V, and reseed_counter. */
	memset(drbg.Key, 0x00, 32);
	memset(drbg.V, 0x01, 32);
	drbg.reseed_counter = 1;

	/* Mix the random seed into the state. */
	update(seed_material, 48);

#ifdef CPUSUPPORT_X86_RDRAND
	/* Add output of RDRAND into the state. */
	if (cpusupport_x86_rdrand())
		update_from_rdrand();
#endif

	/* Clean the stack. */
	insecure_memzero(seed_material, 48);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x40(%rbp), %rdi
movl $0x30, %esi
callq 0x13670
cmpl $0x0, %eax
je 0x10ed4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10f3d
leaq 0xe79d(%rip), %rdi      # 0x1f678
xorl %esi, %esi
movl $0x20, %edx
callq 0x2080
leaq 0xe78a(%rip), %rdi      # 0x1f678
addq $0x20, %rdi
movl $0x1, %esi
movl $0x20, %edx
callq 0x2080
movl $0x1, 0xe7ad(%rip)      # 0x1f6b8
leaq -0x40(%rbp), %rdi
movl $0x30, %esi
callq 0x11100
callq 0x11330
cmpl $0x0, %eax
je 0x10f28
callq 0x113a0
leaq -0x40(%rbp), %rdi
movl $0x30, %esi
callq 0x113e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_entropy.c
// Function: reseed
static int
reseed(void)
{
	uint8_t seed_material[32];

	/* Obtain random seed_material = entropy_input. */
	if (entropy_read(seed_material, 32))
		return (-1);

	/* Mix the random seed into the state. */
	update(seed_material, 32);

#ifdef CPUSUPPORT_X86_RDRAND
	/* Add output of RDRAND into the state. */
	if (cpusupport_x86_rdrand())
		update_from_rdrand();
#endif

	/* Reset the reseed_counter. */
	drbg.reseed_counter = 1;

	/* Clean the stack. */
	insecure_memzero(seed_material, 32);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x13670
cmpl $0x0, %eax
je 0x10f74
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10fb0
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x11100
callq 0x11330
cmpl $0x0, %eax
je 0x10f91
callq 0x113a0
movl $0x1, 0xe71d(%rip)      # 0x1f6b8
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x113e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_entropy.c
// Function: generate
static void
generate(uint8_t * buf, size_t buflen)
{
	size_t bufpos;

	assert(buflen <= GENERATE_MAXLEN);
	assert(drbg.reseed_counter <= RESEED_INTERVAL);

	/* Iterate until we've filled the buffer. */
	for (bufpos = 0; bufpos < buflen; bufpos += 32) {
		HMAC_SHA256_Buf(drbg.Key, 32, drbg.V, 32, drbg.V);
		if (buflen - bufpos >= 32)
			memcpy(&buf[bufpos], drbg.V, 32);
		else
			memcpy(&buf[bufpos], drbg.V, buflen - bufpos);
	}

	/* Mix up state. */
	update(NULL, 0);

	/* We're one data-generation step closer to needing a reseed. */
	drbg.reseed_counter += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x10000, -0x10(%rbp)   # imm = 0x10000
ja 0x10fdc
jmp 0x10ffb
leaq 0x7dcd(%rip), %rdi      # 0x18db0
leaq 0x7de0(%rip), %rsi      # 0x18dca
movl $0xb7, %edx
leaq 0x7dfb(%rip), %rcx      # 0x18df1
callq 0x2120
cmpl $0x100, 0xe6b3(%rip)    # imm = 0x100
ja 0x11009
jmp 0x11028
leaq 0x7e02(%rip), %rdi      # 0x18e12
leaq 0x7db3(%rip), %rsi      # 0x18dca
movl $0xb8, %edx
leaq 0x7dce(%rip), %rcx      # 0x18df1
callq 0x2120
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x110d6
leaq 0xe633(%rip), %rdi      # 0x1f678
movl $0x20, %ecx
movq %rdi, %r8
addq $0x20, %r8
movq %rcx, %rsi
movq %r8, %rdx
callq 0x5e70
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
cmpq $0x20, %rax
jb 0x110a3
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0xe61f(%rip), %rdx      # 0x1f698
movq %rdx, (%rax,%rcx)
movq 0xe61c(%rip), %rdx      # 0x1f6a0
movq %rdx, 0x8(%rax,%rcx)
movq 0xe618(%rip), %rdx      # 0x1f6a8
movq %rdx, 0x10(%rax,%rcx)
movq 0xe614(%rip), %rdx      # 0x1f6b0
movq %rdx, 0x18(%rax,%rcx)
jmp 0x110c3
movq -0x8(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
subq -0x18(%rbp), %rdx
leaq 0xe5be(%rip), %rsi      # 0x1f678
addq $0x20, %rsi
callq 0x2470
jmp 0x110c5
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x11030
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x11100
movl 0xe5d0(%rip), %eax      # 0x1f6b8
addl $0x1, %eax
movl %eax, 0xe5c7(%rip)      # 0x1f6b8
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_entropy.c
// Function: update_from_rdrand
static void
update_from_rdrand(void)
{
	unsigned int buf[8];

	/* This is only *extra* entropy, so it's ok if it fails. */
	if (generate_seed_rdrand(buf, 8))
		return;
	update((uint8_t *)buf, sizeof(buf));

	/* Clean up. */
	insecure_memzero(buf, sizeof(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x11450
cmpl $0x0, %eax
je 0x113bd
jmp 0x113d9
leaq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x11100
leaq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x113e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/crypto/crypto_entropy_rdrand.c
// Function: generate_seed_rdrand
int
generate_seed_rdrand(unsigned int * buf, size_t len)
{
	size_t i;

	/* Fill buffer. */
	for (i = 0; i < len; i++) {
		if (!_rdrand32_step(&buf[i]))
			goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x114ab
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
rdrandl %edx
movl $0x1, %esi
movl %edx, %eax
cmovbl %esi, %eax
movl %edx, (%rcx)
cmpl $0x0, %eax
jne 0x1149b
jmp 0x114b4
jmp 0x1149d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11464
movl $0x0, -0xc(%rbp)
jmp 0x114bb
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq