LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/dispatch.c
// Function: dispatch_accept
struct dispatch_state *
dispatch_accept(struct state * S, struct deleteto * deleteto, int s)
{
	struct dispatch_state * D;

	/* Allocate space for dispatcher state. */
	if ((D = malloc(sizeof(struct dispatch_state))) == NULL)
		goto err0;

	/* Initialize dispatcher. */
	D->S = S;
	D->D = deleteto;

	/* Accept a connection. */
	D->accepting = 1;
	if (network_accept(s, callback_accept, D) == NULL)
		goto err1;

	/* Success! */
	return (D);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x40, %edi
callq 0x2280
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3389
jmp 0x33d9
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x10(%rax)
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rdx
leaq 0x37(%rip), %rsi        # 0x33f0
callq 0x8700
cmpq $0x0, %rax
jne 0x33c6
jmp 0x33d0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33e1
movq -0x28(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/dispatch.c
// Function: dispatch_done
int
dispatch_done(struct dispatch_state * D)
{

	/* Sanity check. */
	assert(D->accepting == 0);
	assert(D->read_cookie == NULL);
	assert(D->npending == 0);

	/* Free the buffered reader for the connection. */
	netbuf_read_free(D->readq);

	/* Free the buffered writer for the connection. */
	netbuf_write_free(D->writeq);

	/* Close the connection. */
	while (close(D->sconn)) {
		if (errno == EINTR)
			continue;
		warnp("close");
		goto err0;
	}

	/* Free allocated memory. */
	free(D);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x36c8
jmp 0x36e7
leaq 0xfca1(%rip), %rdi      # 0x13370
leaq 0xfcac(%rip), %rsi      # 0x13382
movl $0x162, %edx            # imm = 0x162
leaq 0xfcab(%rip), %rcx      # 0x1338d
callq 0x21b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x36f4
jmp 0x3713
leaq 0xfcbd(%rip), %rdi      # 0x133b8
leaq 0xfc80(%rip), %rsi      # 0x13382
movl $0x163, %edx            # imm = 0x163
leaq 0xfc7f(%rip), %rcx      # 0x1338d
callq 0x21b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x3720
jmp 0x373f
leaq 0xfca8(%rip), %rdi      # 0x133cf
leaq 0xfc54(%rip), %rsi      # 0x13382
movl $0x164, %edx            # imm = 0x164
leaq 0xfc53(%rip), %rcx      # 0x1338d
callq 0x21b0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7e00
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x84d0
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x21d0
cmpl $0x0, %eax
je 0x37af
callq 0x20a0
cmpl $0x4, (%rax)
jne 0x3776
jmp 0x3759
jmp 0x3778
callq 0x20a0
cmpl $0x0, (%rax)
je 0x379d
leaq 0x10a8b(%rip), %rdi     # 0x14214
movb $0x0, %al
callq 0xd010
callq 0x20a0
movl $0x0, (%rax)
jmp 0x37ab
leaq 0x10a70(%rip), %rdi     # 0x14214
movb $0x0, %al
callq 0xd260
jmp 0x37ad
jmp 0x37c1
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x37c8
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/lbs-dynamodb/dispatch.c
// Function: callback_get
static int
callback_get(void * cookie, struct proto_lbs_request * R,
    const uint8_t * buf, size_t blklen)
{
	struct dispatch_state * D = cookie;
	int status;
	int rc;

	/* Does the block exist? */
	if (buf != NULL)
		status = 0;
	else
		status = 1;

	/* Sanity check. */
	assert(blklen <= UINT32_MAX);

	/* Send a response back. */
	rc = proto_lbs_response_get(D->writeq, R->ID, status, (uint32_t)blklen,
	    buf);

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

	/* This request is done. */
	D->npending -= 1;

	/* Return success/failure from response write. */
	return (rc);
}

// 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 %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3bc0
movl $0x0, -0x2c(%rbp)
jmp 0x3bc7
movl $0x1, -0x2c(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x20(%rbp)
ja 0x3bd4
jmp 0x3bf3
leaq 0xf90e(%rip), %rdi      # 0x134e9
leaq 0xf7a0(%rip), %rsi      # 0x13382
movl $0xc5, %edx
leaq 0xf910(%rip), %rcx      # 0x134fe
callq 0x21b0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %r8
callq 0xe890
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x30(%rax)
movl -0x30(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/dispatch.c
// Function: callback_append
static int
callback_append(void * cookie, struct proto_lbs_request * R, uint64_t nextblk)
{
	struct dispatch_state * D = cookie;
	int rc;

	/* Send a response back. */
	rc = proto_lbs_response_append(D->writeq, R->ID, 0, nextblk);

	/* Free the request. */
	free(R->r.append.buf);
	free(R);

	/* This request is now done. */
	D->npending -= 1;
	D->appendip = 0;

	/* Return success/failure from response write. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rcx
xorl %edx, %edx
callq 0xe970
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x38(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/state.c
// Function: state_init
struct state *
state_init(struct wire_requestqueue * Q_DDBKV, size_t itemsz, uint8_t * tableid,
    struct metadata * M)
{
	struct state * S;
	struct readtableid RT;

	/* Sanity check. */
	assert(itemsz - KVOVERHEAD <= UINT32_MAX);

	/* Allocate a structure and initialize. */
	if ((S = malloc(sizeof(struct state))) == NULL)
		goto err0;
	S->Q = Q_DDBKV;
	S->M = M;
	S->blklen = (uint32_t)(itemsz - KVOVERHEAD);
	S->npending = 0;

	/* Read "nextblk" and "lastblk" values. */
	S->nextblk = metadata_nextblk_read(S->M);
	S->lastblk = metadata_lastblk_read(S->M);

	/* Read tableid from the table. */
	RT.done = 0;
	if (proto_dynamodb_kv_request_getc(S->Q, "tableid", callback_init, &RT))
		goto err1;
	if (events_spin(&RT.done)) {
		warnp("Error reading tableid");
		goto err1;
	}

	/* Verify that the table IDs match. */
	if (memcmp(RT.tableid, tableid, 32)) {
		warn0("Data table ID does not match metadata table ID!");
		goto err1;
	}

	/* Success! */
	return (S);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x12, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
ja 0x3cec
jmp 0x3d0b
leaq 0xf859(%rip), %rdi      # 0x1354c
leaq 0xf874(%rip), %rsi      # 0x1356e
movl $0x72, %edx
leaq 0xf870(%rip), %rcx      # 0x13576
callq 0x21b0
movl $0x30, %edi
callq 0x2280
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3d24
jmp 0x3e4a
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
subq $0x12, %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4f30
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5290
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x54(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0xf984(%rip), %rsi      # 0x13722
leaq 0xbb(%rip), %rdx        # 0x3e60
leaq -0x54(%rbp), %rcx
callq 0xe010
cmpl $0x0, %eax
je 0x3db8
jmp 0x3e41
leaq -0x54(%rbp), %rdi
callq 0x5bd0
cmpl $0x0, %eax
je 0x3dff
jmp 0x3dc8
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3ded
leaq 0xf7f8(%rip), %rdi      # 0x135d1
movb $0x0, %al
callq 0xd010
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3dfb
leaq 0xf7dd(%rip), %rdi      # 0x135d1
movb $0x0, %al
callq 0xd260
jmp 0x3dfd
jmp 0x3e41
leaq -0x54(%rbp), %rdi
addq $0x4, %rdi
movq -0x20(%rbp), %rsi
movl $0x20, %edx
callq 0x2220
cmpl $0x0, %eax
je 0x3e37
jmp 0x3e1c
leaq 0xf7c4(%rip), %rdi      # 0x135e7
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3e41
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e52
movq -0x30(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/state.c
// Function: callback_init
static int
callback_init(void * cookie, int status, const uint8_t * buf, size_t buflen)
{
	struct readtableid * RT = cookie;

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

	/* Check status. */
	if (status == 1) {
		warn0("Failed to read tableid");
		goto err0;
	} else if (status == 2) {
		warn0("Tableid not initialized");
		goto err0;
	}

	/* Check buffer length. */
	if (buflen != 32) {
		warn0("Tableid is not 32 bytes");
		goto err0;
	}

	/* Copy the table ID out. */
	memcpy(RT->tableid, buf, 32);

	/* We've finished reading this value. */
	RT->done = 1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3e91
cmpl $0x1, -0x14(%rbp)
je 0x3e91
cmpl $0x2, -0x14(%rbp)
jne 0x3e93
jmp 0x3eb2
leaq 0xf811(%rip), %rdi      # 0x136ab
leaq 0xf6cd(%rip), %rsi      # 0x1356e
movl $0x43, %edx
leaq 0xf82e(%rip), %rcx      # 0x136db
callq 0x21b0
cmpl $0x1, -0x14(%rbp)
jne 0x3ed8
jmp 0x3eba
leaq 0xf852(%rip), %rdi      # 0x13713
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3f5b
cmpl $0x2, -0x14(%rbp)
jne 0x3efb
jmp 0x3ee0
leaq 0xf843(%rip), %rdi      # 0x1372a
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3f5b
jmp 0x3efd
cmpq $0x20, -0x28(%rbp)
je 0x3f21
jmp 0x3f06
leaq 0xf835(%rip), %rdi      # 0x13742
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3f5b
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x4(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0xc(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x14(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x1c(%rax)
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3f62
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/state.c
// Function: state_get
int
state_get(struct state * S, struct proto_lbs_request * R,
    int (* callback)(void *, struct proto_lbs_request *,
        const uint8_t *, size_t), void * cookie)
{
	struct get_cookie * C;

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

	/* Send the request. */
	if (proto_dynamodb_kv_request_get(S->Q, objmap(R->r.get.blkno),
	    callback_get, C))
		goto err1;

	/* We will be performing a callback later. */
	S->npending += 1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x28, %edi
callq 0x2280
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3fe1
jmp 0x4074
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5810
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rcx
leaq 0x4a(%rip), %rdx        # 0x4090
callq 0xdc90
cmpl $0x0, %eax
je 0x4052
jmp 0x406b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x407b
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/state.c
// Function: state_append
int
state_append(struct state * S, struct proto_lbs_request * R,
    int (* callback)(void *, struct proto_lbs_request *, uint64_t),
    void * cookie)
{
	struct append_cookie * C;

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct append_cookie))) == NULL)
		goto err0;
	C->S = S;
	C->R = R;
	C->callback = callback;
	C->cookie = cookie;
	C->nblks_left = R->r.append.nblks;
	C->nextblk_old = S->nextblk;

	/* Update nextblk. */
	S->nextblk += R->r.append.nblks;
	if (metadata_nextblk_write(S->M, S->nextblk,
	    callback_append_put_nextblk, C))
		goto err1;

	/* We will be performing a callback later. */
	S->npending += 1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x30, %edi
callq 0x2280
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x4261
jmp 0x430f
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x30(%rbp), %rcx
leaq 0x3f(%rip), %rdx        # 0x4320
callq 0x4f50
cmpl $0x0, %eax
je 0x42ed
jmp 0x4306
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4316
movq -0x30(%rbp), %rdi
callq 0x2040
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/lbs-dynamodb/state.c
// Function: callback_append_put_nextblk
int
callback_append_put_nextblk(void * cookie)
{
	struct append_cookie * C = cookie;
	struct state * S = C->S;
	struct proto_lbs_request * R = C->R;
	size_t i;

	/* Store all the blocks. */
	for (i = 0; i < R->r.append.nblks; i++) {
		if (proto_dynamodb_kv_request_put(S->Q,
		    objmap(C->nextblk_old + i),
		    &R->r.append.buf[i * S->blklen], S->blklen,
		    callback_append_put_blks, C))
			goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jae 0x43cf
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
addq -0x30(%rbp), %rdi
callq 0x5810
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
imulq %rcx, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %r9
leaq 0x3d(%rip), %r8         # 0x43f0
callq 0xd4a0
cmpl $0x0, %eax
je 0x43bf
jmp 0x43d8
jmp 0x43c1
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4353
movl $0x0, -0x4(%rbp)
jmp 0x43df
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/lbs-dynamodb/state.c
// Function: callback_append_put_blks
int
callback_append_put_blks(void * cookie, int status)
{
	struct append_cookie * C = cookie;
	struct state * S = C->S;

	/* Sanity-check: We should be storing blocks. */
	assert(C->nblks_left != 0);

	/* Failures are bad. */
	if (status) {
		warn0("DynamoDB-KV failed storing data block");
		goto err0;
	}

	/* We've stored a block. */
	C->nblks_left--;

	/* If we've stored all the blocks, record a new lastblk value. */
	if (C->nblks_left == 0) {
		S->lastblk = S->nextblk - 1;
		if (metadata_lastblk_write(S->M, S->lastblk,
		    callback_append_put_lastblk, C))
			goto err0;
	}

	/* Success! */
	return (0);

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

// 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)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x441f
jmp 0x443e
leaq 0xf1f1(%rip), %rdi      # 0x13617
leaq 0xf141(%rip), %rsi      # 0x1356e
movl $0x155, %edx            # imm = 0x155
leaq 0xf1f1(%rip), %rcx      # 0x1362a
callq 0x21b0
cmpl $0x0, -0x14(%rbp)
je 0x4461
jmp 0x4446
leaq 0xf207(%rip), %rdi      # 0x13654
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x44c2
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x44b9
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x1, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rcx
leaq 0x35(%rip), %rdx        # 0x44e0
callq 0x52b0
cmpl $0x0, %eax
je 0x44b7
jmp 0x44c2
jmp 0x44b9
movl $0x0, -0x4(%rbp)
jmp 0x44c9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/state.c
// Function: callback_append_put_lastblk
int
callback_append_put_lastblk(void * cookie)
{
	struct append_cookie * C = cookie;
	struct state * S = C->S;
	int rc;

	/* Tell the dispatcher to send its response back. */
	rc = (C->callback)(C->cookie, C->R, S->nextblk);

	/* We've done a callback. */
	S->npending -= 1;

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

	/* 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 (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x2040
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/deleteto.c
// Function: deleteto_init
struct deleteto *
deleteto_init(struct wire_requestqueue * Q_DDBKV, struct metadata * M)
{
	struct deleteto * D;

	/* Allocate and initialize a DeleteTo structure. */
	if ((D = malloc(sizeof(struct deleteto))) == NULL)
		goto err0;
	D->Q = Q_DDBKV;
	D->MD = M;
	D->N = 0;
	D->flushed = 0;
	D->npending = 0;
	D->shuttingdown = 0;
	D->shutdown = 0;
	D->ip_head = NULL;
	D->ip_tail = NULL;

	/* How far are we guaranteed was previously deleted? */
	D->M = metadata_deletedto_read(D->MD);

	/* We want to be poked every time a metadata write completes. */
	metadata_deletedto_register(D->MD, poke, D);

	/* Success! */
	return (D);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x48, %edi
callq 0x2280
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x45c9
jmp 0x466c
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5350
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x23(%rip), %rsi        # 0x4680
callq 0x5390
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4674
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/deleteto.c
// Function: deleteto_stop
int
deleteto_stop(struct deleteto * D)
{

	/* We don't want to do any more DELETEs, just shut down. */
	D->shuttingdown = 1;

	/* Poke the deleter in case it's not already doing anything. */
	if (poke(D))
		goto err0;

	/* Wait for all pending operations to finish. */
	if (events_spin(&D->shutdown))
		goto err0;

	/* We don't want to know about metadata writes completing. */
	metadata_deletedto_register(D->MD, NULL, NULL);

	/* Free the DeleteTo structure. */
	free(D);

	/* Success! */
	return (0);

	/*
	 * We don't free D in the error path, in case there are pending
	 * callbacks holding references to it; until D->shutdown is nonzero
	 * we can't assume that all operations have completed.
	 */
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x4680
cmpl $0x0, %eax
je 0x4977
jmp 0x49b1
movq -0x10(%rbp), %rdi
addq $0x34, %rdi
callq 0x5bd0
cmpl $0x0, %eax
je 0x498b
jmp 0x49b1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x5390
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x49b8
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/lbs-dynamodb/deleteto.c
// Function: callback_done
static int
callback_done(void * cookie, int status)
{
	struct delete * D1 = cookie;
	struct deleteto * D = D1->D;

	/* Sanity-check. */
	assert(D->npending > 0);

	/* Failures are bad, m'kay? */
	if (status) {
		warn0("DynamoDB-KV DELETE operation failed!");
		goto err0;
	}

	/* Remove from linked list of in-progress deletes. */
	if (D1->prev != NULL)
		D1->prev->next = D1->next;
	else
		D->ip_head = D1->next;
	if (D1->next != NULL)
		D1->next->prev = D1->prev;
	else
		D->ip_tail = D1->prev;

	/* Free cookie. */
	free(D1);

	/* We've finished an operation. */
	D->npending -= 1;

	/* Check what we should do next. */
	if (poke(D))
		goto err0;

	/* Success! */
	return (0);

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

// 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)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x49ff
jmp 0x4a1e
leaq 0xede8(%rip), %rdi      # 0x137ee
leaq 0xedf1(%rip), %rsi      # 0x137fe
movl $0xb1, %edx
leaq 0xedf0(%rip), %rcx      # 0x13809
callq 0x21b0
cmpl $0x0, -0x14(%rbp)
je 0x4a44
jmp 0x4a26
leaq 0xedfb(%rip), %rdi      # 0x13828
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x4ad8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4a65
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x4a75
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4a96
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x4aa6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rdi
callq 0x4680
cmpl $0x0, %eax
je 0x4acf
jmp 0x4ad8
movl $0x0, -0x4(%rbp)
jmp 0x4adf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/metadata.c
// Function: metadata_nextblk_write
int
metadata_nextblk_write(struct metadata * M, uint64_t nextblk,
    int (* callback)(void *), void * cookie)
{

	/* We shouldn't have a callback already. */
	assert(M->M_latest.callback_state == NULL);

	/* Record the new value and callback parameters. */
	M->M_latest.nextblk = nextblk;
	M->M_latest.callback_state = callback;
	M->M_latest.cookie_state = cookie;

	/* We want to write metadata as soon as possible. */
	if (writemetadata(M))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x4f78
jmp 0x4f97
leaq 0xe93f(%rip), %rdi      # 0x138be
leaq 0xe95b(%rip), %rsi      # 0x138e1
movl $0x14f, %edx            # imm = 0x14F
leaq 0xe95a(%rip), %rcx      # 0x138ec
callq 0x21b0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rdi
callq 0x4ff0
cmpl $0x0, %eax
je 0x4fd1
jmp 0x4fda
movl $0x0, -0x4(%rbp)
jmp 0x4fe1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/metadata.c
// Function: metadata_lastblk_write
int
metadata_lastblk_write(struct metadata * M, uint64_t lastblk,
    int (* callback)(void *), void * cookie)
{

	/* We shouldn't have a callback already. */
	assert(M->M_latest.callback_state == NULL);

	/* Record the new value and callback parameters. */
	M->M_latest.lastblk = lastblk;
	M->M_latest.callback_state = callback;
	M->M_latest.cookie_state = cookie;

	/* We want to write metadata as soon as possible. */
	if (writemetadata(M))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x52d8
jmp 0x52f7
leaq 0xe5df(%rip), %rdi      # 0x138be
leaq 0xe5fb(%rip), %rsi      # 0x138e1
movl $0x178, %edx            # imm = 0x178
leaq 0xe64b(%rip), %rcx      # 0x1393d
callq 0x21b0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rdi
callq 0x4ff0
cmpl $0x0, %eax
je 0x5334
jmp 0x533d
movl $0x0, -0x4(%rbp)
jmp 0x5344
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/metadata.c
// Function: metadata_free
void
metadata_free(struct metadata * M)
{

	/* Behave consistently with free(NULL). */
	if (M == NULL)
		return;

	/* We shouldn't have any updates or callbacks in flight. */
	assert(M->M_latest.callback_state == NULL);
	assert(M->callback_deletedto == NULL);

	/* Free our structure. */
	free(M);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x53f5
jmp 0x545c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x5405
jmp 0x5424
leaq 0xe4b2(%rip), %rdi      # 0x138be
leaq 0xe4ce(%rip), %rsi      # 0x138e1
movl $0x1cd, %edx            # imm = 0x1CD
leaq 0xe56f(%rip), %rcx      # 0x1398e
callq 0x21b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x5434
jmp 0x5453
leaq 0xe579(%rip), %rdi      # 0x139b4
leaq 0xe49f(%rip), %rsi      # 0x138e1
movl $0x1ce, %edx            # imm = 0x1CE
leaq 0xe540(%rip), %rcx      # 0x1398e
callq 0x21b0
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-dynamodb/metadata.c
// Function: callback_claimmetadata
static int
callback_claimmetadata(void * _m, int status)
{
	struct metadata * M = _m;

	/* Did we succeed? */
	switch (status) {
	case 0:
		/* Request succeeded and we won the race. */
		M->init_lostrace = 0;
		break;
	case 1:
		/* Request failed.  This is bad. */
		warn0("Failed to claim ownership of metadata!");
		goto err0;
	case 2:
		/* We lost the race. */
		M->init_lostrace = 1;
		break;
	}

	/* We're done. */
	M->init_done = 1;

	/* Success! */
	return (0);

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

// 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)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x5537
jmp 0x5523
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x5547
jmp 0x552d
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x5564
jmp 0x5572
movq -0x20(%rbp), %rax
movl $0x0, 0xd4(%rax)
jmp 0x5572
jmp 0x5549
leaq 0xe4ea(%rip), %rdi      # 0x13a3a
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x5589
movq -0x20(%rbp), %rax
movl $0x1, 0xd4(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0xd0(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5590
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/entropy.c
// Function: entropy_read_init
struct entropy_read_cookie *
entropy_read_init(void)
{
	struct entropy_read_cookie * er;

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

	/* Open /dev/urandom. */
	if ((er->fd = open("/dev/urandom", O_RDONLY)) == -1) {
		warnp("open(/dev/urandom)");
		goto err1;
	}

	/* Success! */
	return (er);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, %edi
callq 0x2280
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x98a5
jmp 0x986e
callq 0x20a0
cmpl $0x0, (%rax)
je 0x9893
leaq 0xa99b(%rip), %rdi      # 0x1421a
movb $0x0, %al
callq 0xd010
callq 0x20a0
movl $0x0, (%rax)
jmp 0x98a1
leaq 0xa980(%rip), %rdi      # 0x1421a
movb $0x0, %al
callq 0xd260
jmp 0x98a3
jmp 0x990c
leaq 0xa975(%rip), %rdi      # 0x14221
xorl %esi, %esi
movb $0x0, %al
callq 0x2310
movq -0x10(%rbp), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
jne 0x98f9
jmp 0x98c2
callq 0x20a0
cmpl $0x0, (%rax)
je 0x98e7
leaq 0xa95b(%rip), %rdi      # 0x1422e
movb $0x0, %al
callq 0xd010
callq 0x20a0
movl $0x0, (%rax)
jmp 0x98f5
leaq 0xa940(%rip), %rdi      # 0x1422e
movb $0x0, %al
callq 0xd260
jmp 0x98f7
jmp 0x9903
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9914
movq -0x10(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/entropy.c
// Function: entropy_read_fill
int
entropy_read_fill(struct entropy_read_cookie * er, uint8_t * buf,
    size_t buflen)
{
	ssize_t lenread;

	/* Sanity checks. */
	assert(er != NULL);
	assert(buflen <= SSIZE_MAX);

	/* Read bytes until we have filled the buffer. */
	while (buflen > 0) {
		if ((lenread = read(er->fd, buf, buflen)) == -1) {
			warnp("read(/dev/urandom)");
			goto err0;
		}

		/* The random device should never EOF. */
		if (lenread == 0) {
			warn0("EOF on /dev/urandom?");
			goto err0;
		}

		/* We've filled a portion of the buffer. */
		buf += (size_t)lenread;
		buflen -= (size_t)lenread;
	}

	/* 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)
cmpq $0x0, -0x10(%rbp)
je 0x993d
jmp 0x995c
leaq 0xa8fd(%rip), %rdi      # 0x14241
leaq 0xa901(%rip), %rsi      # 0x1424c
movl $0x4a, %edx
leaq 0xa913(%rip), %rcx      # 0x1426a
callq 0x21b0
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x20(%rbp)
ja 0x996e
jmp 0x998d
leaq 0xa7b3(%rip), %rdi      # 0x14128
leaq 0xa8d0(%rip), %rsi      # 0x1424c
movl $0x4b, %edx
leaq 0xa8e2(%rip), %rcx      # 0x1426a
callq 0x21b0
jmp 0x998f
cmpq $0x0, -0x20(%rbp)
jbe 0x9a34
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2210
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
jne 0x99f0
jmp 0x99b9
callq 0x20a0
cmpl $0x0, (%rax)
je 0x99de
leaq 0xa8e7(%rip), %rdi      # 0x142b1
movb $0x0, %al
callq 0xd010
callq 0x20a0
movl $0x0, (%rax)
jmp 0x99ec
leaq 0xa8cc(%rip), %rdi      # 0x142b1
movb $0x0, %al
callq 0xd260
jmp 0x99ee
jmp 0x9a3d
cmpq $0x0, -0x28(%rbp)
jne 0x9a14
jmp 0x99f9
leaq 0xa8c4(%rip), %rdi      # 0x142c4
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x9a3d
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x998f
movl $0x0, -0x4(%rbp)
jmp 0x9a44
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/entropy.c
// Function: entropy_read_done
int
entropy_read_done(struct entropy_read_cookie * er)
{

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

	/* Close the device. */
	while (close(er->fd) == -1) {
		if (errno != EINTR) {
			warnp("close(/dev/urandom)");
			goto err1;
		}
	}

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

	/* Success! */
	return (0);

err1:
	free(er);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9a65
jmp 0x9a84
leaq 0xa7d5(%rip), %rdi      # 0x14241
leaq 0xa7d9(%rip), %rsi      # 0x1424c
movl $0x70, %edx
leaq 0xa85a(%rip), %rcx      # 0x142d9
callq 0x21b0
jmp 0x9a86
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x21d0
cmpl $-0x1, %eax
jne 0x9adb
callq 0x20a0
cmpl $0x4, (%rax)
je 0x9ad9
jmp 0x9aa2
callq 0x20a0
cmpl $0x0, (%rax)
je 0x9ac7
leaq 0xa85a(%rip), %rdi      # 0x1430d
movb $0x0, %al
callq 0xd010
callq 0x20a0
movl $0x0, (%rax)
jmp 0x9ad5
leaq 0xa83f(%rip), %rdi      # 0x1430d
movb $0x0, %al
callq 0xd260
jmp 0x9ad7
jmp 0x9aed
jmp 0x9a86
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x9afd
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/util/entropy.c
// Function: entropy_read
int
entropy_read(uint8_t * buf, size_t buflen)
{
	struct entropy_read_cookie * er;

	/* Sanity-check the buffer size. */
	assert(buflen <= SSIZE_MAX);

	/* Open /dev/urandom. */
	if ((er = entropy_read_init()) == NULL) {
		warn0("entropy_read_init");
		goto err0;
	}

	/* Read bytes until we have filled the buffer. */
	if (entropy_read_fill(er, buf, buflen)) {
		warn0("entropy_read_fill");
		goto err1;
	}

	/* Close the device. */
	if (entropy_read_done(er)) {
		warn0("entropy_read_done");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x18(%rbp)
ja 0x9b32
jmp 0x9b51
leaq 0xa5ef(%rip), %rdi      # 0x14128
leaq 0xa70c(%rip), %rsi      # 0x1424c
movl $0x91, %edx
leaq 0xa7d5(%rip), %rcx      # 0x14321
callq 0x21b0
callq 0x9850
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x9b7d
jmp 0x9b62
leaq 0xa7dc(%rip), %rdi      # 0x14345
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x9bed
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9920
cmpl $0x0, %eax
je 0x9bb0
jmp 0x9b95
leaq 0xa7bb(%rip), %rdi      # 0x14357
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x9be4
movq -0x20(%rbp), %rdi
callq 0x9a50
cmpl $0x0, %eax
je 0x9bdb
jmp 0x9bc0
leaq 0xa7a2(%rip), %rdi      # 0x14369
movb $0x0, %al
callq 0xd260
callq 0x20a0
movl $0x0, (%rax)
jmp 0x9bed
movl $0x0, -0x4(%rbp)
jmp 0x9bf4
movq -0x20(%rbp), %rdi
callq 0x9a50
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/proto_lbs/proto_lbs_server.c
// Function: proto_lbs_request_read
int
proto_lbs_request_read(struct netbuf_read * R, struct proto_lbs_request * req)
{
	struct wire_packet P;

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

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

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

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

	/* Success! */
	return (0);

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

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xeb80
cmpl $0x0, %eax
je 0xe3b4
jmp 0xe3fb
cmpq $0x0, -0x20(%rbp)
jne 0xe3bd
jmp 0xe3e7
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xe410
cmpl $0x0, %eax
je 0xe3d1
jmp 0xe3fb
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf050
movl $0x0, -0x4(%rbp)
jmp 0xe402
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
jmp 0xe402
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_server.c
// Function: proto_lbs_response_params
int
proto_lbs_response_params(struct netbuf_write * Q, uint64_t ID,
    uint32_t blklen, uint64_t blkno)
{
	uint8_t * wbuf;

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

	/* Write the packet data. */
	be32enc(&wbuf[0], blklen);
	be64enc(&wbuf[4], blkno);

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, 12))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xc, %edx
callq 0xfcb0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xe655
jmp 0xe694
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xe6b0
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movq -0x28(%rbp), %rsi
callq 0xe720
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0xc, %edx
callq 0xfef0
cmpl $0x0, %eax
je 0xe68b
jmp 0xe694
movl $0x0, -0x4(%rbp)
jmp 0xe69b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_server.c
// Function: proto_lbs_response_params2
int
proto_lbs_response_params2(struct netbuf_write * Q, uint64_t ID,
    uint32_t blklen, uint64_t blkno, uint64_t lastblk)
{
	uint8_t * wbuf;

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

	/* Write the packet data. */
	be32enc(&wbuf[0], blklen);
	be64enc(&wbuf[4], blkno);
	be64enc(&wbuf[12], lastblk);

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, 20))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x14, %edx
callq 0xfcb0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xe829
jmp 0xe879
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xe6b0
movq -0x38(%rbp), %rdi
addq $0x4, %rdi
movq -0x28(%rbp), %rsi
callq 0xe720
movq -0x38(%rbp), %rdi
addq $0xc, %rdi
movq -0x30(%rbp), %rsi
callq 0xe720
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x14, %edx
callq 0xfef0
cmpl $0x0, %eax
je 0xe870
jmp 0xe879
movl $0x0, -0x4(%rbp)
jmp 0xe880
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_server.c
// Function: proto_lbs_response_get
int
proto_lbs_response_get(struct netbuf_write * Q, uint64_t ID,
    int status, uint32_t blklen, const uint8_t * buf)
{
	uint8_t * wbuf;
	size_t len;

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

	/* Compute the response length. */
	len = 4 + ((status == 0) ? blklen : 0);

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

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

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, len))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xe8b6
cmpl $0x1, -0x1c(%rbp)
jne 0xe8b8
jmp 0xe8d7
leaq 0x66a1(%rip), %rdi      # 0x14f60
leaq 0x66b9(%rip), %rsi      # 0x14f7f
movl $0xc5, %edx
leaq 0x66d1(%rip), %rcx      # 0x14fa3
callq 0x21b0
cmpl $0x0, -0x1c(%rbp)
jne 0xe8e5
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0xe8ec
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xe8ec
movl -0x3c(%rbp), %eax
addl $0x4, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xfcb0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xe915
jmp 0xe95e
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xe6b0
cmpl $0x0, -0x1c(%rbp)
jne 0xe93d
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x2260
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xfef0
cmpl $0x0, %eax
je 0xe955
jmp 0xe95e
movl $0x0, -0x4(%rbp)
jmp 0xe965
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_server.c
// Function: proto_lbs_response_append
int
proto_lbs_response_append(struct netbuf_write * Q, uint64_t ID,
    int status, uint64_t blkno)
{
	uint8_t * wbuf;
	size_t len;

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

	/* Compute the response length. */
	len = (status == 0) ? 12 : 4;

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

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

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, len))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xe993
cmpl $0x1, -0x1c(%rbp)
jne 0xe995
jmp 0xe9b4
leaq 0x65c4(%rip), %rdi      # 0x14f60
leaq 0x65dc(%rip), %rsi      # 0x14f7f
movl $0xec, %edx
leaq 0x6650(%rip), %rcx      # 0x14fff
callq 0x21b0
movl -0x1c(%rbp), %edx
movl $0x4, %eax
movl $0xc, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xfcb0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xe9ea
jmp 0xea2e
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xe6b0
cmpl $0x0, -0x1c(%rbp)
jne 0xea0d
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movq -0x28(%rbp), %rsi
callq 0xe720
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xfef0
cmpl $0x0, %eax
je 0xea25
jmp 0xea2e
movl $0x0, -0x4(%rbp)
jmp 0xea35
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_lbs/proto_lbs_server.c
// Function: proto_lbs_response_free
int
proto_lbs_response_free(struct netbuf_write * Q, uint64_t ID)
{
	uint8_t * wbuf;

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

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

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, 4))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0xfcb0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xea6e
jmp 0xea9b
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xe6b0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0xfef0
cmpl $0x0, %eax
je 0xea92
jmp 0xea9b
movl $0x0, -0x4(%rbp)
jmp 0xeaa2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexgirao[P]aimant/aimant.c
// Function: sink_open
int sink_open(struct sink *x, int search_path, char **argv)
{
	assert(x->sp->argv == NULL);
	memset(x, 0, sizeof(struct sink));
	x->sp->search_path = search_path;
	x->sp->argv = argv;
	assert(subprocess_fork(x->sp) == 0);
	x->fd = x->sp->child_fdin;
	DEBUG_INFO("sink_open(x,search_path=%i,argv=[argv[0]=[%s]]): done", search_path, argv[0]);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x24f0
jmp 0x250f
leaq 0xdb51(%rip), %rdi      # 0x10048
leaq 0xdb5e(%rip), %rsi      # 0x1005c
movl $0x52, %edx
leaq 0xdb5b(%rip), %rcx      # 0x10065
callq 0x21a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x21c0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x9cd0
cmpl $0x0, %eax
jne 0x2549
jmp 0x2568
leaq 0xdb40(%rip), %rdi      # 0x10090
leaq 0xdb05(%rip), %rsi      # 0x1005c
movl $0x56, %edx
leaq 0xdb02(%rip), %rcx      # 0x10065
callq 0x21a0
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)