LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/lbs-dynamodb/metadata.c
// Function: callback_readmetadata
static int
callback_readmetadata(void * cookie, int status,
    const uint8_t * buf, size_t len)
{
	struct metadata * M = cookie;
	uint8_t nbuf[104];

	/* Failures are bad. */
	if (status == 1)
		goto err0;

	/* Did the item exist? */
	if (status == 2) {
		warnp("metadata table is not initialized");
		goto err0;
	}

	/* We should have 104 bytes. */
	if (len != 104) {
		warn0("metadata has incorrect size: %zu", len);
		goto err0;
	}

	/* Parse it. */
	M->M_stored.nextblk = be64dec(&buf[0]);
	M->M_stored.deletedto = be64dec(&buf[8]);
	M->M_stored.generation = be64dec(&buf[16]);
	M->M_stored.lastblk = be64dec(&buf[24]);
	M->itemsz = be64dec(&buf[64]);
	memcpy(M->tableid, &buf[72], 32);

	/* Generate a random process ID. */
	if (entropy_read(M->process_id, 32)) {
		warn0("Failed to generate random process ID");
		goto err0;
	}

	/* Write new metadata back. */
	memcpy(nbuf, buf, 104);
	memcpy(&nbuf[32], M->process_id, 32);
	if (proto_dynamodb_kv_request_icas(M->Q, "metadata", buf, 104,
	    nbuf, 104, callback_claimmetadata, M))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpl $0x1, %esi
je 0x453c
cmpl $0x2, %esi
jne 0x4431
callq 0x20a0
cmpl $0x0, (%rax)
je 0x44d2
movq %rax, %rbx
leaq 0x9527(%rip), %rdi      # 0xd946
xorl %eax, %eax
callq 0x94c8
movl $0x0, (%rbx)
jmp 0x453c
cmpq $0x68, %rcx
jne 0x44b4
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdx), %rax
bswapq %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rdx), %rax
bswapq %rax
movq %rax, 0x10(%rdi)
movq 0x10(%rdx), %rax
bswapq %rax
movq %rax, 0x18(%rdi)
movq 0x18(%rdx), %rax
bswapq %rax
movq %rax, 0x20(%rdi)
movq 0x40(%rdx), %rax
bswapq %rax
movq %rax, 0xd8(%rdi)
movups 0x48(%rdx), %xmm0
movups 0x58(%rdx), %xmm1
movups %xmm0, 0xe0(%rdi)
movups %xmm1, 0xf0(%rdi)
leaq 0x98(%rdi), %r15
movl $0x20, %esi
movq %r15, %rdi
callq 0x761b
testl %eax, %eax
je 0x44e2
leaq 0x94de(%rip), %rdi      # 0xd989
xorl %eax, %eax
callq 0x95e7
jmp 0x44c5
leaq 0x94ad(%rip), %rdi      # 0xd968
movq %rcx, %rsi
xorl %eax, %eax
callq 0x95e7
callq 0x20a0
movl $0x0, (%rax)
jmp 0x453c
leaq 0x946d(%rip), %rdi      # 0xd946
xorl %eax, %eax
callq 0x95e7
jmp 0x453c
movq %rsp, %r12
movl $0x68, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2250
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm0, 0x20(%r12)
movaps %xmm1, 0x30(%r12)
movq (%r14), %rdi
leaq 0x2b7(%rip), %rax       # 0x47cb
leaq 0x92e1(%rip), %rsi      # 0xd7fc
movl $0x68, %ecx
movl $0x68, %r9d
movq %r12, %r8
movq %rbx, %rdx
pushq %r14
pushq %rax
callq 0x990c
addq $0x10, %rsp
testl %eax, %eax
je 0x454d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x4541
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/lbs-dynamodb/metadata.c
// Function: writemetadata
static int
writemetadata(struct metadata * M)
{
	uint8_t obuf[104];
	uint8_t buf[104];

	/* Is a write already in progress? */
	if (M->write_inprogress == 1) {
		M->write_wanted = 1;
		return (0);
	}

	/* We're going to start a write now. */
	M->write_inprogress = 1;
	M->write_wanted = 0;

	/* We're going to store the latest metadata values. */
	M->M_storing = M->M_latest;

	/* The requested callback will be performed when the store completes. */
	M->M_latest.callback_state = NULL;

	/* Increment metadata generation for the next metadata stored. */
	M->M_latest.generation++;

	/* Encode metadata. */
	be64enc(&obuf[0], M->M_stored.nextblk);
	be64enc(&obuf[8], M->M_stored.deletedto);
	be64enc(&obuf[16], M->M_stored.generation);
	be64enc(&obuf[24], M->M_stored.lastblk);
	memcpy(&obuf[32], M->process_id, 32);
	be64enc(&obuf[64], M->itemsz);
	memcpy(&obuf[72], M->tableid, 32);
	be64enc(&buf[0], M->M_storing.nextblk);
	be64enc(&buf[8], M->M_storing.deletedto);
	be64enc(&buf[16], M->M_storing.generation);
	be64enc(&buf[24], M->M_storing.lastblk);
	memcpy(&buf[32], M->process_id, 32);
	be64enc(&buf[64], M->itemsz);
	memcpy(&buf[72], M->tableid, 32);

	/* Write metadata. */
	if (proto_dynamodb_kv_request_icas(M->Q, "metadata", obuf, 104,
	    buf, 104, callback_writemetadata, M))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
movq %rdi, %rax
cmpl $0x1, 0xc8(%rdi)
jne 0x45ba
movl $0x1, 0xcc(%rax)
xorl %eax, %eax
retq
subq $0xd8, %rsp
movq $0x1, 0xc8(%rax)
movups 0x68(%rax), %xmm0
movups %xmm0, 0x38(%rax)
movups 0x78(%rax), %xmm0
movups %xmm0, 0x48(%rax)
movups 0x88(%rax), %xmm0
movups %xmm0, 0x58(%rax)
movq $0x0, 0x88(%rax)
incq 0x78(%rax)
movq 0x8(%rax), %rcx
bswapq %rcx
leaq 0x70(%rsp), %rdx
movq %rcx, (%rdx)
movq 0x10(%rax), %rcx
bswapq %rcx
movq %rcx, 0x8(%rdx)
movq 0x18(%rax), %rcx
bswapq %rcx
movq %rcx, 0x10(%rdx)
movq 0x20(%rax), %rcx
bswapq %rcx
movq %rcx, 0x18(%rdx)
movups 0x98(%rax), %xmm0
movups 0xa8(%rax), %xmm1
movaps %xmm0, 0x20(%rdx)
movaps %xmm1, 0x30(%rdx)
movq 0xd8(%rax), %rcx
bswapq %rcx
movq %rcx, 0x40(%rdx)
movups 0xe0(%rax), %xmm0
movups 0xf0(%rax), %xmm1
movups %xmm0, 0x48(%rdx)
movups %xmm1, 0x58(%rdx)
movq 0x38(%rax), %rsi
bswapq %rsi
movq %rsp, %r8
movq %rsi, (%r8)
movq 0x40(%rax), %rsi
bswapq %rsi
movq %rsi, 0x8(%r8)
movq 0x48(%rax), %rsi
bswapq %rsi
movq %rsi, 0x10(%r8)
movq 0x50(%rax), %rsi
bswapq %rsi
movq %rsi, 0x18(%r8)
movups 0x98(%rax), %xmm0
movups 0xa8(%rax), %xmm1
movaps %xmm0, 0x20(%r8)
movaps %xmm1, 0x30(%r8)
movq %rcx, 0x40(%r8)
movups 0xe0(%rax), %xmm0
movups 0xf0(%rax), %xmm1
movups %xmm0, 0x48(%r8)
movups %xmm1, 0x58(%r8)
movq (%rax), %rdi
leaq 0x149(%rip), %r10       # 0x4815
leaq 0x9129(%rip), %rsi      # 0xd7fc
movl $0x68, %ecx
movl $0x68, %r9d
pushq %rax
pushq %r10
callq 0x990c
addq $0x10, %rsp
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testq %rdi, %rdi
je 0x478b
cmpq $0x0, 0x88(%rdi)
jne 0x478d
cmpq $0x0, 0xb8(%rdi)
jne 0x47ac
popq %rax
jmp 0x2040
popq %rax
retq
leaq 0x909e(%rip), %rdi      # 0xd832
leaq 0x90ba(%rip), %rsi      # 0xd855
leaq 0x9160(%rip), %rcx      # 0xd902
movl $0x1cd, %edx            # imm = 0x1CD
callq 0x21a0
leaq 0x9175(%rip), %rdi      # 0xd928
leaq 0x909b(%rip), %rsi      # 0xd855
leaq 0x9141(%rip), %rcx      # 0xd902
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/lbs-dynamodb/objmap.c
// Function: objmap
const char *
objmap(uint64_t N)
{
	uint8_t Nbuf[8];
	static char key[17]; /* 0123456789ABCDEF\0 */

	/* Serialize the value N. */
	be64enc(Nbuf, N);

	/* Hexify the 8-byte integer. */
	hexify(Nbuf, key, 8);

	/* Return the constructed string. */
	return (key);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
bswapq %rdi
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
leaq 0xfcc1(%rip), %rbx      # 0x145e0
movl $0x8, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7cc4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl $0x4, %edi
callq 0x2270
testq %rax, %rax
je 0x7455
movq %rax, %rbx
leaq 0x6d78(%rip), %rdi      # 0xe199
xorl %esi, %esi
xorl %eax, %eax
callq 0x2300
movl %eax, (%rbx)
cmpl $-0x1, %eax
jne 0x74a5
callq 0x20a0
cmpl $0x0, (%rax)
je 0x748d
movq %rax, %r14
leaq 0x6d61(%rip), %rdi      # 0xe1a6
xorl %eax, %eax
callq 0x94c8
movl $0x0, (%r14)
jmp 0x749b
callq 0x20a0
cmpl $0x0, (%rax)
je 0x747b
movq %rax, %r14
leaq 0x6d29(%rip), %rdi      # 0xe192
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x94c8
movl $0x0, (%r14)
jmp 0x74a5
leaq 0x6d10(%rip), %rdi      # 0xe192
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x95e7
jmp 0x74a5
leaq 0x6d12(%rip), %rdi      # 0xe1a6
xorl %eax, %eax
callq 0x95e7
movq %rbx, %rdi
callq 0x2040
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x755d
movq %rdx, %r14
testq %rdx, %rdx
js 0x757c
xorl %ebx, %ebx
testq %r14, %r14
je 0x754f
movq %rsi, %r15
movq %rdi, %r12
movl (%r12), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2210
testq %rax, %rax
je 0x7521
cmpq $-0x1, %rax
je 0x74fe
addq %rax, %r15
subq %rax, %r14
jne 0x74da
jmp 0x754f
callq 0x20a0
cmpl $0x0, (%rax)
je 0x753c
movq %rax, %rbx
leaq 0x6d17(%rip), %rdi      # 0xe229
xorl %eax, %eax
callq 0x94c8
movl $0x0, (%rbx)
jmp 0x754a
leaq 0x6d14(%rip), %rdi      # 0xe23c
xorl %eax, %eax
callq 0x95e7
callq 0x20a0
movl $0x0, (%rax)
jmp 0x754a
leaq 0x6ce6(%rip), %rdi      # 0xe229
xorl %eax, %eax
callq 0x95e7
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6c55(%rip), %rdi      # 0xe1b9
leaq 0x6c59(%rip), %rsi      # 0xe1c4
leaq 0x6c70(%rip), %rcx      # 0xe1e2
movl $0x4a, %edx
callq 0x21a0
leaq 0x6b1d(%rip), %rdi      # 0xe0a0
leaq 0x6c3a(%rip), %rsi      # 0xe1c4
leaq 0x6c51(%rip), %rcx      # 0xe1e2
movl $0x4b, %edx
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x75fc
movq %rdi, %rbx
movl (%rbx), %edi
callq 0x21c0
cmpl $-0x1, %eax
jne 0x75d6
callq 0x20a0
movq %rax, %r14
movl (%rax), %eax
cmpl $0x4, %eax
je 0x75a7
leaq 0x6cbc(%rip), %rdi      # 0xe285
testl %eax, %eax
jne 0x75da
xorl %eax, %eax
callq 0x95e7
jmp 0x75e8
xorl %ebp, %ebp
jmp 0x75ed
xorl %eax, %eax
callq 0x94c8
movl $0x0, (%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6bb6(%rip), %rdi      # 0xe1b9
leaq 0x6bba(%rip), %rsi      # 0xe1c4
leaq 0x6c40(%rip), %rcx      # 0xe251
movl $0x70, %edx
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
js 0x76ae
movq %rsi, %r14
movq %rdi, %r15
callq 0x7404
testq %rax, %rax
je 0x7671
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x74b0
testl %eax, %eax
je 0x767a
leaq 0x6c7a(%rip), %rdi      # 0xe2cf
xorl %eax, %eax
callq 0x95e7
callq 0x20a0
movl $0x0, (%rax)
movq %rbx, %rdi
callq 0x759b
jmp 0x769f
leaq 0x6c45(%rip), %rdi      # 0xe2bd
jmp 0x768d
movq %rbx, %rdi
callq 0x759b
testl %eax, %eax
je 0x76aa
leaq 0x6c54(%rip), %rdi      # 0xe2e1
xorl %eax, %eax
callq 0x95e7
callq 0x20a0
movl $0x0, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x76a4
leaq 0x69eb(%rip), %rdi      # 0xe0a0
leaq 0x6b08(%rip), %rsi      # 0xe1c4
leaq 0x6bd6(%rip), %rcx      # 0xe299
movl $0x91, %edx
callq 0x21a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0xa4f4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xa18f
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0xa170
movq 0x10(%rsp), %r12
movq %r12, %rax
shrq $0x20, %rax
jne 0xa1f9
movq 0x8(%rsp), %rax
movq %rax, (%r14)
cmpq $0x4, %r12
jb 0xa18f
movl (%r15), %eax
bswapl %eax
movl %eax, 0x8(%r14)
cmpl $0x4, %eax
ja 0xa18f
leaq 0x4c68(%rip), %rcx      # 0xedbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0xc, %r12
jne 0xa18f
movq 0x4(%r15), %rax
bswapq %rax
movq %rax, 0x10(%r14)
jmp 0xa180
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
jmp 0xa18d
cmpq $0x4, %r12
jne 0xa18f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xa99c
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x10, %r12
jb 0xa18f
movl 0x4(%r15), %eax
bswapl %eax
movl %eax, 0x10(%r14)
movq 0x8(%r15), %rcx
bswapq %rcx
movq %rcx, 0x18(%r14)
testl %eax, %eax
je 0xa18f
addq $-0x10, %r12
movl %eax, %ecx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0xa18f
movl %eax, 0x14(%r14)
movq %r12, %rdi
callq 0x2270
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0xa18f
addq $0x10, %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2250
jmp 0xa180
leaq 0x4cbd(%rip), %rdi      # 0xeebd
leaq 0x4be8(%rip), %rsi      # 0xedef
leaq 0x4cc4(%rip), %rcx      # 0xeed2
movl $0x15, %edx
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movl $0xc, %edx
callq 0xb1cc
testq %rax, %rax
je 0xa29a
movl %ebp, %ecx
rolw $0x8, %cx
movw %cx, 0x2(%rax)
movl %ebp, %ecx
shrl $0x10, %ecx
movb %cl, 0x1(%rax)
shrl $0x18, %ebp
movb %bpl, (%rax)
movb %bl, 0xb(%rax)
movb %bh, 0xa(%rax)
movl %ebx, %ecx
shrl $0x10, %ecx
movb %cl, 0x9(%rax)
movl %ebx, %ecx
shrl $0x18, %ecx
movb %cl, 0x8(%rax)
movq %rbx, %rcx
shrq $0x20, %rcx
movb %cl, 0x7(%rax)
movq %rbx, %rcx
shrq $0x28, %rcx
movb %cl, 0x6(%rax)
movq %rbx, %rcx
shrq $0x30, %rcx
movb %cl, 0x5(%rax)
shrq $0x38, %rbx
movb %bl, 0x4(%rax)
movl $0xc, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xb29a
testl %eax, %eax
je 0xa2a1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa2a3
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movl $0x14, %edx
callq 0xb1cc
testq %rax, %rax
je 0xa372
movl %ebp, %ecx
rolw $0x8, %cx
movw %cx, 0x2(%rax)
movl %ebp, %ecx
shrl $0x10, %ecx
movb %cl, 0x1(%rax)
shrl $0x18, %ebp
movb %bpl, (%rax)
movb %bl, 0xb(%rax)
movb %bh, 0xa(%rax)
movl %ebx, %ecx
shrl $0x10, %ecx
movb %cl, 0x9(%rax)
movl %ebx, %ecx
shrl $0x18, %ecx
movb %cl, 0x8(%rax)
movq %rbx, %rcx
shrq $0x20, %rcx
movb %cl, 0x7(%rax)
movq %rbx, %rcx
shrq $0x28, %rcx
movb %cl, 0x6(%rax)
movq %rbx, %rcx
shrq $0x30, %rcx
movb %cl, 0x5(%rax)
shrq $0x38, %rbx
movb %bl, 0x4(%rax)
movq %r15, %rdx
movb %dl, 0x13(%rax)
movb %dh, 0x12(%rax)
movl %edx, %ecx
shrl $0x10, %ecx
movb %cl, 0x11(%rax)
movl %edx, %ecx
shrl $0x18, %ecx
movb %cl, 0x10(%rax)
movq %r15, %rcx
shrq $0x20, %rcx
movb %cl, 0xf(%rax)
movq %r15, %rcx
shrq $0x28, %rcx
movb %cl, 0xe(%rax)
movq %r15, %rcx
shrq $0x30, %rcx
movb %cl, 0xd(%rax)
shrq $0x38, %rdx
movb %dl, 0xc(%rax)
movl $0x14, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xb29a
testl %eax, %eax
je 0xa379
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa37b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edx
jae 0xa40f
movq %r8, %r14
movl %ecx, %r12d
movl %edx, %ebp
movq %rdi, %rbx
leal 0x4(%r12), %eax
testl %edx, %edx
movl $0x4, %r15d
cmovel %eax, %r15d
movq %r15, %rdx
callq 0xb1cc
testq %rax, %rax
je 0xa3f7
movq %rax, %r13
movb %bpl, 0x3(%rax)
movb $0x0, 0x2(%rax)
movw $0x0, (%rax)
testl %ebp, %ebp
jne 0xa3e5
movq %r13, %rdi
addq $0x4, %rdi
movl %r12d, %edx
movq %r14, %rsi
callq 0x2250
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xb29a
testl %eax, %eax
je 0xa3fe
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa400
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49ba(%rip), %rdi      # 0xedd0
leaq 0x49d2(%rip), %rsi      # 0xedef
leaq 0x49ef(%rip), %rcx      # 0xee13
movl $0xc5, %edx
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edx
jae 0xa49c
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
xorl %eax, %eax
testl %edx, %edx
sete %al
leaq 0x4(,%rax,8), %r15
movq %r15, %rdx
callq 0xb1cc
testq %rax, %rax
je 0xa488
movb %bpl, 0x3(%rax)
movb $0x0, 0x2(%rax)
movw $0x0, (%rax)
testl %ebp, %ebp
jne 0xa476
bswapq %r14
movq %r14, 0x4(%rax)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xb29a
testl %eax, %eax
je 0xa48f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa491
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x492d(%rip), %rdi      # 0xedd0
leaq 0x4945(%rip), %rsi      # 0xedef
leaq 0x49be(%rip), %rcx      # 0xee6f
movl $0xec, %edx
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
jne 0x2f48
movq %rdi, %rbx
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movq $0x0, 0x40(%rbx)
movl %esi, 0x18(%rbx)
movq %rdx, 0x8(%rbx)
callq 0x752e
testl %eax, %eax
jne 0x2f67
movl 0x30(%rbx), %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8159(%rip), %rdi      # 0xb0a8
leaq 0x8166(%rip), %rsi      # 0xb0bc
leaq 0x8168(%rip), %rcx      # 0xb0c5
movl $0x52, %edx
callq 0x21b0
leaq 0x8182(%rip), %rdi      # 0xb0f0
leaq 0x8147(%rip), %rsi      # 0xb0bc
leaq 0x8149(%rip), %rcx      # 0xb0c5
movl $0x56, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: sink_close
void sink_close(struct sink *x)
{
	assert(x->sp->pid > 0);

	/* we are no more interested in tap output
	 */
	subprocess_close_child_fdin(x->sp);

	assert(subprocess_terminate(x->sp) == 0);

	x->fd = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x20(%rdi)
jle 0x2fb9
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x694c
movq %r14, %rdi
callq 0x760b
testl %eax, %eax
jne 0x2fd8
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x814c(%rip), %rdi      # 0xb10c
leaq 0x80f5(%rip), %rsi      # 0xb0bc
leaq 0x814d(%rip), %rcx      # 0xb11b
movl $0x5e, %edx
callq 0x21b0
leaq 0x815b(%rip), %rdi      # 0xb13a
leaq 0x80d6(%rip), %rsi      # 0xb0bc
leaq 0x812e(%rip), %rcx      # 0xb11b
movl $0x64, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: fd_tap_open
int fd_tap_open(struct fd_tap *x, int fd)
{
	memset(x, 0, sizeof(struct fd_tap));
	x->fd = fd;
	assert(make_fd_non_blocking(x->fd) == 0);
	DEBUG_INFO("fd_tap_open(x,fd=%i): done", fd);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, (%rdi)
movl $0x0, 0x8(%rdi)
movl %esi, (%rdi)
movl %esi, %edi
callq 0x5944
testl %eax, %eax
jne 0x301a
xorl %eax, %eax
popq %rbp
retq
leaq 0x813a(%rip), %rdi      # 0xb15b
leaq 0x8094(%rip), %rsi      # 0xb0bc
leaq 0x814d(%rip), %rcx      # 0xb17c
movl $0x6d, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: file_tap_open
int file_tap_open(struct file_tap *x, const char *path)
{
	assert(x->path->s == NULL);
	memset(x, 0, sizeof(struct file_tap));
	str_copyz(x->path, path);
	x->fd = open(x->path->s, O_RDONLY);
	assert(x->fd > 0);
	assert(make_fd_non_blocking(x->fd) == 0);
	DEBUG_INFO("file_tap_open(x,path=[%s]): done", path);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
jne 0x30c3
movq %rdi, %rbx
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
callq 0x9daf
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x22f0
movl %eax, (%rbx)
testl %eax, %eax
jle 0x30e2
movl %eax, %edi
callq 0x5944
testl %eax, %eax
jne 0x3101
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8106(%rip), %rdi      # 0xb1d0
leaq 0x7feb(%rip), %rsi      # 0xb0bc
leaq 0x810b(%rip), %rcx      # 0xb1e3
movl $0x7c, %edx
callq 0x21b0
leaq 0x812d(%rip), %rdi      # 0xb216
leaq 0x7fcc(%rip), %rsi      # 0xb0bc
leaq 0x80ec(%rip), %rcx      # 0xb1e3
movl $0x80, %edx
callq 0x21b0
leaq 0x8053(%rip), %rdi      # 0xb15b
leaq 0x7fad(%rip), %rsi      # 0xb0bc
leaq 0x80cd(%rip), %rcx      # 0xb1e3
movl $0x81, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: file_tap_close
void file_tap_close(struct file_tap *x)
{
	assert(x->path->len);
	assert(x->fd >= 0);
	close(x->fd);
	x->fd = -1;
	str_free(x->path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x10(%rdi)
je 0x3151
movq %rdi, %rbx
movl (%rdi), %edi
testl %edi, %edi
js 0x3170
leaq 0x8(%rbx), %r14
callq 0x21e0
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9d0f
leaq 0x80c8(%rip), %rdi      # 0xb220
leaq 0x7f5d(%rip), %rsi      # 0xb0bc
leaq 0x80c7(%rip), %rcx      # 0xb22d
movl $0x88, %edx
callq 0x21b0
leaq 0x802b(%rip), %rdi      # 0xb1a2
leaq 0x7f3e(%rip), %rsi      # 0xb0bc
leaq 0x80a8(%rip), %rcx      # 0xb22d
movl $0x89, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: cat_tap_open
int cat_tap_open(struct cat_tap *x, const char *path, int seek_end)
{
	int pid;

	assert(x->path->s == NULL);
	assert(x->sp->argv == NULL); /* not used since we won't execve */
	memset(x, 0, sizeof(struct cat_tap));

	str_copyz(x->path, path);

	if ((pid = subprocess_fork0(x->sp)) == 0) {
		/* child
		 */
		int i;
		for (i = getdtablesize(); i >= 0; i--) {
			if (i <= STDERR_FILENO) continue;
			close(i);
		}
		if (seek_end) {
		  assert(tail_fn0(x->path->s) == 0);
		} else {
		  assert(tail_f(x->path->s) == 0);
		}
		exit(0);
	} else if (pid < 0) {
		return -1;
	}

	x->fd = x->sp->child_fdout;

	DEBUG_INFO("cat_tap_open(x, path=[%s]): done, pid=%i", path, x->sp->pid);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x3207
movq %rdi, %r15
cmpq $0x0, 0x18(%rdi)
jne 0x3226
movl %edx, %ebx
leaq 0x8(%r15), %r14
leaq 0x18(%r15), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movq $0x0, 0x50(%r15)
movq %r14, %rdi
callq 0x9daf
movq %r12, %rdi
callq 0x6e86
testl %eax, %eax
je 0x3245
js 0x31f9
movl 0x44(%r15), %eax
movl %eax, (%r15)
xorl %eax, %eax
jmp 0x31fe
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7fc2(%rip), %rdi      # 0xb1d0
leaq 0x7ea7(%rip), %rsi      # 0xb0bc
leaq 0x8038(%rip), %rcx      # 0xb254
movl $0x97, %edx
callq 0x21b0
leaq 0x7e7b(%rip), %rdi      # 0xb0a8
leaq 0x7e88(%rip), %rsi      # 0xb0bc
leaq 0x8019(%rip), %rcx      # 0xb254
movl $0x98, %edx
callq 0x21b0
callq 0x23a0
testl %eax, %eax
js 0x326b
movl %eax, %r15d
cmpl $0x3, %r15d
jl 0x325f
movl %r15d, %edi
callq 0x21e0
leal -0x1(%r15), %eax
testl %r15d, %r15d
movl %eax, %r15d
jg 0x3251
movq (%r14), %rdi
testl %ebx, %ebx
jne 0x329c
xorl %esi, %esi
callq 0x577b
testl %eax, %eax
je 0x32aa
leaq 0x8020(%rip), %rdi      # 0xb2a4
leaq 0x7e31(%rip), %rsi      # 0xb0bc
leaq 0x7fc2(%rip), %rcx      # 0xb254
movl $0xa8, %edx
callq 0x21b0
movl $0x1, %esi
callq 0x577b
testl %eax, %eax
jne 0x32b1
xorl %edi, %edi
callq 0x2350
leaq 0x7fd2(%rip), %rdi      # 0xb28a
leaq 0x7dfd(%rip), %rsi      # 0xb0bc
leaq 0x7f8e(%rip), %rcx      # 0xb254
movl $0xa6, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: cat_tap_close
void cat_tap_close(struct cat_tap *x)
{
	assert(x->sp->pid > 0);
	assert(x->sp->argv == NULL);

	/* we are no more interested in tap output
	 */
	subprocess_close_child_fdout(x->sp);
	subprocess_close_child_fderr(x->sp);

	DEBUG_INFO("sending SIGTERM to cat_tap pid %i", x->sp->pid);
	assert(kill(x->sp->pid, SIGTERM) == 0);

	assert(subprocess_terminate(x->sp) == 0);

	x->fd = -1;
	str_free(x->path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x30(%rdi)
jle 0x332d
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
cmpq $0x0, (%r14)
jne 0x334c
movq %r14, %rdi
callq 0x69b7
movq %r14, %rdi
callq 0x6a22
movl 0x30(%rbx), %edi
movl $0xf, %esi
callq 0x2280
testl %eax, %eax
jne 0x336b
movq %r14, %rdi
callq 0x760b
testl %eax, %eax
jne 0x338a
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9d0f
leaq 0x7dd8(%rip), %rdi      # 0xb10c
leaq 0x7d81(%rip), %rsi      # 0xb0bc
leaq 0x7f7a(%rip), %rcx      # 0xb2bc
movl $0xb8, %edx
callq 0x21b0
leaq 0x7d55(%rip), %rdi      # 0xb0a8
leaq 0x7d62(%rip), %rsi      # 0xb0bc
leaq 0x7f5b(%rip), %rcx      # 0xb2bc
movl $0xb9, %edx
callq 0x21b0
leaq 0x7f6f(%rip), %rdi      # 0xb2e1
leaq 0x7d43(%rip), %rsi      # 0xb0bc
leaq 0x7f3c(%rip), %rcx      # 0xb2bc
movl $0xc1, %edx
callq 0x21b0
leaq 0x7da9(%rip), %rdi      # 0xb13a
leaq 0x7d24(%rip), %rsi      # 0xb0bc
leaq 0x7f1d(%rip), %rcx      # 0xb2bc
movl $0xc3, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: fd_tap_read
int fd_tap_read(struct fd_tap *x, void *buf, int bufsz)
{
	int n = read(x->fd, buf, bufsz);
	if (n < 0) {
		int save_errno = errno;
		assert(n == -1);
		if (errno == EAGAIN) return -1;
		if (errno == EINTR) return -1;
		DEBUG("read(), errno=%i", save_errno);
		errno = save_errno;
		perror("read()");
		exit(1);
	}
	if (n) {
		x->bytes_read += n;
		//get_current_timeval(x->time_read);
	} else {
		assert(x->got_eof == 0);
		x->got_eof = 1;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl (%rdi), %edi
movslq %edx, %rdx
callq 0x2200
movq %rax, %rbx
testl %ebx, %ebx
js 0x33cc
je 0x33ef
addl %ebx, 0x4(%r14)
jmp 0x33fe
callq 0x2080
cmpl $-0x1, %ebx
jne 0x3405
movl (%rax), %edi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x4, %edi
je 0x33fe
cmpl $0xb, %edi
je 0x33fe
movq %rax, %rsi
callq 0x23f0
cmpl $0x0, 0x8(%r14)
jne 0x3424
movl $0x1, 0x8(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7ef4(%rip), %rdi      # 0xb300
leaq 0x7ca9(%rip), %rsi      # 0xb0bc
leaq 0x7eee(%rip), %rcx      # 0xb308
movl $0xce, %edx
callq 0x21b0
leaq 0x7f0b(%rip), %rdi      # 0xb336
leaq 0x7c8a(%rip), %rsi      # 0xb0bc
leaq 0x7ecf(%rip), %rcx      # 0xb308
movl $0xda, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: buffer_new
struct buffer *buffer_new(struct buffer *tail, int id, void *buf, int bufsz)
{
	struct buffer *r = buffer_new0(tail);
	r->id = id;
#if 0
	DEBUG_INFO("%i -> %i", r->_position, tail ? tail->_position : -1);
	str_copyf(r->buf, "%s got %i bytes\n", id, bufsz);
#else
	str_copyn(r->buf, buf, bufsz);
#endif
	r->pos = 0;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r13
movl $0x1, %edi
movl $0x30, %esi
callq 0x2220
movq %rax, %r15
testq %r13, %r13
je 0x3936
movl (%r13), %eax
incl %eax
jmp 0x3938
xorl %eax, %eax
movl %eax, (%r15)
movq %r13, 0x8(%r15)
movl %r12d, 0x10(%r15)
movq %r15, %rdi
addq $0x18, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9d2c
movl $0x0, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: buffer_free
void buffer_free(struct buffer *x)
{
	while (x) {
		struct buffer *t = x->tail;
		str_free(x->buf);
		free(x);
		x = t;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x399e
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %r14
leaq 0x18(%rbx), %rdi
callq 0x9d0f
movq %rbx, %rdi
callq 0x2060
movq %r14, %rbx
testq %r14, %r14
jne 0x397d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: buffer_queue_free
void buffer_queue_free(struct buffer_queue *x)
{
	if (x) {
		buffer_free(x->enqueue);
		buffer_free(x->dequeue);
		free(x);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x39cc
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x396e
movq 0x8(%rbx), %rdi
callq 0x396e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: sink_flush_all_buffers
int sink_flush_all_buffers(struct sink *x, struct buffer_queue *q)
{
	int r;
	int total = 0;
	DEBUG_INFO("sink_flush_all_buffers(x=[pid=%i], q=[buffers=%i]) begin", x->sp->pid, buffer_queue_len(q));
	while (buffer_queue_len(q)) {
		int n;
		n = sink_write_from_queue(x, q);
		if (n < 0) {
			int save_errno = errno;
			assert(n == -1);
			DEBUG("sink_flush_all_buffers(x=[pid=%i]), errno=%i", x->sp->pid, save_errno);
			errno = save_errno;
			perror("sink_write_from_queue()");
			return -1;
		}
		total += n;
		if (x->got_eof) break;
		if ((r = wait_til_ready_for_write(x->fd, 5000 /* 5 secs */))) {
			int save_errno = errno;
			assert(r == -1);
			DEBUG("wait_til_ready_for_write(x->fd=%i), errno=%i", x->fd, save_errno);
			errno = save_errno;
			perror("wait_til_ready_for_write(x->fd)");
			return -1;
		}
	}
	DEBUG_INFO("sink_flush_all_buffers(x=[pid=%i,eof=%i], q=[buffers=%i]) done", x->sp->pid, x->got_eof, buffer_queue_len(q));
	return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rdi), %r12
xorl %ebx, %ebx
xorl %r13d, %r13d
testq %r14, %r14
je 0x3ff1
movq (%r14), %rdx
xorl %eax, %eax
movl $0x0, %ecx
testq %rdx, %rdx
je 0x3f66
movl (%rdx), %ecx
notl %ecx
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x3f73
movl (%rdx), %eax
incl %eax
cmpl %ecx, %eax
je 0x3fee
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b71
testl %eax, %eax
js 0x3fae
addl %eax, %r13d
movl $0x3, %eax
cmpl $0x0, 0x40(%r15)
jne 0x3fa8
movl (%r15), %edi
movl $0x1388, %esi           # imm = 0x1388
xorl %edx, %edx
callq 0x3cc5
testl %eax, %eax
jne 0x3fc4
testl %eax, %eax
je 0x3f4a
jmp 0x3fe4
cmpl $-0x1, %eax
jne 0x4002
movq %r12, %rdi
callq 0x256f
leaq 0x764b(%rip), %rdi      # 0xb60d
jmp 0x3fd8
cmpl $-0x1, %eax
jne 0x4021
movq %r15, %rdi
callq 0x25b4
leaq 0x767a(%rip), %rdi      # 0xb652
callq 0x2310
movl $0x1, %eax
jmp 0x3fa8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x3, %eax
jne 0x3ff1
movl %r13d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x72f7(%rip), %rdi      # 0xb300
leaq 0x70ac(%rip), %rsi      # 0xb0bc
leaq 0x7588(%rip), %rcx      # 0xb59f
movl $0x209, %edx            # imm = 0x209
callq 0x21b0
leaq 0x8a8f(%rip), %rdi      # 0xcab7
leaq 0x708d(%rip), %rsi      # 0xb0bc
leaq 0x7569(%rip), %rcx      # 0xb59f
movl $0x213, %edx            # imm = 0x213
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/aimant.c
// Function: tail0
static int tail0(char *filename, int seek_end)
{
	int fd;

	if ((fd = open(filename, O_RDONLY)) < 0) {
		int save_errno = errno;
		assert(fd == -1);
		DEBUG("open(filename=[%s], O_RDONLY), errno=%i", filename, save_errno);
		errno = save_errno;
		perror(filename);
		return -1;
	}

	if (seek_end && lseek(fd, 0, SEEK_END) < 0) {
		int save_errno = errno;
		errno = save_errno;
		DEBUG("lseek(fd=%i, 0, SEEK_END), errno=%i", fd, save_errno);
		perror("lseek(fd, 0, SEEK_END)");

		assert(close(fd) == 0);
		fd = -1;
		return 1;
	}

	tail0loop(fd, STDOUT_FILENO);

	assert(close(fd) == 0);
	fd = -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100008, %rsp         # imm = 0x100008
movl %esi, %r15d
movq %rdi, %r14
xorl %esi, %esi
xorl %eax, %eax
callq 0x22f0
movl %eax, %ebx
testl %eax, %eax
js 0x58a6
testl %r15d, %r15d
je 0x57c4
movl %ebx, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2190
testq %rax, %rax
js 0x58ba
xorl %r12d, %r12d
leaq -0x100030(%rbp), %r14
movl $0x100000, %edx         # imm = 0x100000
movl %ebx, %edi
movq %r14, %rsi
callq 0x2200
movq %rax, %r15
testl %r15d, %r15d
js 0x5864
je 0x5837
xorl %r13d, %r13d
movl %r13d, %eax
leaq (%rax,%rbp), %rsi
addq $-0x100030, %rsi        # imm = 0xFFEFFFD0
movl %r15d, %eax
subl %r13d, %eax
movslq %eax, %rdx
movl $0x1, %edi
callq 0x2120
testl %eax, %eax
jle 0x581a
addl %eax, %r13d
cmpl %r15d, %r13d
jl 0x57ea
movl %r15d, %eax
xorl %r13d, %r13d
testl %eax, %eax
setns %cl
jns 0x5876
cmpl $-0x1, %eax
jne 0x58e7
movl %r15d, %edi
callq 0x2a0e
jmp 0x5871
leal 0x1(%r12), %r13d
imull $0x1388, %r13d, %edi    # imm = 0x1388
cmpl $0x13, %r12d
movl $0x186a0, %eax          # imm = 0x186A0
cmovgel %eax, %edi
cmpl $0x63, %r12d
movl $0x3d090, %eax          # imm = 0x3D090
cmovgel %eax, %edi
callq 0x23d0
movb $0x1, %cl
jmp 0x5876
cmpl $-0x1, %r15d
jne 0x58c8
movl %ebx, %edi
callq 0x2a61
xorl %ecx, %ecx
movl %r12d, %r13d
movl %r13d, %r12d
testb %cl, %cl
jne 0x57ce
movl %ebx, %edi
callq 0x21e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x5925
addq $0x100008, %rsp         # imm = 0x100008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x1, %ebx
jne 0x5906
movq %r14, %rdi
callq 0x2ab6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5894
movl %ebx, %edi
callq 0x29a5
movl $0x1, %eax
jmp 0x5894
leaq 0x5a31(%rip), %rdi      # 0xb300
leaq 0x57e6(%rip), %rsi      # 0xb0bc
leaq 0x6563(%rip), %rcx      # 0xbe40
movl $0x529, %edx            # imm = 0x529
callq 0x21b0
leaq 0x71c9(%rip), %rdi      # 0xcab7
leaq 0x57c7(%rip), %rsi      # 0xb0bc
leaq 0x6544(%rip), %rcx      # 0xbe40
movl $0x532, %edx            # imm = 0x532
callq 0x21b0
leaq 0x60af(%rip), %rdi      # 0xb9bc
leaq 0x57a8(%rip), %rsi      # 0xb0bc
leaq 0x64ab(%rip), %rcx      # 0xbdc6
movl $0x550, %edx            # imm = 0x550
callq 0x21b0
leaq 0x619d(%rip), %rdi      # 0xbac9
leaq 0x5789(%rip), %rsi      # 0xb0bc
leaq 0x648c(%rip), %rcx      # 0xbdc6
movl $0x564, %edx            # imm = 0x564
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/subprocess.c
// Function: child_new
struct child *child_new(struct subprocess *sp)
{
	struct child *c = child_new0();
	assert(c);
	c->sp = sp;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x2220
testq %rax, %rax
je 0x66ad
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x66a8(%rip), %rdi      # 0xcd5c
leaq 0x586b(%rip), %rsi      # 0xbf26
leaq 0x5aa6(%rip), %rcx      # 0xc168
movl $0x6f, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/subprocess.c
// Function: children_search_by_pid
struct child *children_search_by_pid(struct children * rbtree, int key)
{
	struct child *ret;
	int cmp;
	ret = rbtree->rbt_root;
	while (ret != &rbtree->rbt_nil && (cmp = child_cmp_by_pid(key, ret)) != 0) {
		if (cmp < 0) {
			ret = rbtn_left_get(struct child, _meta, ret);
		} else {
			ret = rbtn_right_get(struct child, _meta, ret);
		}
	}
	if (ret == &rbtree->rbt_nil) {
		ret = NULL;
	}
	return ret;
}

// Assembly:
movq (%rdi), %rax
addq $0x8, %rdi
cmpq %rdi, %rax
je 0x6728
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rax), %rcx
cmpl %esi, 0x18(%rcx)
je 0x6726
jle 0x6717
movq (%rax), %rax
jmp 0x671f
movq 0x8(%rax), %rax
andq $-0x2, %rax
cmpq %rdi, %rax
jne 0x6707
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/subprocess.c
// Function: children_free
void children_free(struct children * x)
{
    if (x) {
	struct child *c, *n;
	for (c = children_first(x); c; c = n) {
	    n = children_next(x, c);
	    children_remove(x, c);
	    child_free(c);
	}
	free(x);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x6756
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
leaq 0x8(%rdi), %rax
cmpq %rax, %rcx
je 0x6757
movq %rcx, %r14
movq (%rcx), %rcx
cmpq %rax, %rcx
jne 0x6749
jmp 0x675a
retq
movq %rcx, %r14
cmpq %rax, %r14
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x679e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a1a
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5dd3
movq 0x10(%r14), %rax
movl $0x1, 0x34(%rax)
movq %r14, %rdi
callq 0x2060
movq %r15, %r14
testq %r15, %r15
jne 0x676a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2060
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/subprocess.c
// Function: get_current_timeval
void get_current_timeval(struct timeval *tv)
{
#ifdef USE_CLOCK_GETTIME
	struct timespec ts[1];
	assert(clock_gettime(CLOCK_REALTIME, ts) == 0);
	tv->tv_sec = ts->tv_sec;
	tv->tv_usec = ts->tv_nsec / 1000;
#else
	assert(gettimeofday(tv, NULL) == 0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x2110
testl %eax, %eax
jne 0x67f9
movq -0x20(%rbp), %rax
movq %rax, (%rbx)
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq -0x18(%rbp)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5995(%rip), %rdi      # 0xc195
leaq 0x571f(%rip), %rsi      # 0xbf26
leaq 0x59ae(%rip), %rcx      # 0xc1bc
movl $0xac, %edx
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/subprocess.c
// Function: interrupt_safe_sleep
void interrupt_safe_sleep(int msec)
{
	int r;
	struct timeval start;
	struct timeval current;
	struct timeval tv;
	long usec;
	long dmsec;

	get_current_timeval(&start);

	DEBUG_INFO("interrupt_safe_sleep(%u)", msec);

	tv.tv_sec = 0;
	tv.tv_usec = msec * 1000;
	r = select(0, NULL, NULL, NULL, &tv);
	while (r < 0) {
		assert(r == -1);
		assert(errno == EINTR);

		get_current_timeval(&current);
		if ((dmsec = DELTA_MSEC(&current, &start)) >= msec) {
			break;
		}

		DEBUG_INFO("resuming interrupt safe sleep, %li milliseconds to go, total %i", msec - dmsec, msec);
		tv.tv_sec = 0;
		tv.tv_usec = (msec - dmsec) * 1000;
		r = select(0, NULL, NULL, NULL, &tv);
	}

	get_current_timeval(&current);
	usec = DELTA_USEC(&current, &start);
	DEBUG_INFO("%li milliseconds elapsed (%lu usecs)", usec / 1000, usec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
leaq -0x58(%rbp), %rdi
callq 0x67b0
leaq -0x38(%rbp), %r8
movq $0x0, (%r8)
imull $0x3e8, %ebx, %eax      # imm = 0x3E8
cltq
movq %rax, 0x8(%r8)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2290
testl %eax, %eax
jns 0x68f6
movq -0x58(%rbp), %r15
movq -0x50(%rbp), %r12
movslq %ebx, %r13
movabsq $0x20c49ba5e353f7cf, %rbx # imm = 0x20C49BA5E353F7CF
leaq -0x38(%rbp), %r14
cmpl $-0x1, %eax
jne 0x692d
callq 0x2080
cmpl $0x4, (%rax)
jne 0x690e
leaq -0x48(%rbp), %rdi
callq 0x67b0
movq -0x48(%rbp), %rax
subq %r15, %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
addq -0x40(%rbp), %rax
subq %r12, %rax
imulq %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %r13, %rax
subq %rdx, %rax
jle 0x68f6
movq $0x0, -0x38(%rbp)
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x30(%rbp)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x2290
testl %eax, %eax
js 0x6885
leaq -0x48(%rbp), %rdi
callq 0x67b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58f1(%rip), %rdi      # 0xc206
leaq 0x560a(%rip), %rsi      # 0xbf26
leaq 0x58c4(%rip), %rcx      # 0xc1e7
movl $0x17f, %edx            # imm = 0x17F
callq 0x21b0
leaq 0x6183(%rip), %rdi      # 0xcab7
leaq 0x55eb(%rip), %rsi      # 0xbf26
leaq 0x58a5(%rip), %rcx      # 0xc1e7
movl $0x17e, %edx            # imm = 0x17E
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/subprocess.c
// Function: subprocess_close_child_fdin
void subprocess_close_child_fdin(struct subprocess *sp)
{
	assert(sp->pid > 0);
	if (sp->child_fdin >= 0) {
		assert(xclose(sp->child_fdin) == 0);
		sp->child_fdin = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x18(%rdi)
jle 0x6979
movq %rdi, %rbx
movl 0x28(%rdi), %edi
testl %edi, %edi
js 0x6972
callq 0x21e0
testl %eax, %eax
jne 0x6998
movl $0xffffffff, 0x28(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4f47(%rip), %rdi      # 0xb8c7
leaq 0x559f(%rip), %rsi      # 0xbf26
leaq 0x5887(%rip), %rcx      # 0xc215
movl $0x193, %edx            # imm = 0x193
callq 0x21b0
leaq 0x58ac(%rip), %rdi      # 0xc24b
leaq 0x5580(%rip), %rsi      # 0xbf26
leaq 0x5868(%rip), %rcx      # 0xc215
movl $0x195, %edx            # imm = 0x195
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/subprocess.c
// Function: subprocess_close_child_fdout
void subprocess_close_child_fdout(struct subprocess *sp)
{
	assert(sp->pid > 0);
	if (sp->child_fdout >= 0) {
		assert(xclose(sp->child_fdout) == 0);
		sp->child_fdout = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x18(%rdi)
jle 0x69e4
movq %rdi, %rbx
movl 0x2c(%rdi), %edi
testl %edi, %edi
js 0x69dd
callq 0x21e0
testl %eax, %eax
jne 0x6a03
movl $0xffffffff, 0x2c(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4edc(%rip), %rdi      # 0xb8c7
leaq 0x5534(%rip), %rsi      # 0xbf26
leaq 0x586e(%rip), %rcx      # 0xc267
movl $0x19c, %edx            # imm = 0x19C
callq 0x21b0
leaq 0x5894(%rip), %rdi      # 0xc29e
leaq 0x5515(%rip), %rsi      # 0xbf26
leaq 0x584f(%rip), %rcx      # 0xc267
movl $0x19e, %edx            # imm = 0x19E
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/alexgirao[P]aimant/subprocess.c
// Function: subprocess_close_child_fderr
void subprocess_close_child_fderr(struct subprocess *sp)
{
	assert(sp->pid > 0);
	if (sp->child_fderr >= 0) {
		assert(xclose(sp->child_fderr) == 0);
		sp->child_fderr = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x18(%rdi)
jle 0x6a4f
movq %rdi, %rbx
movl 0x30(%rdi), %edi
testl %edi, %edi
js 0x6a48
callq 0x21e0
testl %eax, %eax
jne 0x6a6e
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4e71(%rip), %rdi      # 0xb8c7
leaq 0x54c9(%rip), %rsi      # 0xbf26
leaq 0x5857(%rip), %rcx      # 0xc2bb
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x21b0
leaq 0x587d(%rip), %rdi      # 0xc2f2
leaq 0x54aa(%rip), %rsi      # 0xbf26
leaq 0x5838(%rip), %rcx      # 0xc2bb
movl $0x1a7, %edx            # imm = 0x1A7
callq 0x21b0