LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_greet_v3_2_rest_recv__REP
static int on_greet_v3_2_rest_recv__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	struct io_req *rd_req;
	struct zmtp_greeting_v3 *greet;
	int rc;

	/*
	 * The rest is received, validate version and recv the REQ hshake
	 */

	if (len < 0)
		goto out;

	/* Validate the rest greeting */
	assert(len == sizeof(*greet));
	greet = req->buf.iov[0].iov_base;
	if (memcmp(&v3_greet, greet,  sizeof(*greet))) {
		len = -EMSGSIZE;
		goto out;
	}

	rd_req = io_req_create(zmtp->io_proto.q, REQ_RD, zmtp,
			       on_greet_v3_3_hshake_recv__REP);
	if (rd_req == NULL) {
		len = -ENOMEM;
		goto out;
	}
	/*
	 * TODO: probably we need generic function for that,
	 * TODO: like zmtp_init_rd_hdr_req() already does.
	 */
	rd_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_len  = 1 /* Flag field to determin the size */
		},
		.iov_num  = 1,
	};
	rc = zmtp->io_proto.submit(rd_req, TO_HEAD);
	if (rc) {
		io_req_put(rd_req);
		len = rc;
		goto out;
	}

out:
	io_req_put(req);
	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
js 0x27ec
cmpl $0x35, %ebp
jne 0x281d
movq 0x28(%r14), %rsi
leaq 0x5a17(%rip), %rdi      # 0x816d
movl $0x35, %edx
callq 0x11a0
movl $0xffffffa6, %r12d      # imm = 0xFFFFFFA6
testl %eax, %eax
jne 0x27ef
movq (%rbx), %rdi
leaq 0xc4(%rip), %rcx        # 0x283c
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3d60
testq %rax, %rax
je 0x2815
movq %rax, %r15
movq $0x0, 0x28(%rax)
movl $0x1, %r12d
movq %r12, 0x30(%rax)
movq %rax, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq %r12, 0x148(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r15)
movups %xmm0, 0x160(%r15)
movq %r15, %rdi
xorl %esi, %esi
callq *0x8(%rbx)
movl %ebp, %r12d
testl %eax, %eax
je 0x27ef
movl %eax, %r13d
movq %r15, %rdi
callq 0x3df6
movl %r13d, %r12d
jmp 0x27ef
movl %ebp, %r12d
movq %r14, %rdi
callq 0x3df6
testl %r12d, %r12d
jns 0x2803
movl $0x2, 0x28(%rbx)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffff4, %r12d      # imm = 0xFFFFFFF4
jmp 0x27ef
leaq 0x2bf0(%rip), %rdi      # 0x5414
leaq 0x2a69(%rip), %rsi      # 0x5294
leaq 0x2bf8(%rip), %rcx      # 0x542a
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_greet_v3_3_hshake_recv__REP
static int on_greet_v3_3_hshake_recv__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;
	struct io_req *wr_req;
	int rc;

	/*
	 * Receive full hshake, validate and send our hshake
	 */

	if (len < 0)
		goto out;

	rc = zmtp_expect_msg(zmtp, req, true, NULL);
	if (rc < 0) {
		len = rc;
		goto out;
	}
	if (rc == 0)
		/* Package is not fully received, continue */
		return 0;

	rc = zmtp_parse_hshake(req, ZMTP_REP);
	if (rc < 0) {
		/* TODO: probably respond with ERROR? */
		len = rc;
		goto out;
	}

	/*
	 * Send hshake
	 */
	wr_req = io_req_create(zmtp->io_proto.q, REQ_WR, zmtp,
			       on_greet_v3_3_hshake_send__REP);
	if (wr_req == NULL) {
		len = -ENOMEM;
		goto out;
	}
	wr_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = ZMTP_V3_REP_HS,
			.iov_len  = sizeof(ZMTP_V3_REP_HS)
		},
		.iov_num  = 1,
	};
	rc = zmtp->io_proto.submit(wr_req, TO_HEAD);
	if (rc) {
		io_req_put(wr_req);
		len = rc;
		goto out;
	}

out:
	io_req_put(req);
	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
js 0x2963
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2158
testl %eax, %eax
js 0x2968
je 0x297f
movl $0xffffffea, %r15d      # imm = 0xFFFFFFEA
cmpq $0x3, 0x148(%r14)
jne 0x28cc
cmpq $0x19, 0x50(%r14)
jb 0x28cc
movq 0x48(%r14), %rax
movdqu (%rax), %xmm0
movdqu 0x9(%rax), %xmm1
movdqu 0x5932(%rip), %xmm2     # 0x81d9
pcmpeqb 0x5921(%rip), %xmm0     # 0x81d0
pcmpeqb %xmm1, %xmm2
pand %xmm2, %xmm0
pmovmskb %xmm0, %eax
xorl %ecx, %ecx
cmpl $0xffff, %eax           # imm = 0xFFFF
movl $0xffffffea, %r15d      # imm = 0xFFFFFFEA
cmovel %ecx, %r15d
testl %r15d, %r15d
js 0x296b
movq (%rbx), %rdi
leaq 0xba(%rip), %rcx        # 0x2999
movl $0x1, %esi
movq %rbx, %rdx
callq 0x3d60
testq %rax, %rax
je 0x2991
movq %rax, %r12
leaq 0x58b1(%rip), %rax      # 0x81b0
movq %rax, 0x28(%r12)
movq $0x1b, 0x30(%r12)
movq %r12, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r12)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x150(%r12)
movdqu %xmm0, 0x160(%r12)
movq %r12, %rdi
xorl %esi, %esi
callq *0x8(%rbx)
movl %ebp, %r15d
testl %eax, %eax
je 0x296b
movl %eax, %r13d
movq %r12, %rdi
callq 0x3df6
movl %r13d, %r15d
jmp 0x296b
movl %ebp, %r15d
jmp 0x296b
movl %eax, %r15d
movq %r14, %rdi
callq 0x3df6
testl %r15d, %r15d
jns 0x297f
movl $0x2, 0x28(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffff4, %r15d      # imm = 0xFFFFFFF4
jmp 0x296b
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/zmtp.c
// Function: on_greet_v3_3_hshake_send__REP
static int on_greet_v3_3_hshake_send__REP(struct io_req *req, int len)
{
	struct zmtp *zmtp = req->data;

	/*
	 * Our hshake is sent, ready for incoming data.
	 */
	io_req_put(req);

	if (len < 0)
		zmtp->inner_state = ZMTP_REP_CLOSED;

	return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x18(%rdi), %r14
callq 0x3df6
testl %ebx, %ebx
jns 0x29b4
movl $0x2, 0x28(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: buf_it_len
static int buf_it_len(struct io_buf *buf, struct iovec_iter *beg,
		      struct iovec_iter *end)
{
	size_t sz, nb;

	sz = 0;
	while (buf_it_cmp(beg, end) < 0) {
		nb = buf_it_iovlen(buf, beg, end);
		buf_it_advance(buf, beg, nb);
		sz += nb;
	}

	return sz;
}

// Assembly:
leaq 0x8(%rdx), %rcx
xorl %eax, %eax
movq (%rsi), %r8
movq (%rdx), %r9
cmpq %r9, %r8
jb 0x2a3b
ja 0x2aa1
movq 0x8(%rsi), %r10
cmpq 0x8(%rdx), %r10
jae 0x2aa1
cmpq %r9, %r8
jae 0x2a90
movq %r8, %r10
shlq $0x4, %r10
cmpq %r9, %r8
leaq 0x8(%rdi,%r10), %r9
cmoveq %rcx, %r9
movq (%r9), %r9
subq 0x8(%rsi), %r9
movq 0x8(%rsi), %r10
addq %r9, %r10
movq %r10, 0x8(%rsi)
movq 0x120(%rdi), %r11
decq %r11
cmpq %r11, %r8
je 0x2a8b
movq %r8, %r11
shlq $0x4, %r11
cmpq %r10, 0x8(%rdi,%r11)
jne 0x2a8b
movq $0x0, 0x8(%rsi)
incq %r8
movq %r8, (%rsi)
addq %r9, %rax
jmp 0x2a1f
ja 0x2a9c
movq 0x8(%rsi), %r10
cmpq 0x8(%rdx), %r10
jb 0x2a3b
xorl %r9d, %r9d
jmp 0x2a55
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: buf_check
static int buf_check(struct io_buf *buf)
{
	int i;
	struct iovec *iov;

	if (buf->iov_num == 0)
		return -EINVAL;
	if (buf->iov_num >= ARRAY_SIZE(buf->iov))
		return -EINVAL;
	for (i = 0; i < buf->iov_num - 1; i++) {
		/* Only last vari length element can be zero */
		if (!buf->iov[i].iov_len)
			return -EINVAL;
	}
	iov = &buf->iov[buf->iov_num - 1];
	/* Last, not vari length iov must be with valid length */
	if (!buf_vari_len(buf) && !iov->iov_len)
		return -EINVAL;
	/* Last, vari length iov must be fully zeroed or fully alloc'ed */
	if (buf_vari_len(buf) && (!!iov->iov_len ^ !!iov->iov_base))
		return -EINVAL;
	if (buf->pos.iov_ind > buf->iov_num)
		return -EINVAL;
	iov = &buf->iov[buf->pos.iov_ind];
	if (iov->iov_base == NULL && buf->pos.iov_off)
		return -EINVAL;
	if (iov->iov_len && buf->pos.iov_off > iov->iov_len) {
		assert(0);
		return -EINVAL;
	}

	return 0;
}

// Assembly:
pushq %rax
movq 0x120(%rdi), %rcx
leaq -0x10(%rcx), %rdx
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
cmpq $-0xf, %rdx
jae 0x305e
popq %rcx
retq
movq %rcx, %rdx
decq %rdx
je 0x307c
leaq 0x8(%rdi), %rsi
movq %rdx, %r8
cmpq $0x0, (%rsi)
je 0x305c
addq $0x10, %rsi
decq %r8
jne 0x306d
shlq $0x4, %rdx
addq %rdi, %rdx
movb 0x128(%rdi), %sil
testb %sil, %sil
jne 0x309b
cmpq $0x0, 0x8(%rdx)
je 0x305c
testb %sil, %sil
je 0x30b0
cmpq $0x0, 0x8(%rdx)
setne %sil
cmpq $0x0, (%rdx)
setne %dl
xorb %sil, %dl
jne 0x305c
movq 0x100(%rdi), %rdx
cmpq %rcx, %rdx
ja 0x305c
shlq $0x4, %rdx
cmpq $0x0, (%rdi,%rdx)
je 0x3101
addq %rdi, %rdx
movq 0x8(%rdx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x305c
cmpq %rcx, 0x108(%rdi)
jbe 0x305c
leaq 0x2562(%rip), %rdi      # 0x564b
leaq 0x23a2(%rip), %rsi      # 0x5492
leaq 0x24ca(%rip), %rcx      # 0x55c1
movl $0x114, %edx            # imm = 0x114
callq 0x10d0
cmpq $0x0, 0x108(%rdi)
jne 0x305c
jmp 0x30c7
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: io_queue_deinit
void io_queue_deinit(struct io_queue *q)
{
	stash_free(q);
	assert(q->poller == NULL);
	assert(list_empty(&q->queue));
	assert(q->reqs_num[REQ_RD] == 0);
	assert(q->reqs_num[REQ_WR] == 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x158(%rdi), %rdi
callq 0x1040
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq $0x0, 0x168(%rbx)
cmpq $0x0, (%rbx)
jne 0x3187
leaq 0x138(%rbx), %rax
cmpq %rax, 0x138(%rbx)
jne 0x31a6
cmpl $0x0, 0x148(%rbx)
jne 0x31c5
cmpl $0x0, 0x14c(%rbx)
jne 0x31e4
popq %rbx
retq
leaq 0x22f2(%rip), %rdi      # 0x5480
leaq 0x22fd(%rip), %rsi      # 0x5492
leaq 0x22fb(%rip), %rcx      # 0x5497
movl $0x313, %edx            # imm = 0x313
callq 0x10d0
leaq 0x2312(%rip), %rdi      # 0x54bf
leaq 0x22de(%rip), %rsi      # 0x5492
leaq 0x22dc(%rip), %rcx      # 0x5497
movl $0x314, %edx            # imm = 0x314
callq 0x10d0
leaq 0x2309(%rip), %rdi      # 0x54d5
leaq 0x22bf(%rip), %rsi      # 0x5492
leaq 0x22bd(%rip), %rcx      # 0x5497
movl $0x315, %edx            # imm = 0x315
callq 0x10d0
leaq 0x2303(%rip), %rdi      # 0x54ee
leaq 0x22a0(%rip), %rsi      # 0x5492
leaq 0x229e(%rip), %rcx      # 0x5497
movl $0x316, %edx            # imm = 0x316
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: io_queue_bind
int io_queue_bind(struct io_queue *q, void *poller, int fd)
{
	int err, flags;

	if (q->poller)
		return -EINVAL;
	q->refs = 1;
	q->poller = poller;
	q->item = (struct poller_item){
		.fd     = fd,
		.events = 0,
		.data   = NULL,
		.action = on_io,
	};

	flags = fcntl(fd, F_GETFL, 0);
	if  (flags < 0)
		return -errno;
	err = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
	if (err < 0)
		return -errno;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
cmpq $0x0, (%rdi)
jne 0x327d
movl %edx, %ebp
movq %rdi, %r14
movl $0x1, 0x174(%rdi)
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
addq $0xc, %rdi
xorl %ebx, %ebx
movl $0x124, %edx            # imm = 0x124
xorl %esi, %esi
callq 0x10e0
leaq 0x44(%rip), %rax        # 0x3284
movq %rax, 0x130(%r14)
movl %ebp, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1090
testl %eax, %eax
js 0x3274
orl $0x800, %eax            # imm = 0x800
movl %ebp, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x1090
testl %eax, %eax
jns 0x327d
callq 0x1050
xorl %ebx, %ebx
subl (%rax), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: io_queue_unbind
int io_queue_unbind(struct io_queue *q)
{
	int err;

	if (q->poller == NULL)
		return -EINVAL;
	if (q->refs == 0)
		return -EINVAL;
	if (q->refs > 1)
		return -EBUSY;

	err = __io_queue_cancel(q, -EIO);
	q->poller = NULL;
	q->refs = 0;

	return err;
}

// Assembly:
pushq %rbx
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
cmpq $0x0, (%rdi)
je 0x39f5
movq %rdi, %rbx
movl 0x174(%rdi), %ecx
testl %ecx, %ecx
je 0x39f5
movl $0xfffffff0, %eax       # imm = 0xFFFFFFF0
cmpl $0x1, %ecx
jg 0x39f5
movq %rbx, %rdi
movl $0xfffffffb, %esi       # imm = 0xFFFFFFFB
callq 0x39f7
movq $0x0, (%rbx)
movl $0x0, 0x174(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: _io_queue_submit
static int __io_queue_submit(struct io_req *req, bool tail)
{
	struct io_queue *q = req->q;
	int rc, wr;

	if (q->poller == NULL)
		return -EINVAL;
	rc = req_check(req);
	if (rc)
		return -EINVAL;

	if (!q->in_proto && q->proto && q->proto->on_submit) {
		/* Forward request to proto if any */
		rc = q->proto->on_submit(q->proto, req);
		if (rc)
			return rc;
	}
	wr = req->flags & REQ_RDWR_MASK;
	/*
	 * Firstly add request to the list (either to the head or to the tail)
	 * to simplify __poller_update() and _poller_set_prewait() logic, which
	 * simply picks up first request from the queue and updates poller events
	 * accordingly.
	 */
	if (tail)
		list_add_tail(&req->list, &q->queue);
	else
		list_add(&req->list, &q->queue);

	if (q->refs == 1) {
		if (!wr && is_stashed(q))
			/*
			 * We do submission outside the IO loop, but read can
			 * be completed right now from a stash, thus set prewait
			 * for an event to be called just before poller wait and
			 * then return to on_io.
			 */
			rc = __poller_set_prewait(q->poller, &q->item);

		if (rc == 0)
			rc = __poller_update(q);
	}
	if (rc)
		/* Rollback in case of error */
		list_del_init(&req->list);
	else
		/* Success, account added request */
		q->reqs_num[wr]++;

	return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %r14
movl $0xffffffea, %ebp       # imm = 0xFFFFFFEA
cmpq $0x0, (%r14)
je 0x3ae3
movl %esi, %r15d
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x3045
testl %eax, %eax
je 0x3aee
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, 0x20(%rbx)
je 0x3afd
cmpb $0x0, 0x150(%rbx)
jne 0x3ae3
cmpb $0x0, 0x170(%r14)
jne 0x3b27
movq 0x150(%r14), %rdi
testq %rdi, %rdi
je 0x3b27
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3b27
movq %rbx, %rsi
callq *%rax
movl %eax, %ebp
testl %eax, %eax
jne 0x3ae3
movl 0x20(%rbx), %r12d
andl $0x1, %r12d
leaq 0x138(%r14), %rax
testb %r15b, %r15b
je 0x3b4e
leaq 0x140(%r14), %rcx
movq %rax, %rdx
movq 0x140(%r14), %rax
jmp 0x3b55
movq (%rax), %rdx
leaq 0x8(%rdx), %rcx
movq %rbx, (%rcx)
movq %rdx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, (%rax)
xorl %ebp, %ebp
cmpl $0x1, 0x174(%r14)
jne 0x3b83
xorl %ebp, %ebp
testl %r12d, %r12d
je 0x3bae
testl %ebp, %ebp
jne 0x3b83
movq %r14, %rdi
callq 0x3ec2
movl %eax, %ebp
testl %ebp, %ebp
je 0x3ba1
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %rbx, (%rbx)
movq %rbx, 0x8(%rbx)
jmp 0x3ae3
incl 0x148(%r14,%r12,4)
jmp 0x3ae3
cmpq $0x0, 0x160(%r14)
je 0x3b75
movq 0x138(%r14), %rax
leaq 0x138(%r14), %rcx
cmpq %rcx, %rax
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x3b75
testb $0x1, 0x20(%rax)
jne 0x3b75
movq (%r14), %rdi
leaq 0x8(%r14), %rsi
leaq 0x660(%rip), %rax       # 0x424a
movq %rax, 0x128(%r14)
callq 0x43e5
movl %eax, %ebp
jmp 0x3b75
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: io_queue_set_proto
int io_queue_set_proto(struct io_queue *q, struct io_proto *proto)
{
	if (proto) {
		if (q->proto)
			return -EINVAL;
		proto->q = q;
		proto->submit = __io_queue_submit_from_proto;
		q->proto = proto;
	} else {
		if (q->proto == NULL)
			return -EINVAL;
		q->proto->q = NULL;
		q->proto->submit = NULL;
		q->proto = NULL;
	}

	return 0;
}

// Assembly:
movq 0x150(%rdi), %rcx
testq %rsi, %rsi
je 0x3c2a
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
testq %rcx, %rcx
je 0x3c39
retq
testq %rcx, %rcx
je 0x3c51
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
xorl %esi, %esi
jmp 0x3c47
movq %rdi, (%rsi)
leaq 0x14(%rip), %rax        # 0x3c57
movq %rax, 0x8(%rsi)
movq %rsi, 0x150(%rdi)
xorl %eax, %eax
retq
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: io_req_put
bool io_req_put(struct io_req *req)
{
	int refs;

	assert(req->refs > 0);
	refs = --req->refs;
	if (!refs) {
		__io_req_deinit(req);
		free(req);
	}

	return !refs;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x24(%rdi), %ebp
testl %ebp, %ebp
jle 0x3e26
movq %rdi, %rbx
decl %ebp
movl %ebp, 0x24(%rdi)
jne 0x3e1a
movq %rbx, %rdi
callq 0x3ce2
movq %rbx, %rdi
callq 0x1040
testl %ebp, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1744(%rip), %rdi      # 0x5571
leaq 0x165e(%rip), %rsi      # 0x5492
leaq 0x1765(%rip), %rcx      # 0x55a0
movl $0x3f3, %edx            # imm = 0x3F3
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: buf_it_realloc
static int buf_it_realloc(struct io_buf *buf, struct iovec_iter *it, size_t sz)
{
	struct iovec *iov;
	void *tmp;

	/*
	 * Here we come because of two reasons:
	 *   1. !iov_len, !iov_base,  is_vari_len
	 *   2.  iov_len, !iov_base, !is_vari_len
	 *
	 * For 1 we reallocate the iov_len + sz.
	 * For 2 we allocate what is set in iov_len.
	 */

	iov = buf_it_iov(buf, it);
	if (buf_it_vari_len_tail(buf, it))
		sz += iov->iov_len;
	else
		sz  = iov->iov_len;

	tmp = realloc(iov->iov_base, sz);
	if (tmp == NULL)
		return -ENOMEM;
	iov->iov_base = tmp;
	buf->iov_free[it->iov_ind] = true;
	iov->iov_len = sz;

	return sz;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, %r12
shlq $0x4, %r12
addq %rdi, %r12
cmpb $0x1, 0x128(%rdi)
jne 0x3e82
movq 0x120(%r14), %rcx
decq %rcx
cmpq %rcx, %rax
jne 0x3e82
movq %rdx, %rbx
addq 0x8(%r12), %rbx
jmp 0x3e87
movq 0x8(%r12), %rbx
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x11b0
testq %rax, %rax
je 0x3eaf
movq %rax, (%r12)
movq (%r15), %rax
movb $0x1, 0x110(%r14,%rax)
movq %rbx, 0x8(%r12)
jmp 0x3eb4
movl $0xfffffff4, %ebx       # imm = 0xFFFFFFF4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: buf_advance
static size_t buf_advance(struct io_buf *buf, struct iovec_iter *it,
			  size_t sz)
{
	size_t nb;
	struct iovec_iter end = END_IT(buf);

	while (buf_it_cmp(it, &end) < 0 && sz) {
		nb = min(sz, buf_it_iovlen(buf, it, &end));
		buf_it_advance(buf, it, nb);
		sz -= nb;
	}

	return sz;
}

// Assembly:
movq 0x120(%rdi), %rax
cmpb $0x0, 0x128(%rdi)
je 0x3f15
xorl %ecx, %ecx
jmp 0x3f24
decq %rax
movq %rax, %rcx
shlq $0x4, %rcx
movq 0x8(%rdi,%rcx), %rcx
movq (%rsi), %r8
movb $0x1, %r9b
cmpq %rax, %r8
jb 0x3f3e
jbe 0x3f36
xorl %r9d, %r9d
jmp 0x3f3e
cmpq %rcx, 0x8(%rsi)
setb %r9b
testb %r9b, %r9b
je 0x3fea
testq %rdx, %rdx
je 0x3fea
cmpq %rax, %r8
jae 0x3f6f
movq %rcx, %r10
cmpq %rax, %r8
je 0x3f69
movq %r8, %r9
shlq $0x4, %r9
movq 0x8(%rdi,%r9), %r10
subq 0x8(%rsi), %r10
jmp 0x3f7a
ja 0x3f77
cmpq %rcx, 0x8(%rsi)
jb 0x3f55
xorl %r10d, %r10d
movq %rdx, %r9
cmpq %r10, %rdx
jb 0x3fac
cmpq %rax, %r8
jae 0x3fa1
movq %rcx, %r9
cmpq %rax, %r8
je 0x3f9b
movq %r8, %r9
shlq $0x4, %r9
movq 0x8(%rdi,%r9), %r9
subq 0x8(%rsi), %r9
jmp 0x3fac
ja 0x3fa9
cmpq %rcx, 0x8(%rsi)
jb 0x3f87
xorl %r9d, %r9d
movq 0x8(%rsi), %r10
addq %r9, %r10
movq %r10, 0x8(%rsi)
movq 0x120(%rdi), %r11
decq %r11
cmpq %r11, %r8
je 0x3fe2
movq %r8, %r11
shlq $0x4, %r11
cmpq %r10, 0x8(%rdi,%r11)
jne 0x3fe2
movq $0x0, 0x8(%rsi)
incq %r8
movq %r8, (%rsi)
subq %r9, %rdx
jmp 0x3f27
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io.c
// Function: _poller_set
static int __poller_set(void *poller, struct poller_item *item, int new_events)
{
	int rc = 0, old_events = item->events;

	if (new_events ^ old_events) {
		item->events = new_events;
		if (old_events && new_events)
			rc = __poller_ctl(poller, P_CTL_MOD, item);
		else if (!old_events && new_events)
			rc = __poller_ctl(poller, P_CTL_ADD, item);
		else
			rc = __poller_ctl(poller, P_CTL_DEL, item);
	}

	return rc;
}

// Assembly:
movl 0x4(%rsi), %ecx
cmpl %edx, %ecx
je 0x4247
movq %rsi, %rax
movl %edx, 0x4(%rsi)
testl %ecx, %ecx
sete %sil
testl %edx, %edx
sete %r8b
orb %sil, %r8b
jne 0x4222
movl $0x1, %esi
jmp 0x4239
xorl %r8d, %r8d
testl %ecx, %ecx
setne %r8b
addl %r8d, %r8d
testl %edx, %edx
movl $0x2, %esi
cmovnel %r8d, %esi
cmpq $-0x1, %rdi
je 0x4247
movq %rax, %rdx
jmp 0x42ff
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/poller.c
// Function: poller_create
int poller_create(void **p)
{
	int rc;
	struct poller *poller;

	poller = malloc(sizeof(*poller));
	if (poller == NULL)
		return -ENOMEM;
	INIT_LIST_HEAD(&poller->prew_list);
	poller->epollfd = epoll_create1(0);
	if (poller->epollfd < 0) {
		rc = -errno;
		free(poller);

		return rc;
	}
	*p = poller;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x1180
testq %rax, %rax
je 0x429d
movq %rax, %rbx
addq $0x8, %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x11e0
movl %eax, (%rbx)
testl %eax, %eax
js 0x42a4
movq %rbx, (%r14)
jmp 0x42b5
movl $0xfffffff4, %ebp       # imm = 0xFFFFFFF4
jmp 0x42b5
callq 0x1050
xorl %ebp, %ebp
subl (%rax), %ebp
movq %rbx, %rdi
callq 0x1040
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/poller.c
// Function: poller_destroy
void poller_destroy(void *p)
{
	struct poller *poller = p;

	if (poller) {
		del_prewaits(poller);
		close(poller->epollfd);
		free(poller);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x42fe
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rdi
cmpq %r14, %rdi
je 0x42ea
movq (%rdi), %r15
addq $-0x10, %rdi
callq 0x4602
movq %r15, %rdi
cmpq %r14, %r15
jne 0x42d6
movl (%rbx), %edi
callq 0x1100
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/poller.c
// Function: poller_ctl
int poller_ctl(void *p, int op, struct poller_item *item)
{
	int rc, eop;
	struct poller *poller = p;
	struct epoll_event epollev;

	if (poller == NULL)
		return -EINVAL;
	eop = to_epoll_op(op);
	if (eop < 0)
		return eop;
	if (op == P_CTL_DEL || item->prewait == NULL)
		del_prewait(poller, item);

	epollev = (struct epoll_event){
		.events   = to_epoll_events(item->events),
		.data.ptr = item,
	};
	rc = epoll_ctl(poller->epollfd, eop, item->fd, &epollev);

	return (rc >= 0 ? rc : -errno);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4328
movq %rdx, %r14
movq %rdi, %r15
testl %esi, %esi
je 0x4336
cmpl $0x2, %esi
je 0x432f
cmpl $0x1, %esi
jne 0x433f
movl $0x3, %ebx
jmp 0x433b
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
jmp 0x43a3
movl $0x2, %ebx
jmp 0x433b
movl $0x1, %ebx
xorl %eax, %eax
jmp 0x4346
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
movb $0x1, %al
testb %al, %al
jne 0x43a3
cmpl $0x2, %esi
je 0x4359
cmpq $0x0, 0x120(%r14)
jne 0x4364
movq %r15, %rdi
movq %r14, %rsi
callq 0x43af
movl 0x4(%r14), %eax
movl %eax, %ecx
shrl %ecx
andl $0x1, %ecx
movl %eax, %edx
andl $0x4, %edx
orl %ecx, %edx
andl $0x1, %eax
leal (%rdx,%rax,8), %eax
leaq 0x4(%rsp), %rcx
movl %eax, (%rcx)
movq %r14, 0x4(%rcx)
movl (%r15), %edi
movl (%r14), %edx
movl %ebx, %esi
callq 0x1110
movl %eax, %ebx
testl %eax, %eax
jns 0x43a3
callq 0x1050
xorl %ebx, %ebx
subl (%rax), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/poller.c
// Function: del_prewait
static void del_prewait(struct poller *poller, struct poller_item *item)
{
	int i, prews_num = item->prews_num;
	struct prewait *prew;

	for (i = 0; i < ARRAY_SIZE(item->prews) && prews_num; i++) {
		prew = &item->prews[i];
		if (prew->poller)
			prews_num--;
		if (poller == prew->poller) {
			__del_prewait(prew);
			break;
		}
	}
}

// Assembly:
movl 0x18(%rsi), %eax
testl %eax, %eax
je 0x43dc
addq $0x20, %rsi
xorl %ecx, %ecx
movq (%rsi), %rdx
cmpq %rdi, %rdx
je 0x43dd
cmpq $0x1, %rdx
adcl $-0x1, %eax
cmpq $0x6, %rcx
ja 0x43dc
incq %rcx
addq $0x20, %rsi
testl %eax, %eax
jne 0x43bc
retq
movq %rsi, %rdi
jmp 0x4602
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/poller.c
// Function: poller_set_prewait
int poller_set_prewait(void *p, struct poller_item *item)
{
	int rc = 0;
	struct poller *poller = p;

	if (item->prewait == NULL)
		del_prewait(poller, item);
	else if (item->prewait) {
		/*
		 * Item with a prewait action is a special case:
		 * it can belong to a limit amount of pollers,
		 * thus we have to check and return an error if
		 * no buffers left.
		 */
		rc = add_prewait(poller, item);
	}

	return rc;
}

// Assembly:
pushq %rax
cmpq $0x0, 0x120(%rsi)
je 0x4486
movl 0x18(%rsi), %ecx
movl $0xffffff97, %eax       # imm = 0xFFFFFF97
cmpl $0x7, %ecx
ja 0x448d
movl $0x20, %r8d
xorl %eax, %eax
xorl %edx, %edx
movl %ecx, %r9d
movq (%rsi,%r8), %r10
cmpq %rdi, %r10
je 0x448d
testq %r10, %r10
je 0x442a
testl %r9d, %r9d
je 0x448f
decl %r9d
jmp 0x4435
leaq (%rsi,%r8), %r10
testq %rdx, %rdx
cmoveq %r10, %rdx
testl %r9d, %r9d
sete %r10b
testq %rdx, %rdx
setne %r11b
testb %r11b, %r10b
jne 0x4458
leaq 0x20(%r8), %r10
cmpq $0x100, %r8             # imm = 0x100
movq %r10, %r8
jne 0x4412
testq %rdx, %rdx
je 0x44ae
movq %rdi, (%rdx)
movq %rsi, 0x8(%rdx)
leaq 0x10(%rdx), %r8
leaq 0x8(%rdi), %r9
movq 0x10(%rdi), %r10
movq %r8, 0x10(%rdi)
movq %r9, 0x10(%rdx)
movq %r10, 0x18(%rdx)
movq %r8, (%r10)
incl %ecx
movl %ecx, 0x18(%rsi)
jmp 0x448d
callq 0x43af
xorl %eax, %eax
popq %rcx
retq
leaq 0x139b(%rip), %rdi      # 0x5831
leaq 0x139e(%rip), %rsi      # 0x583b
leaq 0x13c5(%rip), %rcx      # 0x5869
movl $0x51, %edx
callq 0x10d0
leaq 0x13eb(%rip), %rdi      # 0x58a0
leaq 0x137f(%rip), %rsi      # 0x583b
leaq 0x13a6(%rip), %rcx      # 0x5869
movl $0x59, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/poller.c
// Function: poller_wait
int poller_wait(void *p, struct poller_item **pitems, int num, int timeout)
{
	int rc, i;
	struct poller *poller = p;
	struct epoll_event epollevs[num];
	struct poller_item *item;

	if (poller == NULL)
		return -EINVAL;

	rc = call_prewaits(poller, pitems, num);
	if (rc)
		return rc;
	rc = epoll_wait(poller->epollfd, epollevs, num, tv_to_poll(timeout));
	if (rc > 0) {
		for (i = 0; i < rc; i++) {
			item = (struct poller_item *)epollevs[i].data.ptr;
			item->revents = from_epoll_events(epollevs[i].events);
			pitems[i] = item;
		}
	}

	return (rc >= 0 ? rc : -errno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %eax
movq %rsp, %r14
leaq (%rax,%rax,2), %rax
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
testq %rdi, %rdi
je 0x4562
movq %rdi, %r13
movl %ecx, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
xorl %r15d, %r15d
movl %edx, -0x2c(%rbp)
testl %edx, %edx
je 0x456d
leaq 0x8(%r13), %r12
movq 0x8(%r13), %rbx
cmpq %r12, %rbx
je 0x456d
xorl %r15d, %r15d
movq -0x8(%rbx), %rsi
movl $0x0, 0x8(%rsi)
movq %r13, %rdi
callq *0x120(%rsi)
testl %eax, %eax
jne 0x456a
movq -0x8(%rbx), %rax
cmpl $0x0, 0x8(%rax)
je 0x4558
movslq %r15d, %rcx
incl %r15d
movq -0x38(%rbp), %rdx
movq %rax, (%rdx,%rcx,8)
cmpl -0x2c(%rbp), %r15d
je 0x456d
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x4522
jmp 0x456d
movl $0xffffffea, %r15d      # imm = 0xFFFFFFEA
jmp 0x45e7
movl %eax, %r15d
testl %r15d, %r15d
jne 0x45e7
movl (%r13), %edi
movl -0x30(%rbp), %eax
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovnel %eax, %ecx
movq %r14, %rsi
movl -0x2c(%rbp), %edx
callq 0x11c0
movl %eax, %r15d
testl %eax, %eax
movq -0x38(%rbp), %r9
jle 0x45d7
movl %r15d, %eax
addq $0x4, %r14
xorl %ecx, %ecx
movq (%r14), %rdx
movl -0x4(%r14), %esi
movl %esi, %edi
andl $0x1, %edi
movl %esi, %r8d
andl $0x4, %r8d
leal (%r8,%rdi,2), %edi
shrl $0x3, %esi
andl $0x1, %esi
orl %edi, %esi
movl %esi, 0x8(%rdx)
movq %rdx, (%r9,%rcx,8)
incq %rcx
addq $0xc, %r14
cmpq %rcx, %rax
jne 0x45a5
testl %r15d, %r15d
jns 0x45e7
callq 0x1050
xorl %r15d, %r15d
subl (%rax), %r15d
movl %r15d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/poller.c
// Function: _del_prewait
static void __del_prewait(struct prewait *prew)
{
	assert(prew->item->prews_num);
	prew->item->prews_num -= 1;
	prew->poller = NULL;
	prew->item = NULL;
	list_del(&prew->list);
}

// Assembly:
movq 0x8(%rdi), %rax
movl 0x18(%rax), %ecx
testl %ecx, %ecx
je 0x4628
decl %ecx
movl %ecx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
retq
pushq %rax
leaq 0x11f5(%rip), %rdi      # 0x5825
leaq 0x1204(%rip), %rsi      # 0x583b
leaq 0x1206(%rip), %rcx      # 0x5844
movl $0x25, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/utils.c
// Function: dump_function
void dump_function(Function* func) {
  eprintf("%s ", func->name);
  eprintf("(");
  for (size_t i = 0; i < func->params->length; i++) {
    if (i != 0)
      eprintf(", ");
    dump_type(((Node*)func->params->ptr[i])->type);
    eprintf(" %s", ((Node*)func->params->ptr[i])->name);
  }
  eprintf(")\n");

  if (func->body)
    dump_node(func->body, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0xc4b6(%rip), %rdi      # 0xf38b
xorl %eax, %eax
callq 0x21b0
leaq 0xc96f(%rip), %rdi      # 0xf852
xorl %eax, %eax
callq 0x21b0
movq 0x18(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x2f59
leaq 0xc16d(%rip), %r14      # 0xf069
leaq 0xc936(%rip), %r15      # 0xf839
xorl %r12d, %r12d
testq %r12, %r12
je 0x2f15
movq %r15, %rdi
xorl %eax, %eax
callq 0x21b0
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %rdi
callq 0xdadf
movq %rax, %rdi
xorl %eax, %eax
callq 0x21b0
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r12,8), %rax
movq 0x40(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x21b0
incq %r12
movq 0x18(%rbx), %rax
cmpq 0x10(%rax), %r12
jb 0x2f06
leaq 0xc8ca(%rip), %rdi      # 0xf82a
xorl %eax, %eax
callq 0x21b0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0x2f7c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x1
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2259
nop
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/containers.c
// Function: new_vec
Vector* new_vec() {
  Vector* v = calloc(1, sizeof(Vector));
  v->ptr = calloc(16, sizeof(void*));
  v->capacity = 16;
  v->length = 0;
  return v;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x20f0
movq %rax, %rbx
movl $0x10, %edi
movl $0x8, %esi
callq 0x20f0
movq %rax, (%rbx)
movq $0x10, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/containers.c
// Function: vec_push
void vec_push(Vector* v, void* elem) {
  if (v->capacity == v->length) {
    v->capacity *= 2;
    v->ptr = realloc(v->ptr, sizeof(void*) * v->capacity);
  }
  v->ptr[v->length++] = elem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
jne 0x30e1
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x2140
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: preprocess
Token* preprocess(char* dir, Token* tokens) {
  gbl_env = calloc(1, sizeof(MacroEnv));
  gbl_env->name = "__hoc__";
  input = tokens;
  src_dir = dir;

  while (input) {
    traverse();
  }

  return output;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movq %rax, 0xffa8(%rip)      # 0x130e8
leaq 0xaebd(%rip), %rcx      # 0xe004
movq %rcx, 0x8(%rax)
movq %rbx, 0xff9e(%rip)      # 0x130f0
movq %r14, 0xff9f(%rip)      # 0x130f8
testq %rbx, %rbx
je 0x316d
callq 0x317c
cmpq $0x0, 0xff85(%rip)      # 0x130f0
jne 0x315e
movq 0xff8c(%rip), %rax      # 0x13100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: expect
static Token* expect(char* expected, enum TokenTag tag) {
  if (input->tag != tag) {
    pp_error(expected, input);
    return NULL;
  } else {
    Token* ret = input;
    consume();
    return ret;
  }
}

// Assembly:
pushq %rbx
movq 0xf8e9(%rip), %rbx      # 0x130f0
cmpl $0x2, 0x8(%rbx)
jne 0x3821
testq %rbx, %rbx
je 0x381c
movq (%rbx), %rax
movq %rax, 0xf8d4(%rip)      # 0x130f0
movq %rbx, %rax
popq %rbx
retq
movq %rdi, %rsi
leaq 0xa825(%rip), %rdi      # 0xe050
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: is_macro
static bool is_macro(Token* token) {
  if (token->tag == TIDENT) {
    for (MacroEnv* env = gbl_env; env != NULL; env = env->next) {
      if (streq(token->ident, env->name)) {
        return true;
      }
    }
  }
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, 0x8(%rdi)
jne 0x3871
movq %rdi, %rbx
leaq 0xf897(%rip), %r14      # 0x130e8
movq (%r14), %r14
testq %r14, %r14
je 0x3871
movq 0x10(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0xd952
testl %eax, %eax
je 0x3851
movb $0x1, %al
testq %r14, %r14
jne 0x3873
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: read_until_bol
static Token* read_until_bol(void) {
  if (input->bol) {
    return NULL;
  } else {
    Token* new = copy_token(input);
    consume();
    new->next = read_until_bol();
    return new;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xf806(%rip), %r14      # 0x130f0
cmpb $0x0, 0x30(%r14)
je 0x38f5
xorl %ebx, %ebx
jmp 0x3946
movl $0x1, %edi
movl $0x38, %esi
callq 0x20f0
movq %rax, %rbx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq $0x0, (%rbx)
testq %r14, %r14
je 0x393e
movq (%r14), %rax
movq %rax, 0xf7b2(%rip)      # 0x130f0
callq 0x38df
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: get_macro_tokens
static Token* get_macro_tokens(char* name) {
  for (MacroEnv* env = gbl_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      return copy_tokens(env->tokens);
    }
  }
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xf789(%rip), %r14      # 0x130e8
movq (%r14), %r14
testq %r14, %r14
je 0x3984
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xd952
testl %eax, %eax
je 0x395f
movq 0x10(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x398e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: copy_tokens
static Token* copy_tokens(Token* src) {
  if (src == NULL) {
    return NULL;
  } else {
    Token* new = copy_token(src);
    new->next = copy_tokens(src->next);
    return new;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x39e1
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x20f0
movq %rax, %rbx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq $0x0, (%rbx)
movq (%r14), %rdi
callq 0x398e
movq %rax, (%rbx)
jmp 0x39e3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_const
static void emit_const(Type* type, Node* node) {
  if (!node) {
    return;
  }

  switch (node->tag) {
  case NINT: {
    if (size_of(type) == 1) {
      emit(".byte %d", node->integer);
    } else if (size_of(type) == 4) {
      emit(".int %d", node->integer);
    } else if (size_of(type) == 8) {
      emit(".quad %d", node->integer);
    } else {
      bad_token(node->token, "emit error: emit_const(invalid size)");
    }
    break;
  }
  case NGVAR: {
    if (size_of(type) == 1) {
      emit(".byte %s", node->name);
    } else if (size_of(type) == 4) {
      emit(".int %s", node->name);
    } else if (size_of(type) == 8) {
      emit(".quad %s", node->name);
    } else {
      bad_token(node->token, "emit error: emit_const(invalid size)");
    }
    break;
  }
  default:
    bad_token(node->token, "emit error: value is not constant");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3dfe
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x3e06
testl %eax, %eax
jne 0x3e9d
movq %r14, %rdi
callq 0x9c8c
cmpq $0x1, %rax
jne 0x3e3c
movl 0x28(%rbx), %esi
leaq 0xa375(%rip), %rdi      # 0xe16e
jmp 0x3e92
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x9c8c
cmpq $0x1, %rax
jne 0x3e21
movq 0x40(%rbx), %rsi
leaq 0xa38e(%rip), %rdi      # 0xe1ad
jmp 0x3e6f
movq %r14, %rdi
callq 0x9c8c
cmpq $0x4, %rax
jne 0x3e56
movq 0x40(%rbx), %rsi
leaq 0xa37c(%rip), %rdi      # 0xe1b6
jmp 0x3e6f
movq %r14, %rdi
callq 0x9c8c
cmpq $0x4, %rax
jne 0x3e7a
movl 0x28(%rbx), %esi
leaq 0xa323(%rip), %rdi      # 0xe177
jmp 0x3e92
movq %r14, %rdi
callq 0x9c8c
cmpq $0x8, %rax
jne 0x3ead
movq 0x40(%rbx), %rsi
leaq 0xa34f(%rip), %rdi      # 0xe1be
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ebd
movq %r14, %rdi
callq 0x9c8c
cmpq $0x8, %rax
jne 0x3ead
movl 0x28(%rbx), %esi
leaq 0xa2ed(%rip), %rdi      # 0xe17f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ebd
movq 0x8(%rbx), %rdi
leaq 0xa31f(%rip), %rsi      # 0xe1c7
callq 0xce4d
movq 0x8(%rbx), %rdi
leaq 0xa2d0(%rip), %rsi      # 0xe188
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit
static void emit(char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  printf("\t");
  vprintf(fmt, ap);
  printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x3f1e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movl $0x9, %edi
callq 0x2040
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movl $0xa, %edi
callq 0x2040
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_var
static void emit_var(Node* var) {
  comment("start lval NVAR %s", var->name);
  emit("lea rax, -%zu[rbp]", var->offset);
  push(AX);
  comment("end lval NVAR %s", var->name);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rsi
leaq 0xa370(%rip), %rdi      # 0xe396
xorl %eax, %eax
callq 0x3f68
movq 0x48(%rbx), %rsi
leaq 0xa371(%rip), %rdi      # 0xe3a9
xorl %eax, %eax
callq 0x3ebd
leaq 0xa387(%rip), %rdi      # 0xe3cd
leaq 0xa5aa(%rip), %rsi      # 0xe5f7
xorl %eax, %eax
callq 0x20a0
movq 0x40(%rbx), %rsi
leaq 0xa35d(%rip), %rdi      # 0xe3bc
xorl %eax, %eax
popq %rbx
jmp 0x3f68
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_lval
static void emit_lval(Node* node) {
  if (node->tag == NVAR) {
    emit_var(node);
  } else if (node->tag == NGVAR) {
    comment("start lval NGVAR");
    emit("lea rax, %s", node->name);
    push(AX);
    comment("end lval NGVAR");
  } else if (node->tag == NMEMBER) {
    comment("start lval NMEMBER");
    emit_lval(node->expr);
    size_t offset = field_offset(type_of(node->expr)->fields, node->name);
    pop(AX);
    emit("lea rax, %zu[rax]", offset);
    push(AX);
    comment("end lval NMEMBER");
  } else if (node->tag == NDEREF){
    comment("start lval NDEREF");
    emit_node(node->expr);
    comment("end lval NDEREF");
  } else {
    bad_token(node->token, "emit error: emit_lval");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x19, %eax
jg 0x5b86
cmpl $0x1, %eax
je 0x5c0b
cmpl $0x2, %eax
jne 0x5c46
leaq 0x8d9a(%rip), %rdi      # 0xe8e6
xorl %eax, %eax
callq 0x3f68
movq 0x40(%rbx), %rsi
leaq 0x8d99(%rip), %rdi      # 0xe8f7
xorl %eax, %eax
callq 0x3ebd
leaq 0x8861(%rip), %rdi      # 0xe3cd
leaq 0x8a84(%rip), %rsi      # 0xe5f7
xorl %eax, %eax
callq 0x20a0
leaq 0x8d82(%rip), %rdi      # 0xe903
jmp 0x5c38
cmpl $0x1a, %eax
je 0x5c1a
cmpl $0x1b, %eax
jne 0x5c46
leaq 0x8d73(%rip), %rdi      # 0xe912
xorl %eax, %eax
callq 0x3f68
movq 0x38(%rbx), %rdi
callq 0x5b25
movq 0x38(%rbx), %rdi
callq 0x9e0f
movq 0x30(%rax), %rdi
movq 0x40(%rbx), %rsi
callq 0x9efb
movq %rax, %rbx
leaq 0x8db1(%rip), %rdi      # 0xe980
leaq 0x8a21(%rip), %r14      # 0xe5f7
movq %r14, %rsi
xorl %eax, %eax
callq 0x20a0
leaq 0x8d3e(%rip), %rdi      # 0xe925
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3ebd
leaq 0x87d5(%rip), %rdi      # 0xe3cd
movq %r14, %rsi
xorl %eax, %eax
callq 0x20a0
leaq 0x8d2e(%rip), %rdi      # 0xe937
jmp 0x5c38
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4017
leaq 0x8d27(%rip), %rdi      # 0xe948
xorl %eax, %eax
callq 0x3f68
movq 0x38(%rbx), %rdi
callq 0x4067
leaq 0x8d22(%rip), %rdi      # 0xe95a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3f68
movq 0x8(%rbx), %rdi
leaq 0x8d19(%rip), %rsi      # 0xe96a
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_assign
static void emit_assign(Node* lhs, Node* rhs) {
  comment("  start lval");
  emit_lval(lhs);
  comment("  end lval");
  emit_node(rhs);
  pop(DI);
  pop(AX);
  store(DI, size_of(type_of(lhs)));
  push(DI);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8ce2(%rip), %rdi      # 0xe9b0
xorl %eax, %eax
callq 0x3f68
movq %r14, %rdi
callq 0x5b25
leaq 0x8cd9(%rip), %rdi      # 0xe9bd
xorl %eax, %eax
callq 0x3f68
movq %rbx, %rdi
callq 0x4067
leaq 0x8c86(%rip), %r15      # 0xe980
leaq 0x856c(%rip), %rbx      # 0xe26d
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20a0
leaq 0x88e2(%rip), %rsi      # 0xe5f7
movq %r15, %rdi
xorl %eax, %eax
callq 0x20a0
movq %r14, %rdi
callq 0x9e0f
movq %rax, %rdi
callq 0x9c8c
cmpq $0x4, %rax
leaq 0x86cf(%rip), %rcx      # 0xe409
cmovneq %rbx, %rcx
cmpq $0x1, %rax
leaq 0x869c(%rip), %rsi      # 0xe3e5
cmovneq %rcx, %rsi
leaq 0x8683(%rip), %rdi      # 0xe3d7
xorl %eax, %eax
callq 0x3ebd
leaq 0x866b(%rip), %rdi      # 0xe3cd
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x20a0
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_builtin_va_start
static void emit_builtin_va_start(Node* node) {
  align_rsp();
  emit_node(node);
  pop(AX); // address of va_list
  push(CX); // save register
  emit("mov DWORD PTR [rax], %d", numgp * 8);
  emit("mov DWORD PTR [rax + 4], 48");
  emit("lea rcx, [rbp - %d]", REGAREA_SIZE);
  emit("mov [rax + 16], rcx");
  pop(CX); // load register
  revert_rsp();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5e11
movq %rbx, %rdi
callq 0x4067
leaq 0x8bf4(%rip), %rbx      # 0xe980
leaq 0x8864(%rip), %rsi      # 0xe5f7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20a0
leaq 0x8629(%rip), %rdi      # 0xe3cd
leaq 0x84fd(%rip), %r14      # 0xe2a8
movq %r14, %rsi
xorl %eax, %eax
callq 0x20a0
movl 0xd359(%rip), %esi      # 0x13114
shll $0x3, %esi
leaq 0x8c03(%rip), %rdi      # 0xe9c8
xorl %eax, %eax
callq 0x3ebd
leaq 0x8c0d(%rip), %rdi      # 0xe9e0
xorl %eax, %eax
callq 0x3ebd
leaq 0x8c1b(%rip), %rdi      # 0xe9fc
movl $0xb0, %esi
xorl %eax, %eax
callq 0x3ebd
leaq 0x8c1c(%rip), %rdi      # 0xea10
xorl %eax, %eax
callq 0x3ebd
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x20a0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5e4b
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/emit.c
// Function: align_rsp
static void align_rsp(void) {
  comment("start align rsp");
  emit("mov r10, rsp");
  emit("and rsp, -16"); // 下位4bit(16で割ったあまり)を切り捨て
  comment("end align rsp");
}

// Assembly:
pushq %rax
leaq 0x8c0b(%rip), %rdi      # 0xea24
xorl %eax, %eax
callq 0x3f68
leaq 0x8c0d(%rip), %rdi      # 0xea34
xorl %eax, %eax
callq 0x3ebd
leaq 0x8c0c(%rip), %rdi      # 0xea41
xorl %eax, %eax
callq 0x3ebd
leaq 0x8c0b(%rip), %rdi      # 0xea4e
xorl %eax, %eax
popq %rcx
jmp 0x3f68
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: is_defined_proto
IFunc* is_defined_proto(Vector* funcs, char* name) {
  for (size_t i = 0; i < funcs->length; i++) {
    IFunc* func = funcs->ptr[i];
    if (streq(func->name, name) && !func->blocks) {
      return func;
    }
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x5ec5
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax,%r12,8), %r13
movq (%r13), %rdi
movq %rbx, %rsi
callq 0xd952
testl %eax, %eax
je 0x5eaf
cmpq $0x0, 0x18(%r13)
je 0x5eb3
movb $0x1, %al
jmp 0x5eb8
xorl %eax, %eax
movq %r13, %r15
testb %al, %al
je 0x5ec8
incq %r12
cmpq 0x10(%r14), %r12
jb 0x5e91
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: emit_lval
static IReg* emit_lval(Node* node) {
  switch (node->tag) {
  case NVAR: {
    IReg* addr = new_reg(8);
    emit_ir(address(addr, node->offset));
    return addr;
  }
  case NGVAR: {
    IReg* addr = new_reg(8);
    emit_ir(label(addr, node->name));
    return addr;
  }
  case NMEMBER: {
    IReg* addr = emit_lval(node->expr);
    IReg* offset = new_reg(8);
    emit_ir(imm(offset, field_offset(type_of(node->expr)->fields, node->name)));
    IReg* reg = new_reg(8);
    emit_ir(new_binop_ir(IADD, reg, addr, offset));
    return reg;
  }
  case NDEREF: {
    return emit_expr(node->expr);
  }
  default: {
    bad_token(node->token, "gen_ir error: emit_lval");
  }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x19, %eax
jg 0x7aa4
cmpl $0x1, %eax
je 0x7b79
cmpl $0x2, %eax
jne 0x7bec
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movq %rax, %r14
movl 0xb6cf(%rip), %eax      # 0x13138
leal 0x1(%rax), %ecx
movl %ecx, 0xb6c6(%rip)      # 0x13138
movl %eax, 0x4(%r14)
movq $0x8, 0x8(%r14)
movq 0x40(%rbx), %rbx
movl $0x1, %edi
movl $0x58, %esi
callq 0x20f0
movl $0x1, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x28(%rax)
jmp 0x7bba
cmpl $0x1a, %eax
je 0x7bda
cmpl $0x1b, %eax
jne 0x7bec
movq 0x38(%rbx), %rdi
callq 0x7a2c
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movq %rax, %r12
movl 0xb65e(%rip), %eax      # 0x13138
leal 0x1(%rax), %ecx
movl %ecx, 0xb655(%rip)      # 0x13138
movl %eax, 0x4(%r12)
movl $0x8, %r13d
movq %r13, 0x8(%r12)
movq 0x38(%rbx), %rdi
callq 0x9e0f
movq 0x30(%rax), %rdi
movq 0x40(%rbx), %rsi
callq 0x9efb
movq %rax, %rbx
movl $0x1, %edi
movl $0x58, %esi
callq 0x20f0
movl $0x0, (%rax)
movq %r12, 0x10(%rax)
movl %ebx, 0x4(%rax)
movq 0xb601(%rip), %rcx      # 0x13130
movq 0x8(%rcx), %rdi
movq %rax, %rsi
callq 0x30b6
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movq %rax, %r14
movl 0xb5e5(%rip), %eax      # 0x13138
leal 0x1(%rax), %ecx
movl %ecx, 0xb5dc(%rip)      # 0x13138
movl %eax, 0x4(%r14)
movq %r13, 0x8(%r14)
movl $0x2, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x8cc6
jmp 0x7bba
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movq %rax, %r14
movl 0xb5a7(%rip), %eax      # 0x13138
leal 0x1(%rax), %ecx
movl %ecx, 0xb59e(%rip)      # 0x13138
movl %eax, 0x4(%r14)
movq $0x8, 0x8(%r14)
movl 0x48(%rbx), %ebx
movl $0x11, %edi
callq 0x8cb0
movq %r14, 0x10(%rax)
movl %ebx, 0x4(%rax)
movq 0xb56f(%rip), %rcx      # 0x13130
movq 0x8(%rcx), %rdi
movq %rax, %rsi
callq 0x30b6
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x38(%rbx), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6a99
movq 0x8(%rbx), %rdi
leaq 0x70dc(%rip), %rsi      # 0xecd3
callq 0xce4d