LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x96c4
je 0x96b9
movswl 0xe(%rsp), %ebx
jmp 0x96c4
callq 0x3060
movl $0x6e, (%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x97ad
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 0x99b8
movl %ebp, %edi
movl $0x4, %esi
movq %rax, %rdx
callq 0x9684
cmpl $-0x1, %eax
je 0x9794
leaq (%r14,%r12), %rsi
movq %rbx, %rdx
subq %r12, %rdx
movl %ebp, %edi
callq 0x30f0
testq %rax, %rax
js 0x9794
addq %rax, %r12
cmpq %rbx, %r12
jb 0x9758
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_O1/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 0x99b8
movl %ebx, 0xc(%rsp)
movl %ebx, %edi
movq %r12, %rsi
movl %ebp, %edx
movq %rax, %rcx
callq 0x97b0
movq %rax, %r15
movq %rax, %r14
testl %ebp, %ebp
jle 0x9864
movl %ebp, %eax
leaq 0x8(%r12), %rcx
xorl %r13d, %r13d
movq %r15, %r14
movq %r15, %rdx
subq (%rcx), %rdx
jb 0x9864
incq %r13
addq $0x10, %rcx
movq %rdx, %r14
cmpq %r13, %rax
jne 0x984a
movl %eax, %r13d
movq %rdx, %r14
cmpl %ebp, %r13d
je 0x98cb
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 0x99b8
movl 0xc(%rsp), %edi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x9723
testq %rax, %rax
js 0x98cb
movq 0x8(%rbx), %rcx
subq %r14, %rcx
cmpq %rcx, %rax
jb 0x98cb
addq %rax, %r15
addq $0x10, %rbx
movl $0x0, %r14d
cmpq %rbp, %rbx
jne 0x987d
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_O1/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 %r12d, %r12d
xorl %esi, %esi
callq 0x3570
movq %rsp, %r15
movl $0x1, %r13d
movq %r15, %rdi
xorl %esi, %esi
callq 0x99b8
movl %ebp, %edi
movl $0x1, %esi
movq %rax, %rdx
callq 0x9684
cmpl $-0x1, %eax
je 0x9994
leaq (%r14,%r12), %rsi
movq %rbx, %rdx
subq %r12, %rdx
movl %ebp, %edi
callq 0x34f0
testq %rax, %rax
jle 0x9991
addq %rax, %r12
cmpq %rbx, %r12
jl 0x9953
jmp 0x9994
movq %rax, %r13
xorl %eax, %eax
negq %r13
sbbq %rax, %rax
testq %r12, %r12
cmovgq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9a2f
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 0x9a16
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_O1/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, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %r15d, %r15d
movq %rax, -0x38(%rbp)
movl %r15d, %ecx
movzbl (%rbx,%rcx), %eax
cmpl $0xa, %eax
je 0x4cf2
testl %eax, %eax
je 0x4dae
xorl %r13d, %r13d
movl %r15d, %r14d
leal (%r15,%r13), %r12d
movzbl (%rbx,%r12), %eax
testl %eax, %eax
je 0x4d1c
cmpl $0xa, %eax
je 0x4d1c
incl %r13d
incl %r14d
jmp 0x4cd8
movl $0x2, %edi
callq 0x4030
movq %rax, -0x30(%rbp)
movw $0xa, (%rax)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x4d89
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x4da6
movq %rcx, -0x40(%rbp)
leal 0x2(%r13), %edi
callq 0x4030
movq %rax, -0x30(%rbp)
cmpl %r12d, %r15d
jae 0x4d56
movq -0x40(%rbp), %rdx
leaq (%rbx,%rdx), %rax
movl %r14d, %ecx
subq %rdx, %rcx
xorl %edx, %edx
movb (%rax,%rdx), %sil
movq -0x30(%rbp), %rdi
movb %sil, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x4d42
movq -0x30(%rbp), %rax
movl %r13d, %ecx
movb $0xa, (%rax,%rcx)
movq -0x30(%rbp), %rax
incl %r13d
movb $0x0, (%rax,%r13)
movq -0x38(%rbp), %r14
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x4d97
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x4da3
movq %r14, %rdi
leaq -0x30(%rbp), %rdx
callq 0x4dce
jmp 0x4da6
movq %r14, %rdi
leaq -0x30(%rbp), %rdx
callq 0x4dce
movl %r12d, %r15d
incl %r15d
jmp 0x4cbe
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19111(%rip), %rsi     # 0x1e03a
leaq 0x1911d(%rip), %rdx     # 0x1e04d
leaq -0x40(%rbp), %rdi
callq 0x5ce4
movl 0x20(%rbx), %r14d
movl $0x1, %eax
cmpl $0xa, %r14d
jb 0x4f8d
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r14d, %edx
cmpl $0x63, %edx
jbe 0x4f86
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x4f8b
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x4f8d
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x4f55
addl $-0x3, %eax
jmp 0x4f8d
addl $-0x2, %eax
jmp 0x4f8d
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 0x5c72
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x40a0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x4fd1
callq 0x41e0
leaq 0x19076(%rip), %rsi     # 0x1e04e
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x8(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
leaq 0x1905d(%rip), %rsi     # 0x1e052
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x10(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
leaq 0x1df6a(%rip), %rsi     # 0x22f7c
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x18(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq -0x40(%rbp), %rdi
callq 0x176b0
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5042
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 0x506f
callq 0x41e0
jmp 0x506f
jmp 0x506c
movq %rax, %rbx
jmp 0x507d
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x507d
callq 0x41e0
movq %rbx, %rdi
callq 0x4270
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18a37(%rip), %rsi     # 0x1e136
leaq 0x18a51(%rip), %rdx     # 0x1e157
leaq -0x40(%rbp), %rdi
callq 0x5ce4
movl 0x34(%rbx), %r14d
movl $0x1, %eax
cmpl $0xa, %r14d
jb 0x5763
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r14d, %edx
cmpl $0x63, %edx
jbe 0x575c
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x5761
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x5763
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x572b
addl $-0x3, %eax
jmp 0x5763
addl $-0x2, %eax
jmp 0x5763
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 0x5c72
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x40a0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x57a7
callq 0x41e0
leaq 0x1d7ce(%rip), %rsi     # 0x22f7c
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x28(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
leaq 0x1898d(%rip), %rsi     # 0x1e158
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq -0x40(%rbp), %rdi
callq 0x40a0
leaq 0x1995e(%rip), %rsi     # 0x1f14a
leaq -0x40(%rbp), %rdi
callq 0x43a0
leaq 0x1896a(%rip), %rax     # 0x1e166
leaq 0x189b2(%rip), %rsi     # 0x1e1b5
cmpb $0x0, 0x30(%rbx)
cmovneq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq -0x40(%rbp), %rdi
callq 0x176b0
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x582e
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 0x585b
callq 0x41e0
jmp 0x585b
jmp 0x5858
movq %rax, %rbx
jmp 0x5869
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5869
callq 0x41e0
movq %rbx, %rdi
callq 0x4270
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x176b0
movq %rax, 0x18(%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x176b0
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25462(%rip), %r13     # 0x2b710
xorl %r15d, %r15d
movq (%r13), %r12
movq %r12, %rdi
callq 0x40e0
movq %r14, %rdx
cmpq %rax, %r14
ja 0x62c8
movq %rax, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40f0
testl %eax, %eax
jne 0x62e5
leaq 0x18452(%rip), %rcx     # 0x1e730
movl (%r15,%rcx), %ecx
movl %ecx, -0x2c(%rbp)
testl %eax, %eax
je 0x62fe
addq $0x8, %r13
addq $0x4, %r15
cmpq $0x7c, %r15
jne 0x62b1
movl $0x3b, %eax
jmp 0x6301
movl -0x2c(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x646d
leaq (%rax,%rax,4), %rax
movl %esi, %ecx
movsbq (%rdi,%rcx), %rcx
leaq (%rcx,%rax,2), %rax
addq $-0x30, %rax
incl %esi
jmp 0x6452
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64d7
pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
movsd 0x18469(%rip), %xmm2    # 0x1e8f0
xorl %eax, %eax
movsd 0x18467(%rip), %xmm3    # 0x1e8f8
movapd %xmm2, %xmm4
xorpd %xmm0, %xmm0
movl %esi, %ecx
movsbl (%rdi,%rcx), %ecx
cmpl $0x2e, %ecx
jne 0x64a8
movb $0x1, %al
jmp 0x64cc
addl $-0x30, %ecx
xorps %xmm5, %xmm5
cvtsi2sd %ecx, %xmm5
testb $0x1, %al
je 0x64c4
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm4
jmp 0x64cc
mulsd %xmm3, %xmm0
addsd %xmm5, %xmm0
incl %esi
cmpl %edx, %esi
jbe 0x6499
addsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8067
cmpl $0xb, %ebx
jne 0x80d7
movq %r15, %rdi
callq 0x176b0
jmp 0x80d4
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 0x80cc
shlq $0x4, %r12
xorl %r14d, %r14d
movl (%r13,%r14), %edi
movq 0x8(%r13,%r14), %rsi
callq 0x8040
movl %eax, (%r15,%r14)
movq %rdx, 0x8(%r15,%r14)
addq $0x10, %r14
cmpq %r14, %r12
jne 0x80ab
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_O1/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 0x8201
movl %edi, %ecx
xorl $0x8, %ecx
movl %esi, %edx
xorl $0x8, %edx
movl $0x8, %eax
orl %ecx, %edx
je 0x8201
cmpl $0x8, %edi
movl $0x4, %eax
cmovel %eax, %edi
cmpl $0x8, %esi
cmovel %eax, %esi
testl %edi, %edi
je 0x8192
xorl %r8d, %r8d
leaq 0x16c9b(%rip), %rcx     # 0x1ee10
leaq 0x16c84(%rip), %rdx     # 0x1ee00
xorl %eax, %eax
cmpl %edi, (%rcx,%r8,4)
je 0x8194
incb %al
movzbl %al, %r8d
cmpl %edi, (%rdx,%r8,4)
jne 0x817e
jmp 0x8194
xorl %eax, %eax
testl %esi, %esi
je 0x81bf
xorl %r9d, %r9d
leaq 0x16c6e(%rip), %rdx     # 0x1ee10
leaq 0x16c57(%rip), %r8      # 0x1ee00
xorl %ecx, %ecx
cmpl %esi, (%rdx,%r9,4)
je 0x81c1
incb %cl
movzbl %cl, %r9d
cmpl %esi, (%r8,%r9,4)
jne 0x81ab
jmp 0x81c1
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
movzbl %cl, %eax
shll $0x2, %eax
leaq 0x16c2d(%rip), %rcx     # 0x1ee10
addq %rax, %rcx
leaq 0x16c13(%rip), %rdx     # 0x1ee00
addq %rax, %rdx
cmpl $0x5, %esi
cmovaeq %rdx, %rcx
cmpl $0x5, %edi
cmovaeq %rdx, %rcx
movl (%rcx), %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22ca3(%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 0x8bce
cmpl $0xc, %r12d
jne 0x8bd5
movl 0x14(%r14), %eax
jmp 0x8bda
movl $0x8, %eax
jmp 0x8bda
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 0x8c0c
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayAssignmentExpressionNode::ArrayAssignmentExpressionNode(AbstractExpressionNode*, AbstractExpressionNode*, AbstractExpressionNode*, char*, SymbolTable*)
ArrayAssignmentExpressionNode::ArrayAssignmentExpressionNode(AbstractExpressionNode* arr, AbstractExpressionNode* ind, AbstractExpressionNode* val, char* context, SymbolTable* symbolTable) {
	array = arr;
	index = ind;
	value = val;
  this->context = context;
	this->symbolTable = symbolTable;
	startLine = arr->startLine;
	endLine = value->endLine;
	evalType = arr->subType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x22c1b(%rip), %rax     # 0x2b848
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq %r9, 0x38(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rcx), %eax
movl %eax, 0xc(%rdi)
movl 0x14(%rsi), %eax
movl %eax, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22be7(%rip), %rcx     # 0x2b868
movq %rcx, (%rdi)
movl %esi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movl 0x10(%rdx), %esi
movl %eax, %edi
callq 0x162f9
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_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: UnaryOperatorNode::UnaryOperatorNode(ParseOperatorType, AbstractExpressionNode*, SymbolTable*, unsigned int)
UnaryOperatorNode::UnaryOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, SymbolTable* table, uint32_t operatorLine) {
  operation = op;
  leftArg = l;
  symbolTable = table;
  evalType = getTypeUnaryExpression(op, l->evalType);
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T; 
  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 %r8d, %ebx
movq %rdx, %r15
movl %esi, %eax
movq %rdi, %r14
leaq 0x22b8e(%rip), %rdx     # 0x2b868
movq %rdx, (%rdi)
movl %esi, 0x18(%rdi)
movq %r15, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movl 0x10(%r15), %esi
movl %eax, %edi
callq 0x162f9
movl %eax, 0x10(%r14)
xorl %ecx, %ecx
cmpl $0xb, %eax
setne %cl
leal (%rcx,%rcx,8), %eax
addl $0x8, %eax
movl %eax, 0x14(%r14)
movl 0x8(%r15), %eax
cmpl %ebx, %eax
cmovael %ebx, %eax
movl %eax, 0x8(%r14)
movl 0xc(%r15), %eax
cmpl %ebx, %eax
cmoval %eax, %ebx
movl %ebx, 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15c57(%rip), %rsi     # 0x1e9b0
leaq 0x15c51(%rip), %rdx     # 0x1e9b1
callq 0x5ce4
movl 0x18(%r14), %edi
callq 0x82cf
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
leaq 0x163ca(%rip), %rsi     # 0x1f14a
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 0x8db8
callq 0x41e0
leaq 0x15da1(%rip), %rsi     # 0x1eb60
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 0x8df1
callq 0x41e0
jmp 0x8df1
jmp 0x8dee
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8dfe
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16320(%rip), %rsi     # 0x1f149
leaq 0x1631b(%rip), %rdx     # 0x1f14b
callq 0x5ce4
movl 0x18(%r14), %edi
callq 0x82cf
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
leaq 0x162fa(%rip), %rsi     # 0x1f14a
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 0x8e89
callq 0x41e0
leaq 0x162ba(%rip), %rsi     # 0x1f14a
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 0x8ec4
callq 0x41e0
leaq 0x15c95(%rip), %rsi     # 0x1eb60
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 0x8f03
jmp 0x8f0f
jmp 0x8f0c
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f0f
callq 0x41e0
jmp 0x8f0f
jmp 0x8f0c
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8f1c
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArithmeticOperatorNode::ArithmeticOperatorNode(ParseOperatorType, AbstractExpressionNode*, AbstractExpressionNode*)
ArithmeticOperatorNode::ArithmeticOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, AbstractExpressionNode* r) {
  operation = op;
  leftArg = l;
  rightArg = r;
  startLine = l->startLine;
  endLine = r->endLine;
  evalType = getTypeArithmeticExpression(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 0x22952(%rip), %rsi     # 0x2b888
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 0x16338
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_O1/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 0x22914(%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 0x163fa
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_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ComparisonOperatorNode::ComparisonOperatorNode(ParseOperatorType, AbstractExpressionNode*, AbstractExpressionNode*)
ComparisonOperatorNode::ComparisonOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, AbstractExpressionNode* r) { 
  operation = op;
  leftArg = l;
  rightArg = r;
  startLine = l->startLine;
  endLine = r->endLine;
  evalType = getTypeComparisonExpression(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 0x228d6(%rip), %rsi     # 0x2b8c8
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 0x1645b
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_O1/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 0x2289f(%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_O1/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 0x1591d(%rip), %rsi     # 0x1e9b0
leaq 0x15917(%rip), %rdx     # 0x1e9b1
callq 0x5ce4
movl 0x20(%r14), %edi
callq 0x82a8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
leaq 0x16090(%rip), %rsi     # 0x1f14a
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 0x90f2
callq 0x41e0
leaq 0x15a67(%rip), %rsi     # 0x1eb60
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 0x912b
callq 0x41e0
jmp 0x912b
jmp 0x9128
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9138
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x227b3(%rip), %rax     # 0x2b908
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movl %r8d, 0xc(%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_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayAccessNode::ArrayAccessNode(AbstractExpressionNode*, AbstractExpressionNode*, AbstractExpressionNode*, char*, unsigned int)
ArrayAccessNode::ArrayAccessNode(AbstractExpressionNode* arr, AbstractExpressionNode* s, AbstractExpressionNode* e, char* context, uint32_t endLin) {
  array = arr; start = s; end = e; endLine = endLin; isSlice = true;
  startLine = arr->startLine;
  endLine = endLin;
	this->context = context;
	evalType = arr->evalType;
	subType = arr->subType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2276d(%rip), %rax     # 0x2b908
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movl %r9d, 0xc(%rdi)
movb $0x1, 0x38(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl %r9d, 0xc(%rdi)
movq %r8, 0x30(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0x14(%rsi), %eax
movl %eax, 0x14(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15f51(%rip), %rsi     # 0x1f14c
leaq 0x15f4c(%rip), %rdx     # 0x1f14e
callq 0x5ce4
cmpb $0x1, 0x38(%r14)
jne 0x9283
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 0x923f
callq 0x41e0
leaq 0x15774(%rip), %rsi     # 0x1e9ba
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 0x927a
callq 0x41e0
leaq 0x15ece(%rip), %rsi     # 0x1f14f
jmp 0x928a
leaq 0x15728(%rip), %rsi     # 0x1e9b2
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 0x92c2
callq 0x41e0
leaq 0x15897(%rip), %rsi     # 0x1eb60
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 0x9305
jmp 0x9311
jmp 0x930e
jmp 0x92f5
jmp 0x930e
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9311
callq 0x41e0
jmp 0x9311
jmp 0x930e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x931e
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x225f4(%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_O1/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 0x14cd0(%rip), %rdx     # 0x1e051
movq %rdx, %rsi
callq 0x5ce4
leaq 0x15dc2(%rip), %rsi     # 0x1f152
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 0x93c8
callq 0x41e0
leaq 0x15d8e(%rip), %rsi     # 0x1f15d
movq %rbx, %rdi
callq 0x43a0
movl 0x14(%r14), %edi
callq 0x82a8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
leaq 0x155c0(%rip), %rsi     # 0x1e9b2
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 0x9424
callq 0x41e0
jmp 0x9424
jmp 0x9421
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9431
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: VariableNode::VariableNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, SymbolTable*, unsigned int)
VariableNode::VariableNode(std::string var, SymbolTable* table, uint32_t line) {
  symbolTable = table;
  variable = var;
  startLine = endLine = line;
  evalType = (symbolTable->get(var)).type;
	subType = (evalType == ARRAY_T) ? ((Array*) (symbolTable->get(var)).value.allocated)->subtype : 
						(evalType == STRING_T) ? CHAR_T :
						INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r12d
movq %rsi, %r15
movq %rdi, %r14
leaq 0x224ed(%rip), %rax     # 0x2b948
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
leaq 0x30(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movq %rdx, 0x18(%rdi)
movq %rbx, %rdi
callq 0x4140
movl %r12d, 0xc(%r14)
movl %r12d, 0x8(%r14)
movq 0x18(%r14), %r12
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x8ac2
leaq -0x70(%rbp), %rsi
movq %r12, %rdi
callq 0x1669a
movl %eax, 0x10(%r14)
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x94cb
callq 0x41e0
movl 0x10(%r14), %r13d
cmpl $0xc, %r13d
jne 0x9504
movq 0x18(%r14), %r12
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x8ac2
leaq -0x50(%rbp), %rsi
movq %r12, %rdi
callq 0x1669a
movl (%rdx), %eax
jmp 0x9513
xorl %eax, %eax
cmpl $0xb, %r13d
setne %al
leal (%rax,%rax,8), %eax
addl $0x8, %eax
movl %eax, 0x14(%r14)
cmpl $0xc, %r13d
jne 0x952f
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x952f
callq 0x41e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
jne 0x955e
jmp 0x956a
jmp 0x9567
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x956a
callq 0x41e0
jmp 0x956a
jmp 0x9567
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x9578
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: FunctionExpressionNode::FunctionExpressionNode(unsigned int, AbstractExpressionNode**, Function*, SymbolTable*, unsigned int, unsigned int)
FunctionExpressionNode::FunctionExpressionNode(uint32_t nArgs, AbstractExpressionNode** args, Function* f, SymbolTable* table, uint32_t startLine, uint32_t endLine) {
	numArgs = nArgs;
	arguments = args;
	function = f;
	symbolTable = table;
	evalType = f->returnType;
	subType = (evalType == STRING_T) ? CHAR_T :
						INVALID_T;

	isReturned = f->returnFlag;
	returnValue = f->returnValue;

  this->startLine = startLine;
  this->endLine = endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
leaq 0x22334(%rip), %r10     # 0x2b968
movq %r10, (%rdi)
movl %esi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movl 0x28(%rcx), %edx
movl %edx, 0x10(%rdi)
xorl %esi, %esi
cmpl $0xb, %edx
setne %sil
leal (%rsi,%rsi,8), %edx
addl $0x8, %edx
movl %edx, 0x14(%rdi)
movq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rdi)
movq 0x30(%rcx), %rcx
movq %rcx, 0x40(%rdi)
movl %r9d, 0x8(%rdi)
movl %eax, 0xc(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: LiteralNode::LiteralNode(ParseData, unsigned int)
LiteralNode::LiteralNode(ParseData d, uint32_t line) {
  data = d;
  startLine = endLine = line;
  evalType = d.type;
	subType = (d.type == STRING_T) ? CHAR_T :
						(d.type == ARRAY_T) ? ((Array*) d.value.allocated)->subtype :
						INVALID_T;
}

// Assembly:
leaq 0x222e3(%rip), %rax     # 0x2b988
movq %rax, (%rdi)
movl %esi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movl %ecx, 0xc(%rdi)
movl %ecx, 0x8(%rdi)
movl %esi, 0x10(%rdi)
cmpl $0xb, %esi
je 0x96cb
cmpl $0xc, %esi
jne 0x96d2
pushq %rbp
movq %rsp, %rbp
movl (%rdx), %eax
popq %rbp
jmp 0x96d7
movl $0x8, %eax
jmp 0x96d7
movl $0x11, %eax
movl %eax, 0x14(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: GroupedExpressionNode::GroupedExpressionNode(AbstractExpressionNode*, unsigned int, unsigned int)
GroupedExpressionNode::GroupedExpressionNode(AbstractExpressionNode* exp, uint32_t startLin, uint32_t endLin) {
  closedExpression = exp;
  startLine = startLin;
  endLine = endLin;
  evalType = exp->evalType;
	subType = (evalType == STRING_T) ? CHAR_T :
						(evalType == ARRAY_T) ? exp->subType :
						INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x22289(%rip), %rax     # 0x2b9a8
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
cmpl $0xb, %eax
je 0x9741
cmpl $0xc, %eax
jne 0x9748
movl 0x14(%rsi), %eax
jmp 0x974d
movl $0x8, %eax
jmp 0x974d
movl $0x11, %eax
movl %eax, 0x14(%rdi)
popq %rbp
retq