LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/json.c
// Function: skip_object
static const uint8_t *
skip_object(const uint8_t * buf, const uint8_t * end)
{

	/* Advance past the opening '{' and following whitespace. */
	buf++;
	buf = skip_ws(buf, end);

	/* Is this an empty object? */
	if (buf == end)
		return (end);
	if (buf[0] == '}')
		return (&buf[1]);

	/* Skip entries until we get to the end. */
	do {
		/* Skip a string and optional whitespace. */
		buf = skip_string(buf, end);
		buf = skip_ws(buf, end);

		/* We should have a colon next. */
		if (buf == end)
			return (end);
		if (*buf++ != ':')
			return (end);

		/* Skip a whitespace, a value, and more whitespace. */
		buf = skip_ws(buf, end);
		buf = skip_value(buf, end);
		buf = skip_ws(buf, end);

		/* Are we at the end? */
		if (buf == end)
			return (end);
		if (buf[0] == '}')
			return (&buf[1]);

		/* Otherwise we should have a comma. */
		if (*buf++ != ',')
			return (end);
	} while (1);

	/* NOTREACHED */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10650
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x10be4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10cf0
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7d, %eax
jne 0x10c01
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10cf0
jmp 0x10c03
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10a10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10650
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x10c3c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10cf0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
cmpl $0x3a, %eax
je 0x10c60
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10cf0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10650
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10840
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10650
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x10ca7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10cf0
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7d, %eax
jne 0x10cc1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10cf0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
cmpl $0x2c, %eax
je 0x10ce2
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10cf0
jmp 0x10ce4
movb $0x1, %al
testb $0x1, %al
jne 0x10c03
jmp 0x10cf0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/json.c
// Function: skip_number
static const uint8_t *
skip_number(const uint8_t * buf, const uint8_t * end)
{

	/*
	 * In valid JSON, any sequence of (unquoted) characters which
	 * individually can be found in a number must collectively be a
	 * number -- so we eat those until we run out.
	 */
	while (buf < end) {
		if (strchr(numchars, buf[0]) == NULL)
			break;
		buf++;
	}

	/* Return our current position. */
	return (buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x10d43
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
leaq 0x15998(%rip), %rdi     # 0x266c0
callq 0x3170
cmpq $0x0, %rax
jne 0x10d35
jmp 0x10d43
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10d10
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/https.c
// Function: https_request
void *
https_request(struct sock_addr * const * addrs, struct http_request * request,
    size_t maxrlen, int (* callback)(void *, struct http_response *),
    void * cookie, const char * hostname)
{
	struct http_cookie * H;
	char * sslhost;

	/* Set function pointers. */
	network_ssl_open_func = network_ssl_open;
	network_ssl_close_func = network_ssl_close;
	netbuf_ssl_read_init_func = netbuf_ssl_read_init;
	netbuf_ssl_write_init_func = netbuf_ssl_write_init;

	/* Duplicate the hostname. */
	if ((sslhost = strdup(hostname)) == NULL)
		goto err0;

	/* Create an HTTP state. */
	if ((H = http_request2(addrs, request, maxrlen, callback,
	    cookie, sslhost)) == NULL)
		goto err1;

	/* Success! */
	return (H);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
leaq 0x22b11(%rip), %rax     # 0x36798
leaq 0x152(%rip), %rcx       # 0x13de0
movq %rcx, (%rax)
leaq 0x22b08(%rip), %rax     # 0x367a0
leaq 0xa61(%rip), %rcx       # 0x14700
movq %rcx, (%rax)
leaq 0x22aff(%rip), %rax     # 0x367a8
leaq 0x80(%rip), %rcx        # 0x13d30
movq %rcx, (%rax)
leaq 0x22af6(%rip), %rax     # 0x367b0
leaq 0xbf(%rip), %rcx        # 0x13d80
movq %rcx, (%rax)
movq -0x38(%rbp), %rdi
callq 0x35f0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x13cd9
jmp 0x13d15
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x48(%rbp), %r9
callq 0xc450
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x13d02
jmp 0x13d0c
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13d1d
movq -0x48(%rbp), %rdi
callq 0x3460
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: init
static int
init(void)
{
	const SSL_METHOD * meth;

	/* If we have a context already, there's nothing to do. */
	if (ctx != NULL)
		return (0);

	/* Launch SSL. */
	if (!SSL_library_init()) {
		warn0("Could not initialize SSL library");
		goto err0;
	}

	/* We want to use TLS. */
	if ((meth = TLS_client_method()) == NULL) {
		warn0("TLS_client_method");
		goto err0;
	}

	/* Create an SSL context. */
	if ((ctx = SSL_CTX_new(meth)) == NULL) {
		warn0("Could not create SSL context");
		goto err0;
	}

	/* Insist on a minimum of TLS 1.2. */
	if (!SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION)) {
		warn0("Could not set minimum TLS version");
		goto err1;
	}

	/* Partial writes are a thing. */
	SSL_CTX_set_mode(ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);

	/* Load root certificates. */
	if (!SSL_CTX_set_default_verify_paths(ctx)) {
		warn0("Could not load default root certificates");
		goto err1;
	}

	/* Release the context when we exit. */
	atexit(network_ssl_atexit);

	/* Success! */
	return (0);

err1:
	SSL_CTX_free(ctx);
	ctx = NULL;
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x22880(%rip)     # 0x368e0
je 0x1406e
movl $0x0, -0x4(%rbp)
jmp 0x141bc
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x3320
cmpl $0x0, %eax
jne 0x1409f
jmp 0x14081
leaq 0xc57e(%rip), %rdi      # 0x20606
movb $0x0, %al
callq 0x6930
callq 0x3040
movl $0x0, (%rax)
jmp 0x141b5
callq 0x31d0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x140ce
jmp 0x140b0
leaq 0xc570(%rip), %rdi      # 0x20627
movb $0x0, %al
callq 0x6930
callq 0x3040
movl $0x0, (%rax)
jmp 0x141b5
movq -0x10(%rbp), %rdi
callq 0x3520
movq %rax, 0x22802(%rip)     # 0x368e0
cmpq $0x0, %rax
jne 0x14104
jmp 0x140e6
leaq 0xc54c(%rip), %rdi      # 0x20639
movb $0x0, %al
callq 0x6930
callq 0x3040
movl $0x0, (%rax)
jmp 0x141b5
movq 0x227d5(%rip), %rdi     # 0x368e0
movl $0x7b, %esi
movl $0x303, %edx            # imm = 0x303
xorl %eax, %eax
movl %eax, %ecx
callq 0x3330
cmpq $0x0, %rax
jne 0x14141
jmp 0x14126
leaq 0xc529(%rip), %rdi      # 0x20656
movb $0x0, %al
callq 0x6930
callq 0x3040
movl $0x0, (%rax)
jmp 0x1419e
movq 0x22798(%rip), %rdi     # 0x368e0
movl $0x21, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3330
movq 0x2277e(%rip), %rdi     # 0x368e0
callq 0x3410
cmpl $0x0, %eax
jne 0x14189
jmp 0x1416e
leaq 0xc503(%rip), %rdi      # 0x20678
movb $0x0, %al
callq 0x6930
callq 0x3040
movl $0x0, (%rax)
jmp 0x1419e
leaq 0x6a0(%rip), %rdi       # 0x14830
callq 0x1d210
movl $0x0, -0x4(%rbp)
jmp 0x141bc
movq 0x2273b(%rip), %rdi     # 0x368e0
callq 0x3070
movq $0x0, 0x2272b(%rip) # 0x368e0
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/network_ssl/network_ssl.c
// Function: network_ssl_read
void *
network_ssl_read(struct network_ssl_ctx * ssl, uint8_t * buf,
    size_t buflen, size_t minread,
    int (* callback)(void *, ssize_t), void * cookie)
{

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

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

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

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

	/* Record details of the pending request. */
	ssl->read_callback = callback;
	ssl->read_cookie = cookie;
	ssl->read_buf = buf;
	ssl->read_buflen = buflen;
	ssl->read_minlen = minread;
	ssl->read_bufpos = 0;
	ssl->read_needs_r = 0;
	ssl->read_needs_w = 0;

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

	/* Success! */
	return (ssl);

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

// Assembly:
pushq %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)
movq %r9, -0x38(%rbp)
cmpq $0x0, 0x226e8(%rip)     # 0x368e0
je 0x141fc
jmp 0x1421b
leaq 0xc24f(%rip), %rdi      # 0x20452
leaq 0xc254(%rip), %rsi      # 0x2045e
movl $0x23f, %edx            # imm = 0x23F
leaq 0xc271(%rip), %rcx      # 0x20487
callq 0x3240
cmpq $0x0, -0x20(%rbp)
je 0x14224
jmp 0x14243
leaq 0xb59d(%rip), %rdi      # 0x1f7c8
leaq 0xc22c(%rip), %rsi      # 0x2045e
movl $0x242, %edx            # imm = 0x242
leaq 0xc249(%rip), %rcx      # 0x20487
callq 0x3240
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x20(%rbp)
ja 0x14255
jmp 0x14274
leaq 0xb5f3(%rip), %rdi      # 0x1f84f
leaq 0xc1fb(%rip), %rsi      # 0x2045e
movl $0x245, %edx            # imm = 0x245
leaq 0xc218(%rip), %rcx      # 0x20487
callq 0x3240
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x14281
jmp 0x142a0
leaq 0xc26d(%rip), %rdi      # 0x204f5
leaq 0xc1cf(%rip), %rsi      # 0x2045e
movl $0x248, %edx            # imm = 0x248
leaq 0xc1ec(%rip), %rcx      # 0x20487
callq 0x3240
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x54(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1432d
movq -0x10(%rbp), %rsi
leaq 0x3c(%rip), %rdi        # 0x14350
xorl %edx, %edx
callq 0x4a30
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x1432b
jmp 0x14337
jmp 0x1432d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1433f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: network_ssl_read_cancel
void
network_ssl_read_cancel(void * cookie)
{
	struct network_ssl_ctx * ssl = cookie;

	/* No more pending read request. */
	ssl->read_callback = NULL;

	/*
	 * It's possible that we don't need any more network events; we need
	 * to make sure we deregister our callbacks in order to have them
	 * out of the way of future operations on the underlying socket.
	 */
	ssl->read_needs_r = ssl->read_needs_w = 0;

	/* We're only (potentially) cancelling events now; so this is safe. */
	(void)setupevents(ssl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x54(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0x143d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: setupevents
static int
setupevents(struct network_ssl_ctx * ssl)
{

	/* Cancel network events if no longer needed. */
	if (ssl->waiting_r && !ssl->read_needs_r && !ssl->write_needs_r) {
		if (events_network_cancel(ssl->s, EVENTS_NETWORK_OP_READ))
			goto err0;
		ssl->waiting_r = 0;
	}
	if (ssl->waiting_w && !ssl->read_needs_w && !ssl->write_needs_w) {
		if (events_network_cancel(ssl->s, EVENTS_NETWORK_OP_WRITE))
			goto err0;
		ssl->waiting_w = 0;
	}

	/* Register network events if needed. */
	if (!ssl->waiting_r && (ssl->read_needs_r || ssl->write_needs_r)) {
		if (events_network_register(callback_read, ssl, ssl->s,
		    EVENTS_NETWORK_OP_READ))
			goto err0;
		ssl->waiting_r = 1;
	}
	if (!ssl->waiting_w && (ssl->read_needs_w || ssl->write_needs_w)) {
		if (events_network_register(callback_write, ssl, ssl->s,
		    EVENTS_NETWORK_OP_WRITE))
			goto err0;
		ssl->waiting_w = 1;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1441f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x1441f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88(%rax)
jne 0x1441f
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
callq 0x5530
cmpl $0x0, %eax
je 0x14414
jmp 0x14507
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x14465
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x14465
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
jne 0x14465
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
callq 0x5530
cmpl $0x0, %eax
je 0x1445a
jmp 0x14507
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x144b0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x14486
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88(%rax)
je 0x144b0
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0xae9(%rip), %rdi       # 0x14f80
xorl %ecx, %ecx
callq 0x4fd0
cmpl $0x0, %eax
je 0x144a5
jmp 0x14507
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x144fe
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x144d1
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
je 0x144fe
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0xaee(%rip), %rdi       # 0x14fd0
movl $0x1, %ecx
callq 0x4fd0
cmpl $0x0, %eax
je 0x144f3
jmp 0x14507
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1450e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: network_ssl_write_cancel
void
network_ssl_write_cancel(void * cookie)
{
	struct network_ssl_ctx * ssl = cookie;

	/* No more pending write request. */
	ssl->write_callback = NULL;

	/*
	 * It's possible that we don't need any more network events; we need
	 * to make sure we deregister our callbacks in order to have them
	 * out of the way of future operations on the underlying socket.
	 */
	ssl->write_needs_r = ssl->write_needs_w = 0;

	/* We're only (potentially) cancelling events now; so this is safe. */
	(void)setupevents(ssl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x10(%rbp), %rdi
callq 0x143d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: network_ssl_close
void
network_ssl_close(struct network_ssl_ctx * ssl)
{

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x14715
jmp 0x14734
leaq 0xbe85(%rip), %rdi      # 0x205a1
leaq 0xbd3b(%rip), %rsi      # 0x2045e
movl $0x2cf, %edx            # imm = 0x2CF
leaq 0xbe7e(%rip), %rcx      # 0x205ad
callq 0x3240
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1474c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4b80
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x14759
jmp 0x14778
leaq 0xbd95(%rip), %rdi      # 0x204f5
leaq 0xbcf7(%rip), %rsi      # 0x2045e
movl $0x2d6, %edx            # imm = 0x2D6
leaq 0xbe3a(%rip), %rcx      # 0x205ad
callq 0x3240
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x14785
jmp 0x147a4
leaq 0xbdf9(%rip), %rdi      # 0x20585
leaq 0xbccb(%rip), %rsi      # 0x2045e
movl $0x2d7, %edx            # imm = 0x2D7
leaq 0xbe0e(%rip), %rcx      # 0x205ad
callq 0x3240
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x147b0
jmp 0x147cf
leaq 0xbe27(%rip), %rdi      # 0x205de
leaq 0xbca0(%rip), %rsi      # 0x2045e
movl $0x2da, %edx            # imm = 0x2DA
leaq 0xbde3(%rip), %rcx      # 0x205ad
callq 0x3240
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x147db
jmp 0x147fa
leaq 0xbe10(%rip), %rdi      # 0x205f2
leaq 0xbc75(%rip), %rsi      # 0x2045e
movl $0x2db, %edx            # imm = 0x2DB
leaq 0xbdb8(%rip), %rcx      # 0x205ad
callq 0x3240
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3430
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3200
movq -0x8(%rbp), %rdi
callq 0x3460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: poke
static int
poke(struct network_ssl_ctx * ssl)
{

	/* Should we try to read? */
	if (ssl->read_callback != NULL &&
	    !ssl->read_needs_r && !ssl->read_needs_w) {
		if (doread(ssl))
			goto err0;
	}

	/* Should we try to write? */
	if (ssl->write_callback != NULL &&
	    !ssl->write_needs_r && !ssl->write_needs_w) {
		if (dowrite(ssl))
			goto err0;
	}

	/* Wait for socket readability/writability as needed. */
	if (setupevents(ssl))
		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
cmpq $0x0, 0x20(%rax)
je 0x148bd
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x148bd
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x148bd
movq -0x10(%rbp), %rdi
callq 0x14920
cmpl $0x0, %eax
je 0x148bb
jmp 0x1490d
jmp 0x148bd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x148f4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88(%rax)
jne 0x148f4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
jne 0x148f4
movq -0x10(%rbp), %rdi
callq 0x14c40
cmpl $0x0, %eax
je 0x148f2
jmp 0x1490d
jmp 0x148f4
movq -0x10(%rbp), %rdi
callq 0x143d0
cmpl $0x0, %eax
je 0x14904
jmp 0x1490d
movl $0x0, -0x4(%rbp)
jmp 0x14914
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: callback_read
static int
callback_read(void * cookie)
{
	struct network_ssl_ctx * ssl = cookie;

	/* No longer waiting for socket to be readable. */
	ssl->waiting_r = 0;

	/*
	 * Any operations which were waiting for the socket to become
	 * readable are now free to run.
	 */
	ssl->read_needs_r = 0;
	ssl->write_needs_r = 0;

	/* Poke the SSL stack. */
	return (poke(ssl));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x10(%rbp), %rdi
callq 0x14880
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/network_ssl/network_ssl.c
// Function: callback_write
static int
callback_write(void * cookie)
{
	struct network_ssl_ctx * ssl = cookie;

	/* No longer waiting for socket to be writable. */
	ssl->waiting_w = 0;

	/*
	 * Any operations which were waiting for the socket to become
	 * writable are now free to run.
	 */
	ssl->read_needs_w = 0;
	ssl->write_needs_w = 0;

	/* Poke the SSL stack. */
	return (poke(ssl));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x54(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x10(%rbp), %rdi
callq 0x14880
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/hexify.c
// Function: hexify
void
hexify(const uint8_t * in, char * out, size_t len)
{
	char * p = out;
	size_t i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x151f2
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x1152d(%rip), %rax     # 0x266d0
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x11500(%rip), %rax     # 0x266d0
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15180
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/hexify.c
// Function: unhexify
int
unhexify(const char * in, uint8_t * out, size_t len)
{
	size_t i;
	ptrdiff_t pos;

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

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

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

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x15270
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1525b
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x11480(%rip), %rdi     # 0x266d0
callq 0x3170
cmpq $0x0, %rax
jne 0x15260
jmp 0x15330
jmp 0x15262
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1521c
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x15327
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq %rcx
movsbl (%rax,%rcx), %esi
leaq 0x11434(%rip), %rdi     # 0x266d0
callq 0x3170
leaq 0x11428(%rip), %rcx     # 0x266d0
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq $0xf, %rax
shlq $0x4, %rax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq %rcx
movsbl 0x1(%rax,%rcx), %esi
leaq 0x113f1(%rip), %rdi     # 0x266d0
callq 0x3170
leaq 0x113e5(%rip), %rcx     # 0x266d0
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x30(%rbp), %rcx
andq $0xf, %rcx
addq %rcx, %rax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15278
movl $0x0, -0x4(%rbp)
jmp 0x15337
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: hwaccel_init
static void
hwaccel_init(void)
{
	uint32_t W[64];
	uint32_t S[8];
	uint8_t block[64];
	uint8_t i;

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

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

	/* Test case: Hash 0x00 0x01 0x02 ... 0x3f. */
	for (i = 0; i < 64; i++)
		block[i] = i;

#if defined(CPUSUPPORT_X86_SHANI) && defined(CPUSUPPORT_X86_SSSE3)
	CPUSUPPORT_VALIDATE(hwaccel, HW_X86_SHANI,
	    cpusupport_x86_shani() && cpusupport_x86_ssse3(),
	    hwtest(initial_state, block, W, S,
		SHA256_Transform_shani_with_W_S));
#endif
#if defined(CPUSUPPORT_X86_SSE2)
	CPUSUPPORT_VALIDATE(hwaccel, HW_X86_SSE2, cpusupport_x86_sse2(),
	    hwtest(initial_state, block, W, S, SHA256_Transform_sse2));
#endif
#if defined(CPUSUPPORT_ARM_SHA256)
	CPUSUPPORT_VALIDATE(hwaccel, HW_ARM_SHA256, cpusupport_arm_sha256(),
	    hwtest(initial_state, block, W, S, SHA256_Transform_arm_with_W_S));
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
cmpl $0x3, 0x112f2(%rip)     # 0x266f4
je 0x15409
jmp 0x15523
movl $0x0, 0x112e1(%rip)     # 0x266f4
movb $0x0, -0x161(%rbp)
movzbl -0x161(%rbp), %eax
cmpl $0x40, %eax
jge 0x1544a
movb -0x161(%rbp), %cl
movzbl -0x161(%rbp), %eax
movb %cl, -0x160(%rbp,%rax)
movb -0x161(%rbp), %al
addb $0x1, %al
movb %al, -0x161(%rbp)
jmp 0x1541a
jmp 0x1544c
callq 0x15fe0
cmpl $0x0, %eax
je 0x154bb
callq 0x16050
cmpl $0x0, %eax
je 0x154bb
leaq -0x160(%rbp), %rsi
leaq -0x100(%rbp), %rdx
leaq -0x120(%rbp), %rcx
leaq 0xb324(%rip), %rdi      # 0x207a0
leaq 0xced(%rip), %r8        # 0x16170
callq 0x160c0
cmpl $0x0, %eax
jne 0x1549c
movl $0x1, 0x1125d(%rip)     # 0x266f4
jmp 0x15523
jmp 0x1549e
leaq 0xb4fc(%rip), %rdi      # 0x209a1
movb $0x0, %al
callq 0x6930
callq 0x3040
movl $0x0, (%rax)
jmp 0x154b9
jmp 0x154bb
jmp 0x154bd
jmp 0x154bf
callq 0x161a0
cmpl $0x0, %eax
je 0x15521
leaq -0x160(%rbp), %rsi
leaq -0x100(%rbp), %rdx
leaq -0x120(%rbp), %rcx
leaq 0xb2bb(%rip), %rdi      # 0x207a0
leaq 0x5764(%rip), %r8       # 0x1ac50
callq 0x160c0
cmpl $0x0, %eax
jne 0x15502
movl $0x2, 0x111f4(%rip)     # 0x266f4
jmp 0x15523
jmp 0x15504
leaq 0xb4c5(%rip), %rdi      # 0x209d0
movb $0x0, %al
callq 0x6930
callq 0x3040
movl $0x0, (%rax)
jmp 0x1551f
jmp 0x15521
jmp 0x15523
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: SHA256_Update_internal
static void
SHA256_Update_internal(SHA256_CTX * ctx, const void * in, size_t len,
    uint32_t tmp32[static restrict 72])
{
	uint32_t r;
	const uint8_t * src = in;

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x155ac
jmp 0x156c7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x3, %rax
andq $0x3f, %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
movq -0x8(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x40, %ecx
subl -0x24(%rbp), %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x15606
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x24(%rbp), %eax
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x32c0
jmp 0x156c7
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x24(%rbp), %eax
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movl $0x40, %eax
subl -0x24(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x100, %rcx            # imm = 0x100
callq 0x16210
movl $0x40, %ecx
subl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x40, %eax
subl -0x24(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x40, -0x18(%rbp)
jb 0x156b2
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x100, %rcx            # imm = 0x100
callq 0x16210
movq -0x30(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x18(%rbp)
jmp 0x15675
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x32c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: libcperciva_SHA256_Buf
void
SHA256_Buf(const void * in, size_t len, uint8_t digest[32])
{
	SHA256_CTX ctx;
	uint32_t tmp32[72];

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x15390
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x1a0(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x15580
movq -0x18(%rbp), %rdi
leaq -0x1a0(%rbp), %rdx
leaq -0x80(%rbp), %rsi
callq 0x15750
leaq -0x80(%rbp), %rdi
movl $0x68, %esi
callq 0x156d0
leaq -0x1a0(%rbp), %rdi
movl $0x120, %esi            # imm = 0x120
callq 0x156d0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: libcperciva_HMAC_SHA256_Init
void
HMAC_SHA256_Init(HMAC_SHA256_CTX * ctx, const void * K, size_t Klen)
{
	uint32_t tmp32[72];
	uint8_t pad[64];
	uint8_t khash[32];

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x140(%rbp), %rcx
leaq -0x180(%rbp), %r8
leaq -0x1a0(%rbp), %r9
callq 0x15890
leaq -0x140(%rbp), %rdi
movl $0x120, %esi            # imm = 0x120
callq 0x156d0
leaq -0x1a0(%rbp), %rdi
movl $0x20, %esi
callq 0x156d0
leaq -0x180(%rbp), %rdi
movl $0x40, %esi
callq 0x156d0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: HMAC_SHA256_Init_internal
static void
HMAC_SHA256_Init_internal(HMAC_SHA256_CTX * ctx, const void * _k, size_t Klen,
    uint32_t tmp32[static restrict 72], uint8_t pad[static restrict 64],
    uint8_t khash[static restrict 32])
{
	const uint8_t * K = _k;
	size_t i;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x40, -0x18(%rbp)
jbe 0x158fe
movq -0x8(%rbp), %rdi
callq 0x15390
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x15580
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x15750
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x20, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15390
movq -0x28(%rbp), %rdi
movl $0x36, %esi
movl $0x40, %edx
callq 0x31e0
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x15957
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %esi
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x15922
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x40, %edx
callq 0x15580
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x15390
movq -0x28(%rbp), %rdi
movl $0x5c, %esi
movl $0x40, %edx
callq 0x31e0
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x159ca
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %esi
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x15995
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x40, %edx
callq 0x15580
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: libcperciva_HMAC_SHA256_Final
void
HMAC_SHA256_Final(uint8_t digest[32], HMAC_SHA256_CTX * ctx)
{
	uint32_t tmp32[72];
	uint8_t ihash[32];

	/* Call the real function. */
	HMAC_SHA256_Final_internal(digest, ctx, tmp32, ihash);

	/* Clear the context state. */
	insecure_memzero(ctx, sizeof(HMAC_SHA256_CTX));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x130(%rbp), %rdx
leaq -0x150(%rbp), %rcx
callq 0x15af0
movq -0x10(%rbp), %rdi
movl $0xd0, %esi
callq 0x156d0
leaq -0x130(%rbp), %rdi
movl $0x120, %esi            # imm = 0x120
callq 0x156d0
leaq -0x150(%rbp), %rdi
movl $0x20, %esi
callq 0x156d0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: libcperciva_HMAC_SHA256_Buf
void
HMAC_SHA256_Buf(const void * K, size_t Klen, const void * in, size_t len,
    uint8_t digest[32])
{
	HMAC_SHA256_CTX ctx;
	uint32_t tmp32[72];
	uint8_t tmp8[96];

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x220(%rbp), %rcx
leaq -0x280(%rbp), %r8
leaq -0x280(%rbp), %r9
addq $0x40, %r9
leaq -0xf8(%rbp), %rdi
callq 0x15890
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x220(%rbp), %rcx
leaq -0xf8(%rbp), %rdi
callq 0x15a40
movq -0x28(%rbp), %rdi
leaq -0x220(%rbp), %rdx
leaq -0x280(%rbp), %rcx
leaq -0xf8(%rbp), %rsi
callq 0x15af0
leaq -0xf8(%rbp), %rdi
movl $0xd0, %esi
callq 0x156d0
leaq -0x220(%rbp), %rdi
movl $0x120, %esi            # imm = 0x120
callq 0x156d0
leaq -0x280(%rbp), %rdi
movl $0x60, %esi
callq 0x156d0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: hwtest
static int
hwtest(const uint32_t state[static restrict 8],
    const uint8_t block[static restrict 64],
    uint32_t W[static restrict 64], uint32_t S[static restrict 8],
    void (* func)(uint32_t state[static restrict 8],
    const uint8_t block[static restrict 64], uint32_t W[static restrict 64],
    uint32_t S[static restrict 8]))
{
	uint32_t state_sw[8];
	uint32_t state_hw[8];

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%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)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x16210
movq -0x8(%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 -0x28(%rbp), %rax
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x20, %edx
callq 0x31b0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: be32dec_vect
static void
be32dec_vect(uint32_t * dst, const uint8_t * src, size_t len)
{
	size_t i;

	/* Sanity-check. */
	assert(len % 4 == 0);

	/* Decode vector, one word at a time. */
	for (i = 0; i < len / 4; i++)
		dst[i] = be32dec(src + i * 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x18714
jmp 0x18733
leaq 0x82e3(%rip), %rdi      # 0x209fe
leaq 0x8201(%rip), %rsi      # 0x20923
movl $0x48, %edx
leaq 0x82dd(%rip), %rcx      # 0x20a0b
callq 0x3240
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x2, %rcx
cmpq %rcx, %rax
jae 0x1877b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x18790
movl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1873b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: SHA256_Pad
static void
SHA256_Pad(SHA256_CTX * ctx, uint32_t tmp32[static restrict 72])
{
	size_t r;

	/* Figure out how many bytes we have buffered. */
	r = (ctx->count >> 3) & 0x3f;

	/* Pad to 56 mod 64, transforming if we finish a block en route. */
	if (r < 56) {
		/* Pad to 56 mod 64. */
		memcpy(&ctx->buf[r], PAD, 56 - r);
	} else {
		/* Finish the current block and mix. */
		memcpy(&ctx->buf[r], PAD, 64 - r);
		SHA256_Transform(ctx->state, ctx->buf, &tmp32[0], &tmp32[64]);

		/* The start of the final block is all zeroes. */
		memset(&ctx->buf[0], 0, 56);
	}

	/* Add the terminating bit-count. */
	be64enc(&ctx->buf[56], ctx->count);

	/* Mix in the final block. */
	SHA256_Transform(ctx->state, ctx->buf, &tmp32[0], &tmp32[64]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x3, %rax
andq $0x3f, %rax
movq %rax, -0x18(%rbp)
cmpq $0x38, -0x18(%rbp)
jae 0x1881e
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
addq -0x18(%rbp), %rdi
movl $0x38, %edx
subq -0x18(%rbp), %rdx
leaq 0x80a9(%rip), %rsi      # 0x208c0
callq 0x32c0
jmp 0x18873
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
addq -0x18(%rbp), %rdi
movl $0x40, %edx
subq -0x18(%rbp), %rdx
leaq 0x8086(%rip), %rsi      # 0x208c0
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x100, %rcx            # imm = 0x100
callq 0x16210
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x31e0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
addq $0x38, %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x18950
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x100, %rcx            # imm = 0x100
callq 0x16210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256.c
// Function: be32enc_vect
static void
be32enc_vect(uint8_t * dst, const uint32_t * src, size_t len)
{
	size_t i;

	/* Sanity-check. */
	assert(len % 4 == 0);

	/* Encode vector, one word at a time. */
	for (i = 0; i < len / 4; i++)
		be32enc(dst + i * 4, src[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x188e4
jmp 0x18903
leaq 0x8113(%rip), %rdi      # 0x209fe
leaq 0x8031(%rip), %rsi      # 0x20923
movl $0x37, %edx
leaq 0x8144(%rip), %rcx      # 0x20a42
callq 0x3240
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x2, %rcx
cmpq %rcx, %rax
jae 0x18949
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x15f70
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1890b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256_sse2.c
// Function: mm_bswap_epi32
static inline __m128i
mm_bswap_epi32(__m128i a)
{

	/* Swap bytes in each 16-bit word. */
	a = _mm_or_si128(_mm_slli_epi16(a, 8), _mm_srli_epi16(a, 8));

	/* Swap all 16-bit words. */
	a = _mm_shufflelo_epi16(a, _MM_SHUFFLE(2, 3, 0, 1));
	a = _mm_shufflehi_epi16(a, _MM_SHUFFLE(2, 3, 0, 1));

	return (a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps %xmm0, -0x70(%rbp)
movaps -0x70(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movl $0x8, -0x34(%rbp)
movaps -0x30(%rbp), %xmm1
movd -0x34(%rbp), %xmm0
psllw %xmm0, %xmm1
movaps -0x70(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movl $0x8, -0x14(%rbp)
movaps -0x10(%rbp), %xmm0
movd -0x14(%rbp), %xmm2
psrlw %xmm2, %xmm0
movaps %xmm1, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps -0x50(%rbp), %xmm0
movaps -0x60(%rbp), %xmm1
por %xmm1, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps -0x70(%rbp), %xmm0
pshuflw $0xb1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,3,2,4,5,6,7]
movaps %xmm0, -0x70(%rbp)
movaps -0x70(%rbp), %xmm0
pshufhw $0xb1, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,5,4,7,6]
movdqa %xmm0, -0x70(%rbp)
movdqa -0x70(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/sha256_sse2.c
// Function: s1_128_low
static inline __m128i
s1_128_low(__m128i a)
{
	__m128i b;
	__m128i c;

	/* ROTR, loading data as {B, B, A, A}; lanes 1 & 3 will be junk. */
	b = _mm_shuffle_epi32(a, _MM_SHUFFLE(3, 3, 2, 2));
	c = _mm_xor_si128(_mm_srli_epi64(b, 17), _mm_srli_epi64(b, 19));

	/* Shift and XOR with rotated data; lanes 1 & 3 will be junk. */
	c = _mm_xor_si128(c, _mm_srli_epi32(b, 10));

	/* Shuffle good data back and zero unwanted lanes. */
	c = _mm_shuffle_epi32(c, _MM_SHUFFLE(2, 0, 2, 0));
	c = _mm_srli_si128(c, 8);

	return (c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movaps %xmm0, -0xb0(%rbp)
movaps -0xb0(%rbp), %xmm0
pshufd $0xfa, %xmm0, %xmm0     # xmm0 = xmm0[2,2,3,3]
movaps %xmm0, -0xc0(%rbp)
movaps -0xc0(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movl $0x11, -0x14(%rbp)
movaps -0x10(%rbp), %xmm1
movd -0x14(%rbp), %xmm0
psrlq %xmm0, %xmm1
movaps -0xc0(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movl $0x13, -0x34(%rbp)
movaps -0x30(%rbp), %xmm0
movd -0x34(%rbp), %xmm2
psrlq %xmm2, %xmm0
movaps %xmm1, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps -0x70(%rbp), %xmm0
movaps -0x80(%rbp), %xmm1
pxor %xmm1, %xmm0
movaps %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm1
movaps -0xc0(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl $0xa, -0x54(%rbp)
movaps -0x50(%rbp), %xmm0
movd -0x54(%rbp), %xmm2
psrld %xmm2, %xmm0
movaps %xmm1, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps -0x90(%rbp), %xmm0
movaps -0xa0(%rbp), %xmm1
pxor %xmm1, %xmm0
movaps %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm0
pshufd $0x88, %xmm0, %xmm0     # xmm0 = xmm0[0,2,0,2]
movaps %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm0
psrldq $0x8, %xmm0             # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
movdqa %xmm0, -0xd0(%rbp)
movdqa -0xd0(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)