LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-test1.c
// Function: comparator
static int comparator(void *left, void *right)
{
    char *l = (char *) left, *r = (char *) right;
    int n = strcmp(l, r);
    if (n < 0)
        return -1;
    else if (n > 0)
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1080
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x258f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25a5
cmpl $0x0, -0x2c(%rbp)
jle 0x259e
movl $0x1, -0x4(%rbp)
jmp 0x25a5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-test1.c
// Function: dofile
static void dofile(char *fname, FILE * fin, aa * tree)
{
    char *ln;

    while (fggets(&ln, fin) == 0) {
        switch (aa_add(tree, ln, duplicate)) {
        case 0:                /* no error */
            break;
        case 2:                /* memory error */
            free(ln);
            error(tree);
            break;
        default:               /* can't happen */
            fprintf(stderr, "can't happen\n");
            free(ln);
            cleanup(tree);
            exit(EXIT_FAILURE);
            break;
        }
    }

    if (ferror(fin) != 0)
        handle_ferr(fname, "aa-test1");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1210
cmpl $0x0, %eax
jne 0x264e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x10b(%rip), %rdx       # 0x26f0
callq 0x1450
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
testl %eax, %eax
je 0x25ff
jmp 0x25f5
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x2601
jmp 0x2615
jmp 0x2649
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x2720
jmp 0x2649
movq 0x29dc(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xaa9(%rip), %rsi       # 0x30cf
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x26c0
movl $0x1, %edi
callq 0x10f0
jmp 0x25c4
movq -0x10(%rbp), %rdi
callq 0x1040
cmpl $0x0, %eax
je 0x266c
movq -0x8(%rbp), %rdi
leaq 0xa5f(%rip), %rsi       # 0x30c6
callq 0x1390
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/dynamodb_queue/main.c
// Function: donereq
static int
donereq(void * cookie, struct http_response * R, const char * err)
{

	(void)cookie; /* UNUSED */
	(void)err; /* UNUSED */

	/* This request is over. */
	if (--inprogress == 0)
		done = 1;

	/* Print status. */
	printf("HTTP status = %d; ", R->status);

	/* Print the body received. */
	fwrite(R->body, 1, R->bodylen, stdout);
	fprintf(stdout, "\n");

	/* Free the body. */
	free(R->body);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl 0x2276e(%rip), %eax     # 0x26708
addl $-0x1, %eax
movl %eax, 0x22765(%rip)     # 0x26708
cmpl $0x0, %eax
jne 0x3fb2
movl $0x1, 0x22752(%rip)     # 0x26704
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x1a1c3(%rip), %rdi     # 0x1e182
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq 0x21feb(%rip), %rax     # 0x25fc8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x3640
movq 0x21fd7(%rip), %rax     # 0x25fc8
movq (%rax), %rdi
leaq 0x1b024(%rip), %rsi     # 0x1f01f
movb $0x0, %al
callq 0x3530
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3460
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/insecure_memzero.c
// Function: insecure_memzero_func
static void
insecure_memzero_func(volatile void * buf, size_t len)
{
	volatile uint8_t * _buf = buf;
	size_t i;

	for (i = 0; i < len; i++)
		_buf[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x62f0
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x62cc
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/dynamodb/dynamodb_request_queue.c
// Function: dynamodb_request_queue_setcapacity
void
dynamodb_request_queue_setcapacity(struct dynamodb_request_queue * Q,
    long capacity)
{

	/* Record rate at which new capacity arrives. */
	if (capacity > 0)
		Q->cappers = (double)capacity;
	else
		Q->cappers = 1000000.0;

	/* How long does it take for one capacity unit to arrive? */
	if (capacity > 0)
		Q->spercap = 1.0 / (double)capacity;
	else
		Q->spercap = 0.0;

	/*
	 * Allow up to 5 seconds worth of requests to be in flight at once
	 * (in the event of request bursts), up to a maximum of 500 requests
	 * (to avoid having an unreasonable number of connections open at
	 * once -- with single-digit request latencies, this is >50k requests
	 * per second, so it's not likely to be a problem).
	 */
	if ((capacity > 0) && (capacity < 100))
		Q->maxburst_cap = (double)capacity * 5.0;
	else
		Q->maxburst_cap = 500.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jle 0x83f4
cvtsi2sdq -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x28(%rax)
jmp 0x8405
movq -0x8(%rbp), %rax
movsd 0x160b0(%rip), %xmm0    # 0x1e4b0
movsd %xmm0, 0x28(%rax)
cmpq $0x0, -0x10(%rbp)
jle 0x8429
cvtsi2sdq -0x10(%rbp), %xmm1
movsd 0x16086(%rip), %xmm0    # 0x1e4a0
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
jmp 0x8435
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
cmpq $0x0, -0x10(%rbp)
jle 0x8460
cmpq $0x64, -0x10(%rbp)
jge 0x8460
cvtsi2sdq -0x10(%rbp), %xmm0
movsd 0x1646f(%rip), %xmm1    # 0x1e8c0
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x50(%rax)
jmp 0x8471
movq -0x8(%rbp), %rax
movsd 0x1644c(%rip), %xmm0    # 0x1e8b8
movsd %xmm0, 0x50(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/dynamodb/dynamodb_request_queue.c
// Function: compar
static int
compar(void * cookie, const void * x, const void * y)
{
	const struct request * _x = x;
	const struct request * _y = y;

	(void)cookie; /* UNUSED */

	/* Is one of the requests in progress? */
	if ((_x->timeout_cookie != NULL) && (_y->timeout_cookie == NULL))
		return (1);
	if ((_x->timeout_cookie == NULL) && (_y->timeout_cookie != NULL))
		return (-1);

	/* Is one a higher priority? */
	if (_x->prio > _y->prio)
		return (1);
	if (_x->prio < _y->prio)
		return (-1);

	/* Sort in order of arrival. */
	if (_x->reqnum > _y->reqnum)
		return (1);
	else
		return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x84bf
movq -0x30(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x84bf
movl $0x1, -0x4(%rbp)
jmp 0x8538
movq -0x28(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x84de
movq -0x30(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x84de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8538
movq -0x28(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jle 0x84f7
movl $0x1, -0x4(%rbp)
jmp 0x8538
movq -0x28(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jge 0x8510
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8538
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jbe 0x8531
movl $0x1, -0x4(%rbp)
jmp 0x8538
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/dynamodb/dynamodb_request_queue.c
// Function: poke
static int
poke(struct dynamodb_request_queue * Q)
{

	/* Do we need an immediate callback? */
	if (Q->immediate_cookie == NULL) {
		if ((Q->immediate_cookie = events_immediate_register(
		    poke_immediate, Q, 0)) == NULL)
			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, 0x60(%rax)
jne 0x87ab
movq -0x10(%rbp), %rsi
leaq 0x18e(%rip), %rdi       # 0x8920
xorl %edx, %edx
callq 0x4a30
movq -0x10(%rbp), %rcx
movq %rax, 0x60(%rcx)
cmpq $0x0, %rax
jne 0x87a9
jmp 0x87b4
jmp 0x87ab
movl $0x0, -0x4(%rbp)
jmp 0x87bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/dynamodb/dynamodb_request_queue.c
// Function: dynamodb_request_queue_flush
void
dynamodb_request_queue_flush(struct dynamodb_request_queue * Q)
{
	struct request * R;

	/* Pull requests off the queue until there are none left. */
	while ((R = ptrheap_getmin(Q->reqs)) != NULL) {
		/* Delete it from the queue. */
		ptrheap_deletemin(Q->reqs);

		/* Cancel any in-progress operation. */
		if (R->timeout_cookie != NULL)
			events_timer_cancel(R->timeout_cookie);
		if (R->http_cookie != NULL) {
			http_request_cancel(R->http_cookie);
			sock_addr_free(R->addrs[0]);
			Q->inflight--;
		}

		/* Free the request. */
		free(R->logstr);
		free(R);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0xbbd0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8868
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0xbf10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x8818
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x6020
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x884d
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xca20
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x11a60
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3460
movq -0x10(%rbp), %rdi
callq 0x3460
jmp 0x87dc
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/dynamodb/dynamodb_request_queue.c
// Function: dynamodb_request_queue_free
void
dynamodb_request_queue_free(struct dynamodb_request_queue * Q)
{

	/* Flush the queue. */
	dynamodb_request_queue_flush(Q);

	/* Stop the rate-limiting timer (if any). */
	if (Q->timer_cookie != NULL)
		events_timer_cancel(Q->timer_cookie);

	/* Cancel the immediate callback (if any). */
	if (Q->immediate_cookie != NULL)
		events_immediate_cancel(Q->immediate_cookie);

	/* Free the (now empty) request queue. */
	ptrheap_free(Q->reqs);

	/* Free string allocated by strdup. */
	free(Q->region);

	/* Free the AWS keys. */
	insecure_memzero(Q->key_secret, strlen(Q->key_secret));
	free(Q->key_secret);
	free(Q->key_id);

	/* Free the request queue structure. */
	free(Q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x87d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x889d
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x6020
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x88b5
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b80
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0xc010
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3460
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31a0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x8570
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3460
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3460
movq -0x8(%rbp), %rdi
callq 0x3460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/dynamodb/dynamodb_request_queue.c
// Function: callback_timeout
static int
callback_timeout(void * cookie)
{
	struct request * R = cookie;
	struct dynamodb_request_queue * Q = R->Q;

	/* We are no longer waiting for a timer callback. */
	R->timeout_cookie = NULL;

	/* Clean up the HTTP request. */
	if ((R->http_cookie != NULL) && done_http(R, 1))
		goto err0;

	/* The priority of this request has changed. */
	ptrheap_decrease(Q->reqs, R->rc);

	/*
	 * Poke the queue -- this request has moved from "in progress" back
	 * to "waiting to be sent", so it might be possible to send it now.
	 */
	if (poke(Q))
		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), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x8deb
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x91f0
cmpl $0x0, %eax
je 0x8deb
jmp 0x8e1c
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rsi
callq 0xbf30
movq -0x20(%rbp), %rdi
callq 0x8770
cmpl $0x0, %eax
je 0x8e13
jmp 0x8e1c
movl $0x0, -0x4(%rbp)
jmp 0x8e23
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/dynamodb/dynamodb_request_queue.c
// Function: done_http
static int
done_http(struct request * R, int timedout)
{
	struct dynamodb_request_queue * Q = R->Q;
	struct timeval t_end;
	int rc = 0;

	/* Cancel the request if we timed out. */
	if (timedout) {
		http_request_cancel(R->http_cookie);
		if (Q->logfile) {
			if (monoclock_get(&t_end)) {
				warnp("monoclock_get");
				t_end = R->t_start;
				rc = -1;
			}
			if (logreq(Q->logfile, R, NULL, 0.0, t_end, NULL))
				rc = -1;
		}
	}

	/* There is no longer a request in flight. */
	R->http_cookie = NULL;
	Q->inflight--;
	sock_addr_free(R->addrs[0]);
	R->addrs[0] = NULL;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x92d1
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xca20
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x92cf
leaq -0x28(%rbp), %rdi
callq 0x6300
cmpl $0x0, %eax
je 0x929a
jmp 0x924a
callq 0x3040
cmpl $0x0, (%rax)
je 0x926f
leaq 0x156d5(%rip), %rdi     # 0x1e930
movb $0x0, %al
callq 0x66e0
callq 0x3040
movl $0x0, (%rax)
jmp 0x927d
leaq 0x156ba(%rip), %rdi     # 0x1e930
movb $0x0, %al
callq 0x6930
jmp 0x927f
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
xorps %xmm0, %xmm0
movq %r9, %rdx
callq 0x9310
cmpl $0x0, %eax
je 0x92cd
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0x92cf
jmp 0x92d1
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x11a60
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/logging/logging.c
// Function: logging_open
struct logging_file *
logging_open(const char * path)
{
	struct logging_file * F;

	/* Allocate a log file structure. */
	if ((F = malloc(sizeof(struct logging_file))) == NULL)
		goto err0;

	/* Duplicate the provided path. */
	if ((F->path = strdup(path)) == NULL)
		goto err1;

	/* Open the file. */
	if ((F->fd = doopen(F->path)) == -1)
		goto err2;

	/* Start the has-file-moved timer. */
	if ((F->timer_cookie =
	    events_timer_register_double(callback_timer, F, 1.0)) == NULL)
		goto err3;

	/* Success! */
	return (F);

err3:
	if (close(F->fd))
		warnp("close");
err2:
	free(F->path);
err1:
	free(F);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq 0x34c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x99d5
jmp 0x9a9e
movq -0x10(%rbp), %rdi
callq 0x35f0
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x99f1
jmp 0x9a95
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9ab0
movq -0x18(%rbp), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
jne 0x9a0b
jmp 0x9a88
movq -0x18(%rbp), %rsi
leaq 0x36a(%rip), %rdi       # 0x9d80
movsd 0x14a82(%rip), %xmm0    # 0x1e4a0
callq 0x5fc0
movq -0x18(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x9a33
jmp 0x9a3d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9aa6
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x3650
cmpl $0x0, %eax
je 0x9a86
jmp 0x9a4f
callq 0x3040
cmpl $0x0, (%rax)
je 0x9a74
leaq 0x147b1(%rip), %rdi     # 0x1e211
movb $0x0, %al
callq 0x66e0
callq 0x3040
movl $0x0, (%rax)
jmp 0x9a82
leaq 0x14796(%rip), %rdi     # 0x1e211
movb $0x0, %al
callq 0x6930
jmp 0x9a84
jmp 0x9a86
jmp 0x9a88
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3460
movq -0x18(%rbp), %rdi
callq 0x3460
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/logging/logging.c
// Function: logging_close
void
logging_close(struct logging_file * F)
{

	/* Stop the has-file-moved timer if it's running. */
	if (F->timer_cookie != NULL)
		events_timer_cancel(F->timer_cookie);

	/* Close the log file if we have it open. */
	if ((F->fd != -1) && close(F->fd))
		warnp("close");

	/* Free the duplicated path string. */
	free(F->path);

	/* Free the structure. */
	free(F);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa2a4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6020
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0xa2f6
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x3650
cmpl $0x0, %eax
je 0xa2f6
jmp 0xa2bf
callq 0x3040
cmpl $0x0, (%rax)
je 0xa2e4
leaq 0x13f41(%rip), %rdi     # 0x1e211
movb $0x0, %al
callq 0x66e0
callq 0x3040
movl $0x0, (%rax)
jmp 0xa2f2
leaq 0x13f26(%rip), %rdi     # 0x1e211
movb $0x0, %al
callq 0x6930
jmp 0xa2f4
jmp 0xa2f6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3460
movq -0x8(%rbp), %rdi
callq 0x3460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: http_request_cancel
void
http_request_cancel(void * cookie)
{
	struct http_cookie * H = cookie;

	/* Stop connecting if we're in the process of doing so. */
	if (H->connect_cookie != NULL)
		network_connect_cancel(H->connect_cookie);

	/* If we have a network reader, cancel any in-progress read. */
	if (H->R != NULL)
		netbuf_read_wait_cancel(H->R);

	/* Free the network reader and writer if they exist. */
	if (H->W != NULL)
		netbuf_write_free(H->W);
	if (H->R != NULL)
		netbuf_read_free(H->R);

	/* Close SSL context if we have one. */
	if (H->ssl != NULL)
		(network_ssl_close_func)(H->ssl);

	/* Close the socket if we are connected. */
	if ((H->s != -1) && close(H->s))
		warnp("close");

	/* Free duplicated SSL target hostname if we have one. */
	free(H->sslhost);

	/*
	 * Free internal buffers.  (req_body does not need to be freed since
	 * it is owned by the caller; res_body does need to be freed, since
	 * it is set to NULL if/when it is passed off to the caller).
	 */
	free(H->req_head);
	free(H->res_head);
	free(H->res.headers);
	free(H->res.body);

	/* Free the cookie. */
	free(H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xca4c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xf110
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xca64
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xe580
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xca7c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xed30
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xca94
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xe660
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xcab0
movq 0x29cfa(%rip), %rax     # 0x367a0
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0xcb04
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3650
cmpl $0x0, %eax
je 0xcb04
jmp 0xcacd
callq 0x3040
cmpl $0x0, (%rax)
je 0xcaf2
leaq 0x11733(%rip), %rdi     # 0x1e211
movb $0x0, %al
callq 0x66e0
callq 0x3040
movl $0x0, (%rax)
jmp 0xcb00
leaq 0x11718(%rip), %rdi     # 0x1e211
movb $0x0, %al
callq 0x6930
jmp 0xcb02
jmp 0xcb04
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x3460
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3460
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x3460
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x3460
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x3460
movq -0x10(%rbp), %rdi
callq 0x3460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: http_findheader
const char *
http_findheader(struct http_header * headers, size_t nheaders,
    const char * header)
{
	size_t i;

	/* Sanity check. */
	assert((headers != NULL) || (nheaders == 0));

	/* Search for the header. */
	for (i = 0; i < nheaders; i++) {
		if (strcmp(headers[i].header, header) == 0)
			return (headers[i].value);
	}

	/* Didn't find it. */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xcb82
cmpq $0x0, -0x18(%rbp)
jne 0xcb84
jmp 0xcba3
leaq 0x12424(%rip), %rdi     # 0x1efaf
leaq 0x1237b(%rip), %rsi     # 0x1ef0d
movl $0x355, %edx            # imm = 0x355
leaq 0x12436(%rip), %rcx     # 0x1efd4
callq 0x3240
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xcbfe
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3500
cmpl $0x0, %eax
jne 0xcbee
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc06
jmp 0xcbf0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xcbab
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: fail
static int
fail(void * cookie)
{
	struct http_cookie * H = cookie;
	int rc;

	/* Perform the callback. */
	rc = (H->callback)(H->cookie, NULL);

	/* Free the cookie. */
	http_request_cancel(H);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x68(%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xca20
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: callback_read_header
static int
callback_read_header(void * cookie, int status)
{
	struct http_cookie * H = cookie;
	uint8_t * buf;
	size_t buflen;

	/* Did the read fail?  (EOF during headers counts as failing.) */
	if (status)
		return (fail(H));

	/* Where's the data? */
	netbuf_read_peek(H->R, &buf, &buflen);

	/* Scan forwards looking for \r\n\r\n. */
	for (; H->hepos + 4 <= buflen; H->hepos++) {
		if (memcmp(&buf[H->hepos], "\r\n\r\n", 4) == 0)
			break;
	}

	/* If we've found the end of the headers, handle them. */
	if (H->hepos + 4 <= buflen)
		return (gotheaders(H, buf, H->hepos + 4));

	/* Reject any response with more than 64 kB of headers. */
	if (buflen > MAXHDR) {
		warn0("Dropping connection with >%d bytes of headers", MAXHDR);
		return (fail(H));
	}

	/* Wait until at least one more byte has arrived. */
	if (netbuf_read_wait(H->R, buflen + 1, callback_read_header, H))
		return (die(H));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xcc9e
movq -0x20(%rbp), %rdi
callq 0xcc10
movl %eax, -0x4(%rbp)
jmp 0xcd9b
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xe0f0
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
addq $0x4, %rax
cmpq -0x30(%rbp), %rax
ja 0xccf9
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
addq 0x70(%rcx), %rax
movl (%rax), %eax
subl $0xa0d0a0d, %eax        # imm = 0xA0D0A0D
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xcce5
jmp 0xccf9
jmp 0xcce7
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rax)
jmp 0xccb3
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
addq $0x4, %rax
cmpq -0x30(%rbp), %rax
ja 0xcd29
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rdx
addq $0x4, %rdx
callq 0xcdb0
movl %eax, -0x4(%rbp)
jmp 0xcd9b
cmpq $0x10000, -0x30(%rbp)   # imm = 0x10000
jbe 0xcd61
jmp 0xcd35
leaq 0x122e5(%rip), %rdi     # 0x1f021
movl $0x10000, %esi          # imm = 0x10000
movb $0x0, %al
callq 0x6930
callq 0x3040
movl $0x0, (%rax)
movq -0x20(%rbp), %rdi
callq 0xcc10
movl %eax, -0x4(%rbp)
jmp 0xcd9b
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x30(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rcx
leaq -0x10c(%rip), %rdx      # 0xcc70
callq 0xe130
cmpl $0x0, %eax
je 0xcd94
movq -0x20(%rbp), %rdi
callq 0xcc50
movl %eax, -0x4(%rbp)
jmp 0xcd9b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: findeol
static size_t
findeol(const uint8_t * buf, size_t buflen)
{
	size_t bufpos;

	/* Scan through the buffer. */
	for (bufpos = 0; bufpos + 2 <= buflen; bufpos++) {
		if (memcmp(&buf[bufpos], "\r\n", 2) == 0)
			return (bufpos);
	}

	/* No \r\n in buffer; return buflen. */
	return (buflen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x18(%rbp), %rax
ja 0xd556
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movw (%rax), %ax
subw $0xa0d, %ax             # imm = 0xA0D
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd546
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd55e
jmp 0xd548
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd514
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: sgetline
static char *
sgetline(uint8_t * buf, size_t buflen, size_t * bufpos, size_t * linelen)
{
	uint8_t * s = &buf[*bufpos];

	/* Find the \r\n. */
	*linelen = findeol(s, buflen - *bufpos);

	/* It had better be there. */
	assert(*linelen < buflen - *bufpos);

	/* Add NUL-terminator. */
	s[*linelen] = '\0';

	/* Adjust buffer position. */
	*bufpos += *linelen + 2;

	/* Return string. */
	return (char *)(s);
}

// 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 -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
subq (%rax), %rsi
callq 0xd500
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq (%rdx), %rcx
cmpq %rcx, %rax
jae 0xd66e
jmp 0xd68d
leaq 0x11c55(%rip), %rdi     # 0x1f2ca
leaq 0x11891(%rip), %rsi     # 0x1ef0d
movl $0xa7, %edx
leaq 0x11c5e(%rip), %rcx     # 0x1f2e6
callq 0x3240
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: docallback
static int
docallback(struct http_cookie * H)
{
	int rc;

	/* Perform callback. */
	rc = (H->callback)(H->cookie, &H->res);

	/* The callback function now owns the response body buffer. */
	H->res.body = NULL;

	/* Free the cookie. */
	http_request_cancel(H);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rdi
movq -0x8(%rbp), %rsi
addq $0xa8, %rsi
callq *%rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x8(%rbp), %rdi
callq 0xca20
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: get_body_gotclen
static int
get_body_gotclen(struct http_cookie * H, size_t len)
{

	/* Is the specified Content-Length too big? */
	if (len > H->res_bodylen_max)
		return (toobig(H));

	/* Record the length of content we need to read. */
	H->readlen = len;

	/* Once we've read this, we're done. */
	H->chunked = 0;

	/* Enter the reading loop. */
	return (callback_readdata(H, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jbe 0xdaef
movq -0x10(%rbp), %rdi
callq 0xdcf0
movl %eax, -0x4(%rbp)
jmp 0xdb1a
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xdd40
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: callback_read_toeof
static int
callback_read_toeof(void * cookie, int status)
{
	struct http_cookie * H = cookie;
	uint8_t * buf;
	size_t buflen;

	/* Did we fail? */
	if (status == -1)
		return (fail(H));

	/* Did we hit EOF? */
	if (status == 1)
		return (docallback(H));

	/* How much data is there? */
	netbuf_read_peek(H->R, &buf, &buflen);

	/* Is it too much? */
	if (buflen > H->res_bodylen_max - H->res.bodylen)
		return (toobig(H));

	/* Add this to our internal buffer. */
	if (addbody(H, buf, buflen))
		return (die(H));

	/* Consume the data. */
	netbuf_read_consume(H->R, buflen);

	/* Wait for at least one more byte to arrive. */
	if (netbuf_read_wait(H->R, 1, callback_read_toeof, H))
		return (die(H));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0xdb5e
movq -0x20(%rbp), %rdi
callq 0xcc10
movl %eax, -0x4(%rbp)
jmp 0xdc23
cmpl $0x1, -0x14(%rbp)
jne 0xdb75
movq -0x20(%rbp), %rdi
callq 0xd6c0
movl %eax, -0x4(%rbp)
jmp 0xdc23
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xe0f0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x98(%rcx), %rcx
movq -0x20(%rbp), %rdx
subq 0xc0(%rdx), %rcx
cmpq %rcx, %rax
jbe 0xdbb7
movq -0x20(%rbp), %rdi
callq 0xdcf0
movl %eax, -0x4(%rbp)
jmp 0xdc23
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xdeb0
cmpl $0x0, %eax
je 0xdbdb
movq -0x20(%rbp), %rdi
callq 0xcc50
movl %eax, -0x4(%rbp)
jmp 0xdc23
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xe600
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rcx
movl $0x1, %esi
leaq -0xd4(%rip), %rdx       # 0xdb30
callq 0xe130
cmpl $0x0, %eax
je 0xdc1c
movq -0x20(%rbp), %rdi
callq 0xcc50
movl %eax, -0x4(%rbp)
jmp 0xdc23
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]kivaloo/liball/../libcperciva/http/http.c
// Function: toobig
static int
toobig(struct http_cookie * H)
{

	/* No body any more. */
	free(H->res.body);
	H->res.body = NULL;

	/* The response is too big. */
	H->res.bodylen = (size_t)(-1);

	/* Perform the callback. */
	return (docallback(H));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x3460
movq -0x8(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0xc0(%rax)
movq -0x8(%rbp), %rdi
callq 0xd6c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/http/http.c
// Function: addbody
static int
addbody(struct http_cookie * H, uint8_t * buf, size_t buflen)
{
	size_t nalloc;
	uint8_t * nbuf;

	/* The caller should make sure we don't exceed the maximum length. */
	assert(H->res.bodylen + buflen <= H->res_bodylen_max);

	/* Reallocate if necessary. */
	if (H->res.bodylen + buflen > H->res_bodylen_alloc) {
		/* Double the buffer size. */
		nalloc = H->res_bodylen_alloc * 2;

		/* Increase if that isn't enough. */
		if (nalloc < H->res.bodylen + buflen)
			nalloc = H->res.bodylen + buflen;

		/* Decrease if we've gone too far. */
		if (nalloc > H->res_bodylen_max)
			nalloc = H->res_bodylen_max;

		/* Expand our memory allocation. */
		if ((nbuf = realloc(H->res.body, nalloc)) == NULL)
			goto err0;

		/* Record the new allocation and its size. */
		H->res.body = nbuf;
		H->res_bodylen_alloc = nalloc;
	}

	/* Copy the data into our (possibly expanded) buffer. */
	memcpy(&H->res.body[H->res.bodylen], buf, buflen);

	/* Record the increased data length. */
	H->res.bodylen += buflen;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xdee2
jmp 0xdf01
leaq 0x11462(%rip), %rdi     # 0x1f34b
leaq 0x1101d(%rip), %rsi     # 0x1ef0d
movl $0xbb, %edx
leaq 0x1147d(%rip), %rcx     # 0x1f379
callq 0x3240
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0xa0(%rcx), %rax
jbe 0xdfbc
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xc0(%rcx), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0xdf5e
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jbe 0xdf7e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x3590
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xdf9e
jmp 0xdffe
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0xc0(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32c0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xe005
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/b64encode.c
// Function: b64encode
void
b64encode(const uint8_t * in, char * out, size_t len)
{
	uint32_t t;
	size_t j;

	/* Repeat {read up to 3 bytes; write 4 bytes} until we're done. */
	while (len) {
		/* Read up to 3 bytes. */
		for (t = 0, j = 0; j < 3; j++) {
			t <<= 8;
			if (j < len)
				t += *in++;
		}

		/* Write 4 bytes. */
		for (j = 0; j < 4; j++) {
			if (j <= len)
				*out++ = b64chars[(t >> 18) & 0x3f];
			else
				*out++ = '=';
			t <<= 6;
		}

		/* Adjust the remaining length. */
		if (len < 3)
			len = 0;
		else
			len -= 3;
	}

	/* NUL terminate. */
	*out++ = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1029a
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
jae 0x1020c
movl -0x1c(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x101fc
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x101fe
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x101ca
movq $0x0, -0x28(%rbp)
cmpq $0x4, -0x28(%rbp)
jae 0x10278
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x1024f
movl -0x1c(%rbp), %eax
shrl $0x12, %eax
andl $0x3f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x16437(%rip), %rax     # 0x26670
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x10261
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x3d, (%rax)
movl -0x1c(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x10214
cmpq $0x3, -0x18(%rbp)
jae 0x10289
movq $0x0, -0x18(%rbp)
jmp 0x10295
movq -0x18(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x101b0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/json.c
// Function: skip_ws
static const uint8_t *
skip_ws(const uint8_t * buf, const uint8_t * end)
{

	/* Skip " \t\r\n". */
	while (buf < end) {
		if ((buf[0] != 0x09) && (buf[0] != 0x0A) &&
		    (buf[0] != 0x0D) && (buf[0] != 0x20))
			break;
		buf++;
	}

	/* Return the first non-whitespace character or the buffer end. */
	return (buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x106a6
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0x10698
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x10698
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0x10698
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x10698
jmp 0x106a6
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1065c
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/json.c
// Function: skip_value
static const uint8_t *
skip_value(const uint8_t * buf, const uint8_t * end)
{

	/* If there's nothing here, return. */
	if (buf == end)
		return (end);

	/* Handle different types of objects. */
	switch (buf[0]) {
	case 'f':
	case 'n':
	case 't':
		/* This must be a literal.  Skip it. */
		return (skip_literal(buf, end));
	case '"':
		/* This must be a string.  Skip it. */
		return (skip_string(buf, end));
	case '[':
		/* This must be an array.  Skip it. */
		return (skip_array(buf, end));
	case '{':
		/* This must be an object.  Skip it. */
		return (skip_object(buf, end));
	default:
		/* Could this plausibly be a number? */
		if (strchr(numchars, buf[0]) != NULL)
			return (skip_number(buf, end));

		/* We don't have a valid JSON value.  Return. */
		return (end);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x10867
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1092a
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x22, %eax
je 0x108bd
jmp 0x10878
movl -0x1c(%rbp), %eax
subl $0x5b, %eax
je 0x108d0
jmp 0x10882
movl -0x1c(%rbp), %eax
subl $0x66, %eax
je 0x108aa
jmp 0x1088c
movl -0x1c(%rbp), %eax
subl $0x6e, %eax
je 0x108aa
jmp 0x10896
movl -0x1c(%rbp), %eax
subl $0x74, %eax
je 0x108aa
jmp 0x108a0
movl -0x1c(%rbp), %eax
subl $0x7b, %eax
je 0x108e3
jmp 0x108f6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10940
movq %rax, -0x8(%rbp)
jmp 0x1092a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10a10
movq %rax, -0x8(%rbp)
jmp 0x1092a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10ab0
movq %rax, -0x8(%rbp)
jmp 0x1092a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10ba0
movq %rax, -0x8(%rbp)
jmp 0x1092a
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
leaq 0x15dbc(%rip), %rdi     # 0x266c0
callq 0x3170
cmpq $0x0, %rax
je 0x10922
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10d00
movq %rax, -0x8(%rbp)
jmp 0x1092a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/json.c
// Function: skip_literal
static const uint8_t *
skip_literal(const uint8_t * buf, const uint8_t * end)
{

	/* MUST be "false", "null", or "true". */
	if (((end - buf) >= 5) && (memcmp(buf, "false", 5) == 0))
		return (&buf[5]);
	if (((end - buf) >= 4) && (memcmp(buf, "null", 4) == 0))
		return (&buf[4]);
	if (((end - buf) >= 4) && (memcmp(buf, "true", 4) == 0))
		return (&buf[4]);

	/* We do not have a literal here; return a pointer to the end. */
	return (end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x5, %rax
jl 0x10989
movq -0x10(%rbp), %rdi
leaq 0xf0fc(%rip), %rsi      # 0x1fa68
movl $0x5, %edx
callq 0x31b0
cmpl $0x0, %eax
jne 0x10989
movq -0x10(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x8(%rbp)
jmp 0x109fb
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jl 0x109be
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x6c6c756e, %eax       # imm = 0x6C6C756E
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x109be
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x109fb
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jl 0x109f3
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x65757274, %eax       # imm = 0x65757274
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x109f3
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x109fb
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/json.c
// Function: skip_string
static const uint8_t *
skip_string(const uint8_t * buf, const uint8_t * end)
{
	uint8_t ch;

	/* Advance past leading '"'. */
	buf++;

	/* Scan until we find a terminating '"' or run out of input. */
	while (buf < end) {
		ch = *buf++;
		if (ch == '"')
			break;
		if (ch == '\\') {
			if (buf == end)
				break;
			ch = *buf++;
			if (ch == 'u') {
				if (end - buf < 4)
					break;
				buf += 4;
			}
		}
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x10aa6
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x22, %eax
jne 0x10a51
jmp 0x10aa6
movzbl -0x11(%rbp), %eax
cmpl $0x5c, %eax
jne 0x10aa4
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x10a66
jmp 0x10aa6
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x75, %eax
jne 0x10aa2
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jge 0x10a96
jmp 0x10aa6
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x10aa4
jmp 0x10a28
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/json.c
// Function: skip_array
static const uint8_t *
skip_array(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 array? */
	if (buf == end)
		return (end);
	if (buf[0] == ']')
		return (&buf[1]);

	/* Skip entries until we get to the end. */
	do {
		/* Skip a value. */
		buf = skip_value(buf, end);

		/* Skip optional whitespace. */
		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 0x10af4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b8b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x10b0e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10b8b
jmp 0x10b10
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 0x10b46
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b8b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x10b60
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10b8b
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
cmpl $0x2c, %eax
je 0x10b81
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b8b
jmp 0x10b83
movb $0x1, %al
testb $0x1, %al
jne 0x10b10
jmp 0x10b8b
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)