LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_server.c
// Function: mkstr
static char *
mkstr(uint8_t * buf, size_t len, size_t * pos)
{
	char * s;
	size_t slen;
	size_t i;

	/* Extract the string length. */
	if (len < *pos + 1)
		goto err0;
	slen = buf[*pos];
	*pos += 1;

	/* Make sure the string is not prematurely terminated. */
	if (len < *pos + slen)
		goto err0;
	for (i = 0; i < slen; i++)
		if (buf[*pos + i] == '\0')
			goto err0;

	/* Allocate space for string. */
	if ((s = malloc(slen + 1)) == NULL)
		goto err0;

	/* Copy and NUL-terminate string. */
	memcpy(s, &buf[*pos], slen);
	*pos += slen;
	s[slen] = '\0';

	/* Success! */
	return (s);

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 -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0xfa4d
jmp 0xfb18
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
addq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jae 0xfa87
jmp 0xfb18
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xfac3
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
addq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xfab3
jmp 0xfb18
jmp 0xfab5
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xfa8f
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0x2350
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xfadc
jmp 0xfb18
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
addq (%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x2300
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfb20
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/s3/s3_request_queue.c
// Function: s3_request_queue_init
struct s3_request_queue *
s3_request_queue_init(const char * key_id, const char * key_secret,
    const char * region, size_t conns)
{
	struct s3_request_queue * Q;

	/* Allocate a request queue structure. */
	if ((Q = malloc(sizeof(struct s3_request_queue))) == NULL)
		goto err0;

	/* Create a server pool structure. */
	if ((Q->SP = s3_serverpool_init()) == NULL)
		goto err1;

	/* Copy key_id and key_secret. */
	if ((Q->key_id = strdup(key_id)) == NULL)
		goto err2;
	if ((Q->key_secret = strdup(key_secret)) == NULL)
		goto err3;

	/* Copy region. */
	if ((Q->region = strdup(region)) == NULL)
		goto err4;

	/* No log file yet. */
	Q->logfile = NULL;

	/* No requests queued or in progress. */
	Q->reqsip = 0;
	Q->reqs_queued_head = Q->reqs_queued_tail = NULL;
	Q->reqs_ip_head = Q->reqs_ip_tail = NULL;

	/* Record the maximum number of simultaneous requests. */
	Q->reqsip_max = conns;

	/* Success! */
	return (Q);

err4:
	insecure_memzero(Q->key_secret, strlen(Q->key_secret));
	free(Q->key_secret);
err3:
	free(Q->key_id);
err2:
	s3_serverpool_free(Q->SP);
err1:
	free(Q);
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)
movl $0x58, %edi
callq 0x2350
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xfb61
jmp 0xfc7b
callq 0x10470
movq -0x30(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0xfb79
jmp 0xfc72
movq -0x10(%rbp), %rdi
callq 0x24b0
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xfb94
jmp 0xfc65
movq -0x18(%rbp), %rdi
callq 0x24b0
movq -0x30(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0xfbb0
jmp 0xfc59
movq -0x20(%rbp), %rdi
callq 0x24b0
movq -0x30(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xfbc9
jmp 0xfc27
movq -0x30(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfc83
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xfc90
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10860
movq -0x30(%rbp), %rdi
callq 0x2040
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/../lib/s3/s3_request_queue.c
// Function: s3_request_queue
int
s3_request_queue(struct s3_request_queue * Q, struct s3_request * request,
    size_t maxrlen,
    int (* callback)(void *, struct http_response *), void * cookie)
{
	struct request * R;

	/* Bake a cookie. */
	if ((R = malloc(sizeof(struct request))) == NULL)
		goto err0;
	R->Q = Q;
	R->request = request;
	R->maxrlen = maxrlen;
	R->callback = callback;
	R->cookie = cookie;
	R->http_cookie = NULL;

	/* Add to the end of the pending-requests queue. */
	R->prev = Q->reqs_queued_tail;
	R->next = NULL;
	if (R->prev == NULL) {
		Q->reqs_queued_head = R;
	} else {
		R->prev->next = R;
	}
	Q->reqs_queued_tail = R;

	/* Poke the queue. */
	if (poke(Q))
		goto err1;

	/* Success! */
	return (0);

err1:
	/* Take R back off the pending-requests queue. */
	if (R->prev != NULL) {
		R->prev->next = NULL;
	} else {
		Q->reqs_queued_head = NULL;
	}
	Q->reqs_queued_tail = R->prev;

	/* Free the request structure. */
	free(R);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x60, %edi
callq 0x2350
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xfd45
jmp 0xfe38
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xfdc1
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0xfdd1
movq -0x38(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x58(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0xfe50
cmpl $0x0, %eax
je 0xfded
jmp 0xfdf6
movl $0x0, -0x4(%rbp)
jmp 0xfe3f
movq -0x38(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xfe13
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq $0x0, 0x58(%rax)
jmp 0xfe1f
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x38(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/s3/s3_request_queue.c
// Function: s3_request_queue_flush
void
s3_request_queue_flush(struct s3_request_queue * Q)
{
	struct request * R;

	/* Free the contents of the pending-requests queue. */
	while ((R = Q->reqs_queued_head) != NULL) {
		Q->reqs_queued_head = R->next;
		free(R);
	}
	Q->reqs_queued_tail = NULL;

	/* Cancel in-progress requests and free them. */
	while ((R = Q->reqs_ip_head) != NULL) {
		http_request_cancel(R->http_cookie);
		Q->reqs_ip_head = R->next;
		sock_addr_free(R->addrs[0]);
		free(R);
	}
	Q->reqs_ip_tail = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x10059
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x2040
jmp 0x1002c
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x100ac
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x76f0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xd5f0
movq -0x10(%rbp), %rdi
callq 0x2040
jmp 0x10065
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/s3/s3_request_queue.c
// Function: s3_request_queue_free
void
s3_request_queue_free(struct s3_request_queue * Q)
{

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

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

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

	/* Free the server pool. */
	s3_serverpool_free(Q->SP);

	/* 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 0x10020
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0xfc90
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10860
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/s3/s3_serverpool.c
// Function: s3_serverpool_add
int
s3_serverpool_add(struct s3_serverpool * SP,
    const struct sock_addr *sa, int ttl)
{
	S3_SERVERPOOL S = (S3_SERVERPOOL)SP;
	struct timeval tv;
	struct timeval * tvo;
	struct s3_endpoint ep;
	size_t i;

	/* Compute EOL for this endpoint. */
	if (monoclock_get(&tv))
		goto err0;
	tv.tv_sec += ttl;

	/* Look for the endpoint. */
	for (i = 0; i < serverpool_getsize(S); i++) {
		if (sock_addr_cmp(sa, serverpool_get(S, i)->sa) == 0) {
			/* Update the EOL and return. */
			tvo = &serverpool_get(S, i)->eol;
			if ((tvo->tv_sec < tv.tv_sec) ||
			    ((tvo->tv_sec == tv.tv_sec) &&
			     (tvo->tv_usec < tv.tv_usec))) {
				tvo->tv_sec = tv.tv_sec;
				tvo->tv_usec = tv.tv_usec;
			}
			return (0);
		}
	}

	/* Construct a new endpoint structure. */
	if ((ep.sa = sock_addr_dup(sa)) == NULL)
		goto err0;
	ep.eol.tv_sec = tv.tv_sec;
	ep.eol.tv_usec = tv.tv_usec;

	/* Add the new endpoint to the list. */
	if (serverpool_append(S, &ep, 1))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(ep.sa);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc5c0
cmpl $0x0, %eax
je 0x104ee
jmp 0x10609
movslq -0x1c(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10620
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x105b9
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x10640
movq -0x70(%rbp), %rdi
movq (%rax), %rsi
callq 0xddb0
cmpl $0x0, %eax
jne 0x105a6
movq -0x28(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x10640
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpq -0x38(%rbp), %rax
jl 0x10586
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpq -0x38(%rbp), %rax
jne 0x1059d
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x30(%rbp), %rax
jge 0x1059d
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x10610
jmp 0x105a8
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x10502
movq -0x18(%rbp), %rdi
callq 0xde40
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0x105ce
jmp 0x10609
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x1, %edx
callq 0x10670
cmpl $0x0, %eax
je 0x105f7
jmp 0x10600
movl $0x0, -0x4(%rbp)
jmp 0x10610
movq -0x58(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/s3/s3_serverpool.c
// Function: s3_serverpool_pick
struct sock_addr *
s3_serverpool_pick(struct s3_serverpool * SP)
{
	S3_SERVERPOOL S = (S3_SERVERPOOL)SP;
	struct timeval tv;
	struct timeval * tvo;
	struct sock_addr * sa;
	size_t i;

	/* If we have no endpoints, fail. */
	if (serverpool_getsize(S) == 0)
		goto err0;

	/* Delete expired endpoints; count down to avoid missing anything. */
	if (monoclock_get(&tv))
		goto err0;
	for (i = serverpool_getsize(S); i > 0; i--) {
		/* Is the EOL still in the future? */
		tvo = &serverpool_get(S, i - 1)->eol;
		if ((tvo->tv_sec > tv.tv_sec) ||
		    ((tvo->tv_sec == tv.tv_sec) &&
		     (tvo->tv_usec > tv.tv_usec)))
			continue;

		/* Is this the last remaining endpoint? */
		if (serverpool_getsize(S) == 1)
			continue;

		/* Delete this endpoint. */
		endpoint_free(S, i - 1);
	}

	/* Pick a (non-cryptographically) random endpoint. */
	i = (size_t)rand() % serverpool_getsize(S);

	/* Make a copy of the address. */
	if ((sa = sock_addr_dup(serverpool_get(S, i)->sa)) == NULL)
		goto err0;

	/* Return the address. */
	return (sa);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10620
cmpq $0x0, %rax
jne 0x106c8
jmp 0x107b1
leaq -0x28(%rbp), %rdi
callq 0xc5c0
cmpl $0x0, %eax
je 0x106db
jmp 0x107b1
movq -0x18(%rbp), %rdi
callq 0x10620
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jbe 0x10762
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
subq $0x1, %rsi
callq 0x10640
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jg 0x10730
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x10732
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jle 0x10732
jmp 0x10754
movq -0x18(%rbp), %rdi
callq 0x10620
cmpq $0x1, %rax
jne 0x10743
jmp 0x10754
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
subq $0x1, %rsi
callq 0x107d0
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x106e8
callq 0x2510
cltq
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10620
movq %rax, %rcx
movq -0x48(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x10640
movq (%rax), %rdi
callq 0xde40
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x107a7
jmp 0x107b1
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x107b9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/s3/s3_serverpool.c
// Function: endpoint_free
static void
endpoint_free(S3_SERVERPOOL S, size_t i)
{

	/* Free the endpoint address. */
	sock_addr_free(serverpool_get(S, i)->sa);

	/*
	 * Copy the last endpoint over this one (if we're deleting the last
	 * endpoint in the array, this turns out to be a no-op, of course).
	 */
	memcpy(serverpool_get(S, i),
	    serverpool_get(S, serverpool_getsize(S) - 1),
	    sizeof(struct s3_endpoint));

	/* Delete the last endpoint (now that it's moved). */
	serverpool_shrink(S, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10640
movq (%rax), %rdi
callq 0xd5f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10640
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10620
movq -0x20(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x10640
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x108d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/s3/s3_serverpool.c
// Function: s3_serverpool_free
void
s3_serverpool_free(struct s3_serverpool * SP)
{
	S3_SERVERPOOL S = (S3_SERVERPOOL)SP;

	/* Delete endpoints. */
	while (serverpool_getsize(S) > 0)
		endpoint_free(S, 0);

	/* Free the elastic array. */
	serverpool_free(S);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10620
cmpq $0x0, %rax
jbe 0x10892
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x107d0
jmp 0x10874
movq -0x10(%rbp), %rdi
callq 0x108b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/s3/s3_verifyetag.c
// Function: s3_verifyetag
int
s3_verifyetag(struct http_response * res)
{
	const char * etag;
	uint8_t etagmd5[16];
	uint8_t datamd5[16];

	/* Look for an ETag header. */
	etag = http_findheader(res->headers, res->nheaders, "ETag");

	/* If there is no header, return zero. */
	if (etag == NULL)
		return (0);

	/* Skip any leading whitespace. */
	while ((etag[0] == ' ') || (etag[0] == '\t'))
		etag++;

	/* It should be '"' <32 characters of hex> '"'. */
	if ((strlen(etag) != 34) || (etag[0] != '"') || (etag[33] != '"'))
		return (0);

	/* Characters 1--33 should be hex.  Parse them. */
	if (unhexify(&etag[1], etagmd5, 16))
		return (0);

	/* Compute the MD5 hash of the HTTP response body. */
	MD5_Buf(res->body, res->bodylen, datamd5);

	/* Check if the MD5 hash matches the parsed ETag. */
	if (memcmp(etagmd5, datamd5, 16))
		return (0);
	else
		return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xf7c3(%rip), %rdx      # 0x200e6
callq 0x7830
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1093f
movl $0x0, -0x4(%rbp)
jmp 0x10a1d
jmp 0x10941
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x41(%rbp)
je 0x10962
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1096b
jmp 0x10979
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10941
movq -0x18(%rbp), %rdi
callq 0x2180
cmpq $0x22, %rax
jne 0x109a1
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x109a1
movq -0x18(%rbp), %rax
movsbl 0x21(%rax), %eax
cmpl $0x22, %eax
je 0x109aa
movl $0x0, -0x4(%rbp)
jmp 0x10a1d
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x14210
cmpl $0x0, %eax
je 0x109ce
movl $0x0, -0x4(%rbp)
jmp 0x10a1d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x40(%rbp), %rdx
callq 0x13230
leaq -0x30(%rbp), %rax
leaq -0x40(%rbp), %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x10a16
movl $0x0, -0x4(%rbp)
jmp 0x10a1d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/md5.c
// Function: libcperciva_MD5_Init
void
MD5_Init(MD5_CTX * ctx)
{

	/* Zero bits processed so far. */
	ctx->count[0] = ctx->count[1] = 0;

	/* Magic initialization constants. */
	ctx->state[0] = 0x67452301;
	ctx->state[1] = 0xEFCDAB89;
	ctx->state[2] = 0x98BADCFE;
	ctx->state[3] = 0x10325476;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/md5.c
// Function: libcperciva_MD5_Update
void
MD5_Update(MD5_CTX * ctx, const void * in, size_t len)
{
	uint32_t bitlen[2];
	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[0] >> 3) & 0x3f;

	/* Convert the length into a number of bits. */
	bitlen[0] = ((uint32_t)len) << 3;
	bitlen[1] = (uint32_t)(len >> 29);

	/* Update number of bits. */
	if ((ctx->count[0] += bitlen[0]) < bitlen[0])
		ctx->count[1]++;
	ctx->count[1] += bitlen[1];

	/* 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);
	MD5_Transform(ctx->state, ctx->buf);
	src += 64 - r;
	len -= 64 - r;

	/* Perform complete blocks. */
	while (len >= 64) {
		MD5_Transform(ctx->state, src);
		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 -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11da8
jmp 0x11ecf
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
shll $0x3, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shrq $0x1d, %rax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0x10(%rcx), %eax
movl %eax, 0x10(%rcx)
cmpl -0x20(%rbp), %eax
jae 0x11dec
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x40, %ecx
subl -0x24(%rbp), %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x11e2c
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x24(%rbp), %eax
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2300
jmp 0x11ecf
movq -0x8(%rbp), %rdi
addq $0x18, %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 0x2300
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0x11ee0
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 0x11eba
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11ee0
movq -0x30(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x18(%rbp)
jmp 0x11e8c
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2300
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/md5.c
// Function: MD5_Pad
static void
MD5_Pad(MD5_CTX * ctx)
{
	uint8_t len[8];
	uint32_t r, plen;

	/*
	 * Convert length to a vector of bytes -- we do this now rather
	 * than later because the length will change after we pad.
	 */
	le32enc_vect(len, ctx->count, 8);

	/* Add 1--64 bytes so that the resulting length is 56 mod 64. */
	r = (ctx->count[0] >> 3) & 0x3f;
	plen = (r < 56) ? (56 - r) : (120 - r);
	MD5_Update(ctx, PAD, (size_t)plen);

	/* Add the terminating bit-count. */
	MD5_Update(ctx, len, 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x8, %edx
callq 0x131a0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
cmpl $0x38, -0x14(%rbp)
jae 0x13155
movl $0x38, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x13160
movl $0x78, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %edx
leaq 0x144ca(%rip), %rsi     # 0x27640
callq 0x11d80
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x11d80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/md5.c
// Function: libcperciva_HMAC_MD5_Init
void
HMAC_MD5_Init(HMAC_MD5_CTX * ctx, const void * _k, size_t Klen)
{
	uint8_t pad[64];
	uint8_t khash[16];
	const uint8_t * K = _k;
	size_t i;

	/* If Klen > 64, the key is really MD5(K). */
	if (Klen > 64) {
		MD5_Init(&ctx->ictx);
		MD5_Update(&ctx->ictx, K, Klen);
		MD5_Final(khash, &ctx->ictx);
		K = khash;
		Klen = 16;
	}

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

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

	/* Clean the stack. */
	insecure_memzero(khash, 16);
	insecure_memzero(pad, 64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x40, -0x18(%rbp)
jbe 0x132dd
movq -0x8(%rbp), %rdi
callq 0x11d30
movq -0x8(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x11d80
leaq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x130d0
leaq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
movq $0x10, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d30
leaq -0x60(%rbp), %rdi
movl $0x36, %esi
movl $0x40, %edx
callq 0x2210
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x13334
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movzbl (%rax,%rcx), %edx
movq -0x80(%rbp), %rax
movzbl -0x60(%rbp,%rax), %ecx
xorl %edx, %ecx
movb %cl, -0x60(%rbp,%rax)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x13301
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
callq 0x11d80
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x11d30
leaq -0x60(%rbp), %rdi
movl $0x5c, %esi
movl $0x40, %edx
callq 0x2210
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x133a1
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movzbl (%rax,%rcx), %edx
movq -0x80(%rbp), %rax
movzbl -0x60(%rbp,%rax), %ecx
xorl %edx, %ecx
movb %cl, -0x60(%rbp,%rax)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x1336e
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
callq 0x11d80
leaq -0x70(%rbp), %rdi
movl $0x10, %esi
callq 0x13200
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0x13200
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/alg/md5.c
// Function: libcperciva_HMAC_MD5_Final
void
HMAC_MD5_Final(uint8_t digest[16], HMAC_MD5_CTX * ctx)
{
	uint8_t ihash[16];

	/* Finish the inner MD5 operation. */
	MD5_Final(ihash, &ctx->ictx);

	/* Feed the inner hash to the outer MD5 operation. */
	MD5_Update(&ctx->octx, ihash, 16);

	/* Finish the outer MD5 operation. */
	MD5_Final(digest, &ctx->octx);

	/* Clean the stack. */
	insecure_memzero(ihash, 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x130d0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x11d80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
callq 0x130d0
leaq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x13200
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/9wm.c
// Function: getscreen
ScreenInfo *
getscreen(Window w)
{
	int i;

	for (i = 0; i < num_screens; i++)
		if (screens[i].root == w)
			return &screens[i];

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x96a0(%rip), %eax      # 0xca08
jge 0x33b1
movq 0x969f(%rip), %rax      # 0xca10
movslq -0x14(%rbp), %rcx
imulq $0x178, %rcx, %rcx      # imm = 0x178
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x33a4
movq 0x9680(%rip), %rax      # 0xca10
movslq -0x14(%rbp), %rcx
imulq $0x178, %rcx, %rcx      # imm = 0x178
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x33b9
jmp 0x33a6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x335f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/9wm.c
// Function: timestamp
Time
timestamp(void)
{
	XEvent ev;

	if (curtime == CurrentTime) {
		XChangeProperty(dpy, screens[0].root, _9wm_running, _9wm_running, 8, PropModeAppend, (unsigned char *) "", 0);
		XMaskEvent(dpy, PropertyChangeMask, &ev);
		curtime = ev.xproperty.time;
	}
	return curtime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movslq 0x95c6(%rip), %rax      # 0xc998
cmpq $0x0, %rax
jne 0x3444
movq 0x9599(%rip), %rdi      # 0xc978
movq 0x962a(%rip), %rax      # 0xca10
movq 0x8(%rax), %rsi
movq 0x9607(%rip), %rdx      # 0xc9f8
movq 0x9600(%rip), %rcx      # 0xc9f8
movl $0x8, %r8d
movl $0x2, %r9d
leaq 0x5daa(%rip), %rax      # 0x91b5
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x2360
movq 0x9552(%rip), %rdi      # 0xc978
movl $0x400000, %esi         # imm = 0x400000
leaq -0xc0(%rbp), %rdx
callq 0x25e0
movq -0x90(%rbp), %rax
movl %eax, 0x9554(%rip)      # 0xc998
movslq 0x954d(%rip), %rax      # 0xc998
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/9wm.c
// Function: sendcmessage
void
sendcmessage(Window w, Atom a, long x, int isroot)
{
	XEvent ev;
	int status;
	long mask;

	memset(&ev, 0, sizeof(ev));
	ev.xclient.type = ClientMessage;
	ev.xclient.window = w;
	ev.xclient.message_type = a;
	ev.xclient.format = 32;
	ev.xclient.data.l[0] = x;
	ev.xclient.data.l[1] = timestamp();
	mask = 0L;
	if (isroot)
		mask = SubstructureRedirectMask;	/* magic! */
	status = XSendEvent(dpy, w, False, mask, &ev);
	if (status == 0)
		fprintf(stderr, "9wm: sendcmessage failed\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x21e0
movl $0x21, -0xe0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl $0x20, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x33c0
movq %rax, -0xa0(%rbp)
movq $0x0, -0xf0(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x34ea
movq $0x100000, -0xf0(%rbp) # imm = 0x100000
movq 0x9487(%rip), %rdi      # 0xc978
movq -0x8(%rbp), %rsi
movq -0xf0(%rbp), %rcx
xorl %edx, %edx
leaq -0xe0(%rbp), %r8
callq 0x2040
movl %eax, -0xe4(%rbp)
cmpl $0x0, -0xe4(%rbp)
jne 0x3531
movq 0x8ad8(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x5e45(%rip), %rsi      # 0x936f
movb $0x0, %al
callq 0x22b0
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/9wm.c
// Function: sendconfig
void
sendconfig(c)
     Client *c;
{
	XConfigureEvent ce;

	ce.type = ConfigureNotify;
	ce.event = c->window;
	ce.window = c->window;
	ce.x = c->x;
	ce.y = c->y;
	ce.width = c->dx;
	ce.height = c->dy;
	ce.border_width = c->border;
	ce.above = None;
	ce.override_redirect = 0;
	XSendEvent(dpy, c->window, False, StructureNotifyMask, (XEvent *) & ce);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x16, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x93c7(%rip), %rdi      # 0xc978
movq -0x8(%rbp), %rax
movq (%rax), %rsi
xorl %edx, %edx
movl $0x20000, %ecx          # imm = 0x20000
leaq -0x60(%rbp), %r8
callq 0x2040
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/9wm.c
// Function: getevent
void
getevent(XEvent * e)
{
	int fd;
	fd_set rfds;
	struct timeval t;

	if (!signalled) {
		if (QLength(dpy) > 0) {
			XNextEvent(dpy, e);
			return;
		}
		fd = ConnectionNumber(dpy);
		FD_ZERO(&rfds);
		FD_SET(fd, &rfds);
		t.tv_sec = t.tv_usec = 0;
		if (select(fd + 1, &rfds, NULL, NULL, &t) == 1) {
			XNextEvent(dpy, e);
			return;
		}
		XFlush(dpy);

		do {
			FD_ZERO(&rfds);
			FD_SET(fd, &rfds);
			if (select(fd + 1, &rfds, NULL, NULL, NULL) == 1) {
				XNextEvent(dpy, e);
				return;
			}
		} while (errno == EINTR);
		if (!signalled) {
			perror("9wm: select failed");
			exit(1);
		}
	}
	fprintf(stderr, "9wm: exiting on signal\n");
	cleanup();
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x9422(%rip)      # 0xca18
jne 0x37f7
movq 0x9375(%rip), %rax      # 0xc978
cmpl $0x0, 0x88(%rax)
jle 0x3621
movq 0x9365(%rip), %rdi      # 0xc978
movq -0x8(%rbp), %rsi
callq 0x2320
jmp 0x381e
movq 0x9350(%rip), %rax      # 0xc978
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
cmpq $0x10, %rax
jae 0x3678
movq -0xb0(%rbp), %rax
movl -0xa4(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x3646
jmp 0x367a
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0xc(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movq $0x0, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
movl -0xc(%rbp), %edi
addl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa0(%rbp), %r8
movq %rcx, %rdx
callq 0x22f0
cmpl $0x1, %eax
jne 0x3701
movq 0x9285(%rip), %rdi      # 0xc978
movq -0x8(%rbp), %rsi
callq 0x2320
jmp 0x381e
movq 0x9270(%rip), %rdi      # 0xc978
callq 0x2480
jmp 0x370f
leaq -0x90(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
cmpq $0x10, %rax
jae 0x3759
movq -0xc0(%rbp), %rax
movl -0xb4(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x3727
jmp 0x375b
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0xc(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movl -0xc(%rbp), %edi
addl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x22f0
cmpl $0x1, %eax
jne 0x37c6
movq 0x91bd(%rip), %rdi      # 0xc978
movq -0x8(%rbp), %rsi
callq 0x2320
jmp 0x381e
jmp 0x37c8
callq 0x20a0
cmpl $0x4, (%rax)
je 0x370d
cmpl $0x0, 0x923b(%rip)      # 0xca18
jne 0x37f5
leaq 0x5ba3(%rip), %rdi      # 0x9389
callq 0x24a0
movl $0x1, %edi
callq 0x2520
jmp 0x37f7
movq 0x87fa(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x5b94(%rip), %rsi      # 0x939c
movb $0x0, %al
callq 0x22b0
callq 0x3830
movl $0x1, %edi
callq 0x2520
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/9wm.c
// Function: cleanup
void
cleanup(void)
{
	Client *c, *cc[2], *next;
	XWindowChanges wc;
	int i;

	/*
	 * order of un-reparenting determines final stacking order... 
	 */
	cc[0] = cc[1] = 0;
	for (c = clients; c; c = next) {
		next = c->next;
		i = normal(c);
		c->next = cc[i];
		cc[i] = c;
	}

	for (i = 0; i < 2; i++) {
		for (c = cc[i]; c; c = c->next) {
			if (!withdrawn(c)) {
				gravitate(c, 1);
				XReparentWindow(dpy, c->window, c->screen->root, c->x, c->y);
			}
			wc.border_width = c->border;
			XConfigureWindow(dpy, c->window, CWBorderWidth, &wc);
		}
	}

	XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, timestamp());
	for (i = 0; i < num_screens; i++)
		cmapnofocus(&screens[i]);
	XCloseDisplay(dpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x92e9(%rip), %rax      # 0xcb38
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x38a7
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x98(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rax
movq -0x20(%rbp,%rax,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movslq -0x54(%rbp), %rax
movq %rcx, -0x20(%rbp,%rax,8)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3856
movl $0x0, -0x54(%rbp)
cmpl $0x2, -0x54(%rbp)
jge 0x3965
movslq -0x54(%rbp), %rax
movq -0x20(%rbp,%rax,8), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3955
movq -0x8(%rbp), %rax
cmpl $0x0, 0x98(%rax)
je 0x391e
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x5520
movq 0x9084(%rip), %rdi      # 0xc978
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %r8d
callq 0x2050
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x40(%rbp)
movq 0x9049(%rip), %rdi      # 0xc978
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x10, %edx
leaq -0x50(%rbp), %rcx
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x38c5
jmp 0x3957
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x38ae
movq 0x900c(%rip), %rax      # 0xc978
movq %rax, -0x60(%rbp)
callq 0x33c0
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl $0x1, %esi
movl $0x1, %edx
callq 0x25b0
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl 0x906d(%rip), %eax      # 0xca08
jge 0x39c4
movq 0x906c(%rip), %rdi      # 0xca10
movslq -0x54(%rbp), %rax
imulq $0x178, %rax, %rax      # imm = 0x178
addq %rax, %rdi
movb $0x0, %al
callq 0x5830
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x3992
movq 0x8fad(%rip), %rdi      # 0xc978
callq 0x2590
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/event.c
// Function: unmap
void
unmap(XUnmapEvent * e)
{
	Client *c;

	curtime = CurrentTime;
	c = getclient(e->window, 0);
	if (c) {
		switch (c->state) {
		case IconicState:
			if (e->send_event) {
				unhidec(c, 0);
				withdraw(c);
			}
			break;
		case NormalState:
			if (c == current)
				nofocus();
			if (!c->reparenting)
				withdraw(c);
			break;
		}
		c->reparenting = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x88e5(%rip), %rax      # 0xc998
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x415a
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x411b
jmp 0x40ed
movl -0x14(%rbp), %eax
subl $0x3, %eax
jne 0x414c
jmp 0x40f7
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x4119
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x67e0
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x5450
jmp 0x414c
movq -0x10(%rbp), %rax
leaq 0x8a0a(%rip), %rcx      # 0xcb30
cmpq (%rcx), %rax
jne 0x4132
movb $0x0, %al
callq 0x6c80
movq -0x10(%rbp), %rax
cmpl $0x0, 0xa0(%rax)
jne 0x414a
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x5450
jmp 0x414c
movq -0x10(%rbp), %rax
movl $0x0, 0xa0(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/event.c
// Function: newwindow
void
newwindow(XCreateWindowEvent * e)
{
	Client *c;
	ScreenInfo *s;

	/*
	 * we don't set curtime as nothing here uses it 
	 */
	if (e->override_redirect)
		return;
	c = getclient(e->window, 1);
	if (c && c->window == e->window && (s = getscreen(e->parent))) {
		c->x = e->x;
		c->y = e->y;
		c->dx = e->width;
		c->dy = e->height;
		c->border = e->border_width;
		c->screen = s;
		if (c->parent == None)
			c->parent = c->screen->root;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x41ab
jmp 0x4275
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4275
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x4275
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movb $0x0, %al
callq 0x3350
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4275
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4273
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4275
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/event.c
// Function: destroy
void
destroy(Window w)
{
	Client *c;

	curtime = CurrentTime;
	c = getclient(w, 0);
	if (c == 0)
		return;

	rmclient(c);

	/*
	 * flush any errors generated by the window's sudden demise 
	 */
	ignore_badwindow = 1;
	XSync(dpy, False);
	ignore_badwindow = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x8705(%rip), %rax      # 0xc998
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x42b3
jmp 0x42e9
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x7020
leaq 0x88a3(%rip), %rax      # 0xcb68
movl $0x1, (%rax)
leaq 0x86a6(%rip), %rax      # 0xc978
movq (%rax), %rdi
xorl %esi, %esi
callq 0x23a0
leaq 0x8885(%rip), %rax      # 0xcb68
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/event.c
// Function: cmap
void
cmap(XColormapEvent * e)
{
	Client *c;
	int i;

	/*
	 * we don't set curtime as nothing here uses it 
	 */
	if (e->new) {
		c = getclient(e->window, 0);
		if (c) {
			c->cmap = e->colormap;
			if (c == current)
				cmapfocus(c);
		} else
			for (c = clients; c; c = c->next) {
				for (i = 0; i < c->ncmapwins; i++)
					if (c->cmapwins[i] == e->window) {
						c->wmcmaps[i] = e->colormap;
						if (c == current)
							cmapfocus(c);
						return;
					}
			}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x4701
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4659
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x10(%rbp), %rax
leaq 0x84ec(%rip), %rcx      # 0xcb30
cmpq (%rcx), %rax
jne 0x4654
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x56b0
jmp 0x46ff
leaq 0x84d8(%rip), %rax      # 0xcb38
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x46fd
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xe0(%rcx), %eax
jge 0x46ea
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x46dd
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
leaq 0x8465(%rip), %rcx      # 0xcb30
cmpq (%rcx), %rax
jne 0x46db
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x56b0
jmp 0x4701
jmp 0x46df
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4679
jmp 0x46ec
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4667
jmp 0x46ff
jmp 0x4701
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/event.c
// Function: reparent
void
reparent(XReparentEvent * e)
{
	Client *c;
	XWindowAttributes attr;
	ScreenInfo *s;

	/*
	 * we don't set curtime as nothing here uses it 
	 */
	if (!getscreen(e->event) || e->override_redirect)
		return;
	if ((s = getscreen(e->parent)) != 0) {
		c = getclient(e->window, 1);
		if (c != 0 && (c->dx == 0 || c->dy == 0)) {
			XGetWindowAttributes(dpy, c->window, &attr);
			c->x = attr.x;
			c->y = attr.y;
			c->dx = attr.width;
			c->dy = attr.height;
			c->border = attr.border_width;
			c->screen = s;
			if (c->parent == None)
				c->parent = c->screen->root;
		}
	} else {
		c = getclient(e->window, 0);
		if (c != 0 && (c->parent == c->screen->root || withdrawn(c)))
			rmclient(c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movb $0x0, %al
callq 0x3350
cmpq $0x0, %rax
je 0x496e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x4973
jmp 0x4ab3
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movb $0x0, %al
callq 0x3350
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x4a64
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4a62
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x49ce
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x4a62
leaq 0x7fa3(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x98(%rbp), %rdx
callq 0x2490
movl -0x98(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x94(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl -0x90(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movl -0x8c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movl -0x88(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0xa0(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4a60
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4a62
jmp 0x4ab3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4ab1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rcx
cmpq 0x8(%rcx), %rax
je 0x4aa6
movq -0x10(%rbp), %rax
cmpl $0x0, 0x98(%rax)
jne 0x4ab1
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x7020
jmp 0x4ab3
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)