LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/xbs_socket.cpp
// Function: beyondy::XbsClient(char const*, int, long)
int XbsClient(const char *address, int flags, long timedout)
{
	struct sockaddr_storage addr_buf;
	socklen_t addr_len = sizeof(addr_buf);
	int type;
	int fd;

	if (str2sockaddr(address, &type, (struct sockaddr *)&addr_buf, &addr_len, 1) < 1) goto error_out;
	if ((fd = XbsSocket(addr_buf.ss_family, type, 0)) < 0) goto error_out;
	if (flags && XbsSetFlags(fd, flags, 0) < 0) goto error_close;
	if (XbsConnect(fd, (struct sockaddr *)&addr_buf, addr_len, timedout) < 0) goto error_close;
	return fd;
error_close:
	close(fd);
error_out:
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movl %esi, %ebp
leaq 0x4(%rsp), %rcx
movl $0x80, (%rcx)
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movl $0x1, %r8d
callq 0x9210
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x7bdd
movzwl 0x8(%rsp), %edi
movl (%rsp), %esi
xorl %edx, %edx
callq 0x30b0
testl %eax, %eax
js 0x7bdd
movl %eax, %r15d
testl %ebp, %ebp
je 0x7bb8
movl %r15d, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x31d0
orl %eax, %ebp
movl %r15d, %edi
movl $0x4, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x31d0
testl %eax, %eax
js 0x7bd5
movl 0x4(%rsp), %edx
leaq 0x8(%rsp), %rsi
movl %r15d, %edi
movq %r14, %rcx
callq 0x7637
testl %eax, %eax
js 0x7bd5
movl %r15d, %ebx
jmp 0x7bdd
movl %r15d, %edi
callq 0x3630
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/rbtree.c
// Function: rb_insert_color
void rb_insert_color(struct rb_node *node, struct rb_root *root)
{
	struct rb_node *parent, *gparent;

	while ((parent = rb_parent(node)) && rb_is_red(parent))
	{
		gparent = rb_parent(parent);

		if (parent == gparent->rb_left)
		{
			{
				register struct rb_node *uncle = gparent->rb_right;
				if (uncle && rb_is_red(uncle))
				{
					rb_set_black(uncle);
					rb_set_black(parent);
					rb_set_red(gparent);
					node = gparent;
					continue;
				}
			}

			if (parent->rb_right == node)
			{
				register struct rb_node *tmp;
				__rb_rotate_left(parent, root);
				tmp = parent;
				parent = node;
				node = tmp;
			}

			rb_set_black(parent);
			rb_set_red(gparent);
			__rb_rotate_right(gparent, root);
		} else {
			{
				register struct rb_node *uncle = gparent->rb_left;
				if (uncle && rb_is_red(uncle))
				{
					rb_set_black(uncle);
					rb_set_black(parent);
					rb_set_red(gparent);
					node = gparent;
					continue;
				}
			}

			if (parent->rb_left == node)
			{
				register struct rb_node *tmp;
				__rb_rotate_right(parent, root);
				tmp = parent;
				parent = node;
				node = tmp;
			}

			rb_set_black(parent);
			rb_set_red(gparent);
			__rb_rotate_left(gparent, root);
		}
	}

	rb_set_black(root->rb_node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
andq $-0x4, %rdi
je 0x7cc1
movq (%rdi), %rax
testb $0x1, %al
jne 0x7cc1
movq %rax, %r15
andq $-0x4, %r15
movq 0x10(%r15), %rcx
cmpq %rdi, %rcx
je 0x7c65
testq %rcx, %rcx
je 0x7c33
movq (%rcx), %rdx
testb $0x1, %dl
je 0x7c76
cmpq %r14, 0x10(%rdi)
jne 0x7c4d
movq %rdi, %r12
movq %rbx, %rsi
callq 0x7d2e
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %r14
orq $0x1, %rax
movq %rax, (%rdi)
andb $-0x2, (%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7cd4
jmp 0x7cb9
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x7c89
movq (%rcx), %rdx
testb $0x1, %dl
jne 0x7c89
orq $0x1, %rdx
movq %rdx, (%rcx)
orb $0x1, (%rdi)
andb $-0x2, (%r15)
movq %r15, %r14
jmp 0x7cb9
cmpq %r14, 0x8(%rdi)
jne 0x7ca3
movq %rdi, %r12
movq %rbx, %rsi
callq 0x7cd4
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %r14
orq $0x1, %rax
movq %rax, (%rdi)
andb $-0x2, (%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d2e
movq (%r14), %rdi
jmp 0x7c01
movq (%rbx), %rax
orq $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/rbtree.c
// Function: _rb_rotate_right
static void __rb_rotate_right(struct rb_node *node, struct rb_root *root)
{
	struct rb_node *left = node->rb_left;
	struct rb_node *parent = rb_parent(node);

	if ((node->rb_left = left->rb_right))
		rb_set_parent(left->rb_right, node);
	left->rb_right = node;

	rb_set_parent(left, parent);

	if (parent)
	{
		if (node == parent->rb_right)
			parent->rb_right = left;
		else
			parent->rb_left = left;
	}
	else
		root->rb_node = left;
	rb_set_parent(node, left);
}

// Assembly:
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
andq $-0x4, %rcx
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rdi)
testq %rdx, %rdx
je 0x7d53
movq (%rdx), %r8
andl $0x3, %r8d
orq %rdi, %r8
movq %r8, (%rdx)
movq %rdi, 0x8(%rax)
movq (%rax), %rdx
andl $0x3, %edx
orq %rcx, %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
je 0x7d78
leaq 0x8(%rcx), %rdx
leaq 0x10(%rcx), %rsi
cmpq %rdi, 0x8(%rcx)
cmoveq %rdx, %rsi
movq %rax, (%rsi)
movq (%rdi), %rcx
andl $0x3, %ecx
orq %rax, %rcx
movq %rcx, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/rbtree.c
// Function: rb_replace_node
void rb_replace_node(struct rb_node *victim, struct rb_node *newn,
		     struct rb_root *root)
{
	struct rb_node *parent = rb_parent(victim);

	/* Set the surrounding nodes to point to the replacement */
	if (parent) {
		if (victim == parent->rb_left)
			parent->rb_left = newn;
		else
			parent->rb_right = newn;
	} else {
		root->rb_node = newn;
	}
	if (victim->rb_left)
		rb_set_parent(victim->rb_left, newn);
	if (victim->rb_right)
		rb_set_parent(victim->rb_right, newn);

	/* Copy the pointers/colour from the victim to the replacement */
	*newn = *victim;
}

// Assembly:
movq (%rdi), %rax
andq $-0x4, %rax
je 0x80b1
leaq 0x10(%rax), %rcx
leaq 0x8(%rax), %rdx
cmpq %rdi, 0x10(%rax)
cmoveq %rcx, %rdx
movq %rsi, (%rdx)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x80c9
movq (%rax), %rcx
andl $0x3, %ecx
orq %rsi, %rcx
movq %rcx, (%rax)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x80de
movq (%rax), %rcx
andl $0x3, %ecx
orq %rsi, %rcx
movq %rcx, (%rax)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsi)
movups (%rdi), %xmm0
movups %xmm0, (%rsi)
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/ConfigProperty.cpp
// Function: ConfigProperty::getInt(char const*, int) const
int ConfigProperty::getInt(const char *name, int def) const
{
	const char *val = getString(name, NULL);
	if (val == NULL || strlen(val) == 0) return def;

	char *eptr;
	int v = strtol(val, &eptr, 0);
	if (eptr == val) {
		// invalid number
		if (!strcasecmp(val, "true")  || !strcasecmp(val, "yes") || !strcasecmp(val, "t")  || !strcasecmp(val, "y"))
			return 1;
		if (!strcasecmp(val, "false") || !strcasecmp(val, "no") || !strcasecmp(val, "f") || !strcasecmp(val, "n"))
			return 0;
		return def;
	}

	if (*eptr == 'k' || *eptr == 'K') v *= 1024;
	else if (*eptr == 'm' || *eptr == 'M') v *= 1024 * 1024;
	else if (*eptr == 'g' || *eptr == 'G') v *= 1024 * 1024 * 1024;
	/* ignore others */

	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
xorl %edx, %edx
callq 0x8526
testq %rax, %rax
je 0x875a
movq %rax, %r15
cmpb $0x0, (%rax)
je 0x875a
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x34d0
movq %rax, %r14
movq (%r12), %rax
cmpq %r15, %rax
je 0x869e
movzbl (%rax), %eax
addl $-0x47, %eax
cmpl $0x26, %eax
ja 0x8757
movabsq $0x100000001, %rcx      # imm = 0x100000001
btq %rax, %rcx
jb 0x8753
movabsq $0x1000000010, %rcx     # imm = 0x1000000010
btq %rax, %rcx
jb 0x874d
movabsq $0x4000000040, %rcx     # imm = 0x4000000040
btq %rax, %rcx
jae 0x8757
shll $0x14, %r14d
jmp 0x8757
leaq 0x2d9f(%rip), %rsi      # 0xb444
movq %r15, %rdi
callq 0x3380
movl $0x1, %r14d
testl %eax, %eax
je 0x8757
leaq 0x2d87(%rip), %rsi      # 0xb449
movq %r15, %rdi
callq 0x3380
testl %eax, %eax
je 0x8757
leaq 0x204a(%rip), %rsi      # 0xa723
movq %r15, %rdi
callq 0x3380
testl %eax, %eax
je 0x8757
leaq 0x1cba(%rip), %rsi      # 0xa3a6
movq %r15, %rdi
callq 0x3380
testl %eax, %eax
je 0x8757
leaq 0x2d4e(%rip), %rsi      # 0xb44d
movq %r15, %rdi
callq 0x3380
xorl %r14d, %r14d
testl %eax, %eax
je 0x8757
leaq 0x2d3e(%rip), %rsi      # 0xb453
movq %r15, %rdi
callq 0x3380
testl %eax, %eax
je 0x8757
leaq 0x1a01(%rip), %rsi      # 0xa129
movq %r15, %rdi
callq 0x3380
testl %eax, %eax
je 0x8757
leaq 0x1b90(%rip), %rsi      # 0xa2cb
movq %r15, %rdi
callq 0x3380
testl %eax, %eax
cmovel %eax, %ebx
movl %ebx, %r14d
jmp 0x8757
shll $0xa, %r14d
jmp 0x8757
shll $0x1e, %r14d
movl %r14d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/xbs_naddr.cpp
// Function: beyondy::sockaddr2str(sockaddr const*, int, char*, unsigned long)
int sockaddr2str(const struct sockaddr *naddr, int type, char *address, size_t addrlen)
{
	if (naddr->sa_family == PF_UNIX || naddr->sa_family == PF_LOCAL) {
		return __unix_naddr2str((struct sockaddr_un *)naddr, type, address, addrlen);
	}
	else if (naddr->sa_family == PF_INET) {
		return __inet_naddr2str((struct sockaddr_in *)naddr, type, address, addrlen);
	}
	else if (naddr->sa_family == PF_INET6) {
		return __inet6_naddr2str((struct sockaddr_in6 *)naddr, type, address, addrlen);
	}

	errno = EAFNOSUPPORT;
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movzwl (%rdi), %eax
cmpl $0xa, %eax
je 0x94d0
cmpl $0x2, %eax
je 0x94c2
cmpl $0x1, %eax
jne 0x9539
cmpl $0x1, %ebp
leaq 0x1fe4(%rip), %rax      # 0xb45e
leaq 0x1fe4(%rip), %rcx      # 0xb465
cmoveq %rax, %rcx
addq $0x2, %r15
leaq 0x1fdc(%rip), %rdx      # 0xb46c
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %r8
xorl %eax, %eax
callq 0x3560
testl %eax, %eax
js 0x9552
cmpl %ebx, %eax
setge %al
testq %rbx, %rbx
setne %cl
testb %al, %cl
jne 0x9557
jmp 0x955d
leaq 0x4(%r15), %rsi
movq %rsp, %r12
movl $0x2, %edi
jmp 0x94dc
leaq 0x8(%r15), %rsi
movq %rsp, %r12
movl $0xa, %edi
movq %r12, %rdx
movl $0x10, %ecx
callq 0x3370
cmpl $0x1, %ebp
leaq 0x1f6b(%rip), %rax      # 0xb45e
leaq 0x1f6b(%rip), %rcx      # 0xb465
cmoveq %rax, %rcx
movzwl 0x2(%r15), %eax
rolw $0x8, %ax
movzwl %ax, %r9d
leaq 0x1f60(%rip), %rdx      # 0xb472
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %r8
xorl %eax, %eax
callq 0x3560
testl %eax, %eax
js 0x954b
testq %rbx, %rbx
je 0x9535
cmpl %ebx, %eax
jl 0x9535
movb $0x0, -0x1(%r14,%rbx)
xorl %ebp, %ebp
jmp 0x955d
callq 0x3060
movl $0x61, (%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x955d
testq %rbx, %rbx
jne 0x952f
jmp 0x9535
testq %rbx, %rbx
je 0x955d
movb $0x0, -0x1(%r14,%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/xbs_io.cpp
// Function: beyondy::XbsWaitPollable(int, short, long)
int XbsWaitPollable(int fd, short events, long msTimedout)
{
	struct pollfd pfd = { fd, events, 0 };
	int nfd = poll(&pfd, 1, msTimedout);

	if (nfd < 0) return -1;
	if (nfd == 0) return errno = ETIMEDOUT, -1;
	return pfd.revents;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rax
movl %edi, (%rax)
movw %si, 0x4(%rax)
movw $0x0, 0x6(%rax)
movl $0x1, %esi
movq %rax, %rdi
callq 0x3530
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x95c8
je 0x95bd
movswl 0xe(%rsp), %ebx
jmp 0x95c8
callq 0x3060
movl $0x6e, (%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/xbs_io.cpp
// Function: beyondy::XbsWriteN(int, void const*, unsigned long, long)
ssize_t XbsWriteN(int fd, const void *buf, size_t size, long msTimedout)
{
	if (size == 0) return 0;

	TimedoutCountdown toCountdown(msTimedout);
	size_t sed = 0;
	ssize_t slen;

	do {
		if (XbsWaitWritable(fd, toCountdown.Update()) < 0) goto out;
		if ((slen = write(fd, (char *)buf + sed, size - sed)) < 0) goto out;
		sed += static_cast<size_t>(slen);
	} while (sed < size);
out:
	return (sed > 0) ? static_cast<ssize_t>(sed) : -1;
}

// Assembly:
testq %rdx, %rdx
je 0x96b1
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x3570
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x98ba
movl %ebp, %edi
movl $0x4, %esi
movq %rax, %rdx
callq 0x9588
cmpl $-0x1, %eax
je 0x9698
leaq (%r14,%r12), %rsi
movq %rbx, %rdx
subq %r12, %rdx
movl %ebp, %edi
callq 0x30f0
testq %rax, %rax
js 0x9698
addq %rax, %r12
cmpq %rbx, %r12
jb 0x965c
xorl %eax, %eax
cmpq $0x1, %r12
sbbq %rax, %rax
orq %r12, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/xbs_io.cpp
// Function: beyondy::XbsWriteVN(int, iovec const*, int, long)
ssize_t XbsWriteVN(int fd, const struct iovec *iov, int iovcnt, long msTimedout)
{
	TimedoutCountdown toCountdown(msTimedout);
	size_t sed;
	ssize_t slen;

	sed = XbsWriteV(fd, iov, iovcnt, toCountdown.Update());
	if (sed < 0) return -1;

	int i = 0;
	size_t left = sed;
	while (i < iovcnt) {
		if (iov[i].iov_len > left) {
			break;
		}
		else {
			left -= iov[i].iov_len;
		}

		++i;
	}

	for (const struct iovec *next = &iov[i]; next != &iov[iovcnt]; ++next) {
		slen = XbsWriteN(fd, (char *)next->iov_base + left, next->iov_len - left, toCountdown.Update());
		if (slen < 0) break;
		if (static_cast<size_t>(slen) < (next->iov_len - left)) break;
		sed += static_cast<size_t>(slen);
		left = 0;
	}

	return (sed > 0) ? static_cast<ssize_t>(sed) : -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r12
movl %edi, %ebx
leaq 0x18(%rsp), %rdi
movq %rcx, -0x8(%rdi)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x3570
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x98ba
movl %ebx, 0xc(%rsp)
movl %ebx, %edi
movq %r12, %rsi
movl %ebp, %edx
movq %rax, %rcx
callq 0x96b4
movq %rax, %r15
movq %rax, %r14
testl %ebp, %ebp
jle 0x9764
movl %ebp, %eax
leaq 0x8(%r12), %rcx
xorl %r13d, %r13d
movq %r15, %r14
movq %r15, %rdx
subq (%rcx), %rdx
jb 0x9764
incq %r13
addq $0x10, %rcx
movq %rdx, %r14
cmpq %r13, %rax
jne 0x974e
jmp 0x97cb
cmpl %ebp, %r13d
je 0x97cb
movslq %ebp, %rbp
shlq $0x4, %rbp
addq %r12, %rbp
movl %r13d, %ebx
shlq $0x4, %rbx
addq %r12, %rbx
movq (%rbx), %r12
addq %r14, %r12
movq 0x8(%rbx), %r13
subq %r14, %r13
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x98ba
movl 0xc(%rsp), %edi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x9627
testq %rax, %rax
js 0x97cb
movq 0x8(%rbx), %rcx
subq %r14, %rcx
cmpq %rcx, %rax
jb 0x97cb
addq %rax, %r15
addq $0x10, %rbx
movl $0x0, %r14d
cmpq %rbp, %rbx
jne 0x977d
xorl %eax, %eax
cmpq $0x1, %r15
sbbq %rax, %rax
orq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/xbs_io.cpp
// Function: beyondy::XbsReadN(int, void*, unsigned long, long)
ssize_t XbsReadN(int fd, void *buf, size_t size, long msTimedout)
{
	TimedoutCountdown toCountdown(msTimedout);
	ssize_t red = 0, rlen = -1;

	do {
		if (XbsWaitReadable(fd, toCountdown.Update()) < 0) goto out;
		if ((rlen = read(fd, (char *)buf + red, size - red)) < 1) goto out;
		red += rlen;
	} while (red < (ssize_t)size);
out:
	if (red > 0) {
		return red;
	}
	else if (rlen == 0) {
		return 0;
	}

	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x3570
movq %rsp, %r15
movq $-0x1, %r12
movq %r15, %rdi
xorl %esi, %esi
callq 0x98ba
movl %ebp, %edi
movl $0x1, %esi
movq %rax, %rdx
callq 0x9588
cmpl $-0x1, %eax
je 0x989b
leaq (%r14,%r13), %rsi
movq %rbx, %rdx
subq %r13, %rdx
movl %ebp, %edi
callq 0x34f0
testq %rax, %rax
jle 0x9892
addq %rax, %r13
cmpq %rbx, %r13
jl 0x9854
jmp 0x989b
xorl %r12d, %r12d
negq %rax
sbbq %r12, %r12
testq %r13, %r13
cmovgq %r13, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/common/src/../include/beyondy/timedout_countdown.hpp
// Function: beyondy::TimedoutCountdown::Update(long*) const
long Update(long *during = NULL) const {
		if (timedout_ < 0) return -1;		// never timeout

		long past = During();
		if (during != NULL) *during = past;
		past = timedout_  - past;

		return (past < 1) ? 0 : past;
	}

// Assembly:
cmpq $0x0, (%rdi)
js 0x9931
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3570
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq 0x8(%rbx), %rcx
subq 0x10(%rbx), %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
imulq %rdx
imulq $0x3e8, %rcx, %rax      # imm = 0x3E8
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x7, %rdx
addq %rcx, %rdx
addq %rax, %rdx
testq %r14, %r14
je 0x9918
movq %rdx, (%r14)
movq (%rbx), %rcx
subq %rdx, %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovgq %rcx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq $-0x1, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/main.cpp
// Function: getLines(char*)
vector<char*>* getLines(char* code) {
  
  vector<char*>* lines = new vector<char*>();
  uint32_t codeIndex = 0;
  
  while(code[codeIndex]) {
    
    //edge cases
    if(code[codeIndex] == '\n') {
      char* c = new char[2];
      c[0] = '\n'; c[1] = '\0';
      lines->push_back(c);
      codeIndex++;
      continue;
    }
    
    //setup
    uint32_t start = codeIndex;
    uint32_t end = codeIndex;
    
    while(code[end] != '\n' && code[end] != '\0') {
      end++;
    }
    
    char* c = new char[end-start+2];
    for(uint32_t i = start; i < end; i++) {
      c[i-start] = code[i];
    }
    c[end-start] = '\n';
    c[end-start+1] = '\0';

    lines->push_back(c);
    codeIndex = end+1;
  }
  
  return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x18, %edi
callq 0x4210
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %r12d, %r12d
movq %rax, -0x38(%rbp)
movl %r12d, %r14d
movzbl (%rbx,%r14), %eax
cmpl $0xa, %eax
je 0x4cca
testl %eax, %eax
je 0x4d80
movl $0x1, %r15d
movl %r12d, %r13d
testb %al, %al
je 0x4cf4
movzbl %al, %eax
cmpl $0xa, %eax
je 0x4cf4
incl %r13d
movb (%rbx,%r13), %al
incl %r15d
jmp 0x4cb2
movl $0x2, %edi
callq 0x4030
movq %rax, -0x30(%rbp)
movw $0xa, (%rax)
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x4d5b
movq %rax, (%rsi)
addq $0x8, 0x8(%r15)
jmp 0x4d78
leal 0x1(%r15), %edi
callq 0x4030
movq %rax, -0x30(%rbp)
cmpl %r13d, %r12d
jae 0x4d2a
leaq (%rbx,%r14), %rax
movl %r13d, %ecx
subq %r14, %rcx
xorl %edx, %edx
movb (%rax,%rdx), %sil
movq -0x30(%rbp), %rdi
movb %sil, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x4d12
movq -0x30(%rbp), %rax
leal -0x1(%r15), %ecx
movl %ecx, %ecx
movb $0xa, (%rax,%rcx)
movq -0x30(%rbp), %rax
movl %r15d, %ecx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %r15
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x4d69
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r15)
jmp 0x4d75
movq %r15, %rdi
leaq -0x30(%rbp), %rdx
callq 0x4da0
jmp 0x4d78
movq %r15, %rdi
leaq -0x30(%rbp), %rdx
callq 0x4da0
movl %r13d, %r12d
incl %r12d
jmp 0x4c94
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/errors.cpp
// Function: LexerError::what() const
const char* LexerError::what() const throw() {
  
  std::string str  = "LexerError on line ";
  str.append(std::to_string(lineNumber));
  str.append(":\n\t");
  str.append(context);
  str.append("with token ");
  str.append(lexeme);
  str.append("\n");
  str.append(message);
  
  return copyString(str.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x19121(%rip), %rsi     # 0x1e01e
leaq 0x1912d(%rip), %rdx     # 0x1e031
leaq -0x40(%rbp), %rdi
callq 0x5cb8
movl 0x20(%rbx), %r14d
movl $0x1, %eax
cmpl $0xa, %r14d
jb 0x4f61
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r14d, %edx
cmpl $0x63, %edx
jbe 0x4f5a
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x4f5f
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x4f61
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x4f29
addl $-0x3, %eax
jmp 0x4f61
addl $-0x2, %eax
jmp 0x4f61
decl %eax
movl %eax, %esi
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x60(%rbp), %rdi
xorl %edx, %edx
callq 0x4250
movq -0x60(%rbp), %rdi
movl -0x58(%rbp), %esi
movl %r14d, %edx
callq 0x5c46
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x40a0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x4fa5
callq 0x41e0
leaq 0x19086(%rip), %rsi     # 0x1e032
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x8(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
leaq 0x1906d(%rip), %rsi     # 0x1e036
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x10(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
leaq 0x1df76(%rip), %rsi     # 0x22f5c
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x18(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq -0x40(%rbp), %rdi
callq 0x175e8
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5016
callq 0x41e0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x5043
callq 0x41e0
jmp 0x5043
jmp 0x5040
movq %rax, %rbx
jmp 0x5051
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5051
callq 0x41e0
movq %rbx, %rdi
callq 0x4270
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/errors.cpp
// Function: StaticVariableScopeError::what() const
const char* StaticVariableScopeError::what() const throw() {

  std::string str = "StaticVariableScopeError on line ";
  str.append(std::to_string(lineNumber));
  str.append("\n");
  str.append(context);

  str.append("The variable ");
  str.append(variable);
  str.append(" ");

  if(isDeclaredError) {
    str.append("is already declared in this scope. It cannot be re-declared in the same scope.");
  } else {
    str.append("is not yet declared in this or enclosing scopes.\nIt has to be declared with a type before"
                " being accessed or assigned a value.");
  }

  return copyString(str.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x18a47(%rip), %rsi     # 0x1e11a
leaq 0x18a61(%rip), %rdx     # 0x1e13b
leaq -0x40(%rbp), %rdi
callq 0x5cb8
movl 0x34(%rbx), %r14d
movl $0x1, %eax
cmpl $0xa, %r14d
jb 0x5737
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r14d, %edx
cmpl $0x63, %edx
jbe 0x5730
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x5735
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x5737
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x56ff
addl $-0x3, %eax
jmp 0x5737
addl $-0x2, %eax
jmp 0x5737
decl %eax
movl %eax, %esi
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x60(%rbp), %rdi
xorl %edx, %edx
callq 0x4250
movq -0x60(%rbp), %rdi
movl -0x58(%rbp), %esi
movl %r14d, %edx
callq 0x5c46
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x40a0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x577b
callq 0x41e0
leaq 0x1d7da(%rip), %rsi     # 0x22f5c
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x28(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
leaq 0x1899d(%rip), %rsi     # 0x1e13c
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq -0x40(%rbp), %rdi
callq 0x40a0
leaq 0x1996a(%rip), %rsi     # 0x1f12a
leaq -0x40(%rbp), %rdi
callq 0x43a0
leaq 0x1897a(%rip), %rax     # 0x1e14a
leaq 0x189c2(%rip), %rsi     # 0x1e199
cmpb $0x0, 0x30(%rbx)
cmovneq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq -0x40(%rbp), %rdi
callq 0x175e8
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5802
callq 0x41e0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x582f
callq 0x41e0
jmp 0x582f
jmp 0x582c
movq %rax, %rbx
jmp 0x583d
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x583d
callq 0x41e0
movq %rbx, %rdi
callq 0x4270
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: makeToken(TokenType, unsigned int, char const*, Data)
Token makeToken(TokenType typ, uint32_t lin, const char* lex, Data val) {
  Token tokenPtr;
  tokenPtr.type = typ;
  tokenPtr.line = lin;
  tokenPtr.lexeme = copyString(lex);
  tokenPtr.value = val;
  return tokenPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x10(%rdi)
movq %rcx, %rdi
callq 0x175e8
movq %rax, 0x18(%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: makeToken(TokenType, unsigned int, char const*)
Token makeToken(TokenType typ, uint32_t lin, const char* lex) {
  Token tokenPtr;
  tokenPtr.type = typ;
  tokenPtr.line = lin;
  tokenPtr.lexeme = copyString(lex);
  return tokenPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x10(%rdi)
movq %rcx, %rdi
callq 0x175e8
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: varOrKeywordTokenType(char*)
TokenType varOrKeywordTokenType(char* lexeme) {

  //determine if keyword, if not then identifier
  std::size_t len = strlen(lexeme);

  for(uint8_t i = 0; i < NUM_RESERVED_WORDS; i++) {
    const char* keyword = RESERVED_WORDS[i];
    if(strncmp(lexeme, keyword, std::max(len, strlen(keyword))) == 0) {
      return RESERVED_WORD_TOKENS[i];
    }
  }

  return VARIABLE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x40e0
movq %rax, %r14
leaq 0x2548a(%rip), %r13     # 0x2b710
xorl %r12d, %r12d
movq (%r13), %r15
movq %r15, %rdi
callq 0x40e0
movq %r14, %rdx
cmpq %rax, %r14
ja 0x62a0
movq %rax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40f0
testl %eax, %eax
je 0x62c4
addq $0x4, %r12
addq $0x8, %r13
cmpq $0x7c, %r12
jne 0x6289
movl $0x3b, %eax
jmp 0x62cf
leaq 0x18445(%rip), %rax     # 0x1e710
movl (%r12,%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/lexer.cpp
// Function: stringToInt(char*, unsigned int, unsigned int)
uint64_t stringToInt(char* str, uint32_t start, uint32_t end) {

  uint64_t ans = 0;
  for(uint32_t i = start; i <= end; i++) {
    ans = ans*10 + (str[i] - '0');
  }  

  return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpl %edx, %esi
ja 0x6439
leaq (%rax,%rax,4), %rax
movl %esi, %ecx
movsbq (%rdi,%rcx), %rcx
leaq (%rcx,%rax,2), %rax
addq $-0x30, %rax
incl %esi
jmp 0x641e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/lexer.cpp
// Function: stringToDouble(char*, unsigned int, unsigned int)
double stringToDouble(char* str, uint32_t start, uint32_t end) {

  double whole = 0;
  double decimal = 0;
  double exp = 0.1;
  bool isDecimalMode = false;

  for(uint32_t i = start; i <= end; i++) {

    if(str[i] == '.') {
      isDecimalMode = true;
    } else if(isDecimalMode) {
      decimal += exp*(str[i]-'0');
      exp *= 0.1;      
    } else {
      whole = whole*10 + (str[i]-'0');      
    }
  }

  return whole + decimal;
}

// Assembly:
xorpd %xmm0, %xmm0
cmpl %edx, %esi
ja 0x64aa
pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
movsd 0x1847d(%rip), %xmm2    # 0x1e8d0
xorl %ecx, %ecx
movsd 0x1847b(%rip), %xmm3    # 0x1e8d8
movapd %xmm2, %xmm4
xorpd %xmm0, %xmm0
movl %esi, %eax
movsbl (%rdi,%rax), %r8d
movb $0x1, %al
cmpl $0x2e, %r8d
je 0x649d
addl $-0x30, %r8d
xorps %xmm5, %xmm5
cvtsi2sd %r8d, %xmm5
testb $0x1, %cl
je 0x6493
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm4
jmp 0x649d
mulsd %xmm3, %xmm0
addsd %xmm5, %xmm0
xorl %eax, %eax
incl %esi
movl %eax, %ecx
cmpl %edx, %esi
jbe 0x6465
addsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsetoken.cpp
// Function: copyParseData(ParseData)
ParseData copyParseData(ParseData d) {

	ParseDataType type = d.type;
	ParseData d2;
	d2.type = type;

	//string deep copy
	if(type == STRING_T) {

		d2.value.allocated = (void*) copyString((char*) d.value.allocated);

	} else if(type == ARRAY_T) {

		//array deep copy
		Array* arr = (Array*) d.value.allocated;
		uint32_t length = arr->length;
		ParseData* values = arr->values;

		Array* arr2 = (Array*) malloc(sizeof(Array));
		arr2->length = length;
		arr2->subtype = arr->subtype;

		ParseData* values2 = (ParseData*) malloc(sizeof(ParseData)*std::max((int32_t)length, 1));
		for(uint32_t i = 0; i < length; i++) {
			values2[i] = copyParseData(values[i]);
		}
		arr2->values = values2;
		d2.value.allocated = (void*) arr2;

	} else if(type == DOUBLE_T) {
		d2.value.floatingPoint = d.value.floatingPoint;
	} else {
		d2.value.integer = d.value.integer;
	}

	return d2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
cmpl $0xc, %edi
je 0x7f43
cmpl $0xb, %ebx
jne 0x7fb3
movq %r15, %rdi
callq 0x175e8
jmp 0x7fb0
movl 0x4(%r15), %r12d
movq 0x8(%r15), %r13
movl $0x10, %edi
callq 0x4290
movl %r12d, 0x4(%rax)
movl (%r15), %ecx
movq %rax, -0x30(%rbp)
movl %ecx, (%rax)
cmpl $0x2, %r12d
movl $0x1, %edi
cmovgel %r12d, %edi
shlq $0x4, %rdi
callq 0x4290
movq %rax, %r15
testq %r12, %r12
je 0x7fa8
shlq $0x4, %r12
xorl %r14d, %r14d
movl (%r13,%r14), %edi
movq 0x8(%r13,%r14), %rsi
callq 0x7f1c
movl %eax, (%r15,%r14)
movq %rdx, 0x8(%r15,%r14)
addq $0x10, %r14
cmpq %r14, %r12
jne 0x7f87
movq -0x30(%rbp), %rax
movq %r15, 0x8(%rax)
movq %rax, %r15
movl %ebx, %eax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsetoken.cpp
// Function: getLargerNumberParseDataType(ParseDataType, ParseDataType)
ParseDataType getLargerNumberParseDataType(ParseDataType p1, ParseDataType p2) {
 
  //some special cases
  if(p1 == DOUBLE_T || p2 == DOUBLE_T)
    return DOUBLE_T;

  //CHAR_T only returned if BOTH types are CHAR_T already (otherwise it's int)
  if(p1 == CHAR_T && p2 == CHAR_T)
    return CHAR_T;

  //pre-process
  ParseDataType P1 = (p1 == CHAR_T) ? UINT8_T : p1;
  ParseDataType P2 = (p2 == CHAR_T) ? UINT8_T : p2;

  //find the larger type
  uint8_t i1 = 0;
  uint8_t i2 = 0;

  while((signedIntegerTypes[i1] != P1) &&  (unsignedIntegerTypes[i1] != P1))
    i1++;

  while((signedIntegerTypes[i2] != P2) &&  (unsignedIntegerTypes[i2] != P2))
    i2++;

  uint8_t max = (i1 > i2) ? i1 : i2;
  return (isUnsignedIntParseDataType(P1) && isUnsignedIntParseDataType(P2)) ?
          unsignedIntegerTypes[max] : signedIntegerTypes[max];  

}

// Assembly:
cmpl $0xa, %edi
sete %al
cmpl $0xa, %esi
sete %cl
orb %al, %cl
movl $0xa, %eax
jne 0x80d5
movl %edi, %ecx
xorl $0x8, %ecx
movl %esi, %edx
xorl $0x8, %edx
movl $0x8, %eax
orl %ecx, %edx
je 0x80d5
cmpl $0x8, %edi
movl $0x4, %eax
cmovel %eax, %edi
cmpl $0x8, %esi
cmovel %eax, %esi
testl %edi, %edi
je 0x806e
xorl %r8d, %r8d
leaq 0x16d9f(%rip), %rcx     # 0x1edf0
leaq 0x16d88(%rip), %rdx     # 0x1ede0
xorl %eax, %eax
cmpl %edi, (%rcx,%r8,4)
je 0x8070
incb %al
movzbl %al, %r8d
cmpl %edi, (%rdx,%r8,4)
jne 0x805a
jmp 0x8070
xorl %eax, %eax
testl %esi, %esi
je 0x809b
xorl %r9d, %r9d
leaq 0x16d72(%rip), %rdx     # 0x1edf0
leaq 0x16d5b(%rip), %r8      # 0x1ede0
xorl %ecx, %ecx
cmpl %esi, (%rdx,%r9,4)
je 0x809d
incb %cl
movzbl %cl, %r9d
cmpl %esi, (%r8,%r9,4)
jne 0x8087
jmp 0x809d
xorl %ecx, %ecx
pushq %rbp
movq %rsp, %rbp
movzbl %al, %eax
movzbl %cl, %ecx
cmpb %cl, %al
cmoval %eax, %ecx
addl $-0x4, %edi
addl $-0x4, %esi
cmpl $0x5, %esi
leaq 0x16d34(%rip), %rax     # 0x1edf0
leaq 0x16d1d(%rip), %rdx     # 0x1ede0
cmovaeq %rdx, %rax
cmpl $0x5, %edi
cmovaeq %rdx, %rax
movzbl %cl, %ecx
movl (%rax,%rcx,4), %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: AssignmentExpressionNode::AssignmentExpressionNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseDataType, AbstractExpressionNode*, SymbolTable*, unsigned int)
AssignmentExpressionNode::AssignmentExpressionNode(std::string var, ParseDataType varType, AbstractExpressionNode* val, SymbolTable* table, uint32_t varLine) {

  variable = var;
  variableType = varType;
  value = val;
  symbolTable = table;
  
  evalType = varType;
	subType = (varType == STRING_T) ? CHAR_T :
						(varType == ARRAY_T) ? val->subType :
						INVALID_T;
	
  startLine = varLine;
  endLine = val->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, %r14
movl %edx, %r12d
movq %rdi, %r15
leaq 0x22de7(%rip), %rax     # 0x2b828
movq %rax, (%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r13
movq %r13, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %rbx, %rdi
callq 0x4140
movl %r12d, 0x38(%r15)
movq %r14, 0x40(%r15)
movq -0x38(%rbp), %rax
movq %rax, 0x48(%r15)
movl %r12d, 0x10(%r15)
cmpl $0xb, %r12d
je 0x8a8a
cmpl $0xc, %r12d
jne 0x8a91
movl 0x14(%r14), %eax
jmp 0x8a96
movl $0x8, %eax
jmp 0x8a96
movl $0x11, %eax
movl %eax, 0x14(%r15)
movl -0x2c(%rbp), %eax
movl %eax, 0x8(%r15)
movl 0xc(%r14), %eax
movl %eax, 0xc(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x8ac8
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: UnaryOperatorNode::UnaryOperatorNode(ParseOperatorType, AbstractExpressionNode*, unsigned int)
UnaryOperatorNode::UnaryOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, uint32_t operatorLine) {
  operation = op;
  leftArg = l;
  evalType = getTypeUnaryExpression(op, l->evalType); 
  startLine = std::min(operatorLine, l->startLine);
  endLine = std::max(operatorLine, l->endLine);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %r15
leaq 0x22d2b(%rip), %rcx     # 0x2b868
movq %rcx, (%rdi)
movl %esi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movl 0x10(%rdx), %esi
movl %eax, %edi
callq 0x16271
movl %eax, 0x10(%r15)
movl 0x8(%r14), %eax
cmpl %ebx, %eax
cmovael %ebx, %eax
movl %eax, 0x8(%r15)
movl 0xc(%r14), %eax
cmpl %ebx, %eax
cmoval %eax, %ebx
movl %ebx, 0xc(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: UnaryOperatorNode::toString[abi:cxx11]()
std::string UnaryOperatorNode::toString() {
  std::string str = "(";
  str.append(toStringParseOperatorType(operation));
  str.append(" ");
  str.append(leftArg->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x15d7b(%rip), %rsi     # 0x1e990
leaq 0x15d75(%rip), %rdx     # 0x1e991
callq 0x5cb8
movl 0x18(%r14), %edi
callq 0x81a3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
leaq 0x164ee(%rip), %rsi     # 0x1f12a
movq %rbx, %rdi
callq 0x43a0
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *0x8(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c74
callq 0x41e0
leaq 0x15ec5(%rip), %rsi     # 0x1eb40
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8cad
callq 0x41e0
jmp 0x8cad
jmp 0x8caa
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8cba
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: AbstractBinaryOperatorNode::toString[abi:cxx11]()
std::string AbstractBinaryOperatorNode::toString() {
  std::string str = "( ";
  str.append(toStringParseOperatorType(operation));
  str.append(" ");
  str.append(leftArg->toString());
  str.append(" "); 
  str.append(rightArg->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x16444(%rip), %rsi     # 0x1f129
leaq 0x1643f(%rip), %rdx     # 0x1f12b
callq 0x5cb8
movl 0x18(%r14), %edi
callq 0x81a3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
leaq 0x1641e(%rip), %rsi     # 0x1f12a
movq %rbx, %rdi
callq 0x43a0
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x8d45
callq 0x41e0
leaq 0x163de(%rip), %rsi     # 0x1f12a
movq %rbx, %rdi
callq 0x43a0
movq 0x28(%r14), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x8d80
callq 0x41e0
leaq 0x15db9(%rip), %rsi     # 0x1eb40
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
jne 0x8dbf
jmp 0x8dcb
jmp 0x8dc8
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8dcb
callq 0x41e0
jmp 0x8dcb
jmp 0x8dc8
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8dd8
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: BitLogicalOperatorNode::BitLogicalOperatorNode(ParseOperatorType, AbstractExpressionNode*, AbstractExpressionNode*)
BitLogicalOperatorNode::BitLogicalOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, AbstractExpressionNode* r) {
  operation = op;
  leftArg = l;
  rightArg = r;
  startLine = l->startLine;
  endLine = r->endLine;
  evalType = getTypeBitLogicalExpression(op, l->evalType, r->evalType);
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
leaq 0x22a58(%rip), %rsi     # 0x2b8a8
movq %rsi, (%rdi)
movl %eax, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movl 0x8(%rdx), %esi
movl %esi, 0x8(%rdi)
movl 0xc(%rcx), %esi
movl %esi, 0xc(%rdi)
movl 0x10(%rdx), %esi
movl 0x10(%rcx), %edx
movl %eax, %edi
callq 0x16372
movl %eax, 0x10(%rbx)
xorl %ecx, %ecx
cmpl $0xb, %eax
setne %cl
leal (%rcx,%rcx,8), %eax
addl $0x8, %eax
movl %eax, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: CastNode::CastNode(AbstractExpressionNode*, ParseDataType, unsigned int)
CastNode::CastNode(AbstractExpressionNode* e, ParseDataType type, uint32_t startLin) {
  expression = e;
  evalType = finalType = type;
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T;

  startLine = startLin;
  endLine = e->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x229e3(%rip), %rax     # 0x2b8e8
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movl %edx, 0x20(%rdi)
movl %edx, 0x10(%rdi)
xorl %eax, %eax
cmpl $0xb, %edx
setne %al
leal (%rax,%rax,8), %eax
addl $0x8, %eax
movl %eax, 0x14(%rdi)
movl %ecx, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: CastNode::toString[abi:cxx11]()
std::string CastNode::toString() {
  std::string str = "(";
  str.append(toStringParseDataType(finalType));
  str.append(" ");
  str.append(expression->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x15a41(%rip), %rsi     # 0x1e990
leaq 0x15a3b(%rip), %rdx     # 0x1e991
callq 0x5cb8
movl 0x20(%r14), %edi
callq 0x817c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
leaq 0x161b4(%rip), %rsi     # 0x1f12a
movq %rbx, %rdi
callq 0x43a0
movq 0x18(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *0x8(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8fae
callq 0x41e0
leaq 0x15b8b(%rip), %rsi     # 0x1eb40
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8fe7
callq 0x41e0
jmp 0x8fe7
jmp 0x8fe4
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8ff4
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayAccessNode::ArrayAccessNode(AbstractExpressionNode*, AbstractExpressionNode*, char*, unsigned int)
ArrayAccessNode::ArrayAccessNode(AbstractExpressionNode* arr, AbstractExpressionNode* s, char* context, uint32_t endLin) {
	array = arr; start = s; endLine = endLin; isSlice = false;
	startLine = arr->startLine;
	endLine = endLin;
	this->context = context;
	evalType = arr->subType;
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x228f7(%rip), %rax     # 0x2b908
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movb $0x0, 0x38(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movq %rcx, 0x30(%rdi)
movl 0x14(%rsi), %eax
movl %eax, 0x10(%rdi)
xorl %ecx, %ecx
cmpl $0xb, %eax
setne %cl
leal (%rcx,%rcx,8), %eax
addl $0x8, %eax
movl %eax, 0x14(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayAccessNode::toString[abi:cxx11]()
std::string ArrayAccessNode::toString() {
  
  std::string str = "([";
  if(isSlice) {
    
    str.append(start->toString());
    str.append(":");
    str.append(end->toString());
    str.append("] ");
    
  } else {
    str.append("]");
  }
 
  str.append(array->toString());
  str.append(")");
 
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x1607d(%rip), %rsi     # 0x1f12c
leaq 0x16078(%rip), %rdx     # 0x1f12e
callq 0x5cb8
cmpb $0x1, 0x38(%r14)
jne 0x9137
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x90f3
callq 0x41e0
leaq 0x158a0(%rip), %rsi     # 0x1e99a
movq %rbx, %rdi
callq 0x43a0
movq 0x28(%r14), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x912e
callq 0x41e0
leaq 0x15ffa(%rip), %rsi     # 0x1f12f
jmp 0x913e
leaq 0x15854(%rip), %rsi     # 0x1e992
movq %rbx, %rdi
callq 0x43a0
movq 0x18(%r14), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9176
callq 0x41e0
leaq 0x159c3(%rip), %rsi     # 0x1eb40
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
jne 0x91b9
jmp 0x91c5
jmp 0x91c2
jmp 0x91a9
jmp 0x91c2
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x91c5
callq 0x41e0
jmp 0x91c5
jmp 0x91c2
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x91d2
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayNode::ArrayNode(ParseDataType, bool, AbstractExpressionNode*, AbstractExpressionNode**, unsigned int, unsigned int)
ArrayNode::ArrayNode(ParseDataType sType, bool isInit, AbstractExpressionNode* len, AbstractExpressionNode** vals, uint32_t startLine, uint32_t endLine) {
	evalType = ARRAY_T;
	subType = sType;
	isInitialized = isInit;
	length = len;
	values = vals;
	this->startLine = startLine;
	this->endLine = endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
leaq 0x22740(%rip), %r10     # 0x2b928
movq %r10, (%rdi)
movl $0xc, 0x10(%rdi)
movl %esi, 0x14(%rdi)
movb %dl, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %r8, 0x28(%rdi)
movl %r9d, 0x8(%rdi)
movl %eax, 0xc(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayNode::toString[abi:cxx11]()
std::string ArrayNode::toString() {
	std::string str = "";
	str.append("[length = ");
	str.append(length->toString());
	str.append(", type = ");
	str.append(toStringParseDataType(subType));
	str.append("]");
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x14e00(%rip), %rdx     # 0x1e035
movq %rdx, %rsi
callq 0x5cb8
leaq 0x15eee(%rip), %rsi     # 0x1f132
movq %rbx, %rdi
callq 0x43a0
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *0x8(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x927c
callq 0x41e0
leaq 0x15eba(%rip), %rsi     # 0x1f13d
movq %rbx, %rdi
callq 0x43a0
movl 0x14(%r14), %edi
callq 0x817c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
leaq 0x156ec(%rip), %rsi     # 0x1e992
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x92d8
callq 0x41e0
jmp 0x92d8
jmp 0x92d5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x92e5
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop