LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x16ea1(%rip), %rsi     # 0x1c11a
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x40a0
movl 0x34(%rbx), %esi
leaq -0x48(%rbp), %rdi
callq 0x54e9
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4370
leaq -0x48(%rbp), %rdi
callq 0x40e0
leaq 0x1bcad(%rip), %rsi     # 0x20f5c
leaq -0x28(%rbp), %rdi
callq 0x4360
movq 0x28(%rbx), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4360
leaq 0x16e70(%rip), %rsi     # 0x1c13c
leaq -0x28(%rbp), %rdi
callq 0x4360
leaq 0x8(%rbx), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4370
leaq 0x17e41(%rip), %rsi     # 0x1d12a
leaq -0x28(%rbp), %rdi
callq 0x4360
leaq 0x16e51(%rip), %rax     # 0x1c14a
leaq 0x16e99(%rip), %rsi     # 0x1c199
cmpb $0x0, 0x30(%rbx)
cmovneq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4360
movq -0x28(%rbp), %rdi
callq 0x152e4
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x40e0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x40e0
jmp 0x5348
jmp 0x5345
movq %rax, %rbx
jmp 0x5351
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4230
nop
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/errors.cpp
// Function: StaticCastError::what() const
const char* StaticCastError::what() const throw() {

  std::string str = "";

  if(startLineNumber == endLineNumber) {
    str.append("StaticCastError on line ");
    str.append(std::to_string(startLineNumber));
  } else {
    str.append("StaticCastError from line ");
    str.append(std::to_string(startLineNumber));
    str.append(" to line ");
    str.append(std::to_string(endLineNumber));
  }

  str.append("\n");
  str.append(context);

	if(message != NULL) {
		str.append(message);
		return copyString(str.c_str());
	}

  if(isExplicit) {
    str.append("Cannot cast at all from type ");
  } else {
    str.append("Cannot implicitly cast from type ");
  }
  
  str.append(toStringParseDataType(originalType));
  str.append(" to type ");
  str.append(toStringParseDataType(finalType));

  return copyString(str.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x16cc8(%rip), %rsi     # 0x1c035
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x40a0
movl 0x24(%rbx), %eax
cmpl 0x28(%rbx), %eax
jne 0x53ad
leaq 0x16e8e(%rip), %rsi     # 0x1c217
leaq -0x28(%rbp), %rdi
callq 0x4360
movl 0x24(%rbx), %esi
leaq -0x48(%rbp), %rdi
callq 0x54e9
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4370
jmp 0x5408
leaq 0x16e7c(%rip), %rsi     # 0x1c230
leaq -0x28(%rbp), %rdi
callq 0x4360
movl 0x24(%rbx), %esi
leaq -0x48(%rbp), %rdi
callq 0x54e9
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4370
leaq -0x48(%rbp), %rdi
callq 0x40e0
leaq 0x16ce6(%rip), %rsi     # 0x1c0cc
leaq -0x28(%rbp), %rdi
callq 0x4360
movl 0x28(%rbx), %esi
leaq -0x48(%rbp), %rdi
callq 0x54e9
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4370
leaq -0x48(%rbp), %rdi
callq 0x40e0
leaq 0x1bb44(%rip), %rsi     # 0x20f5c
leaq -0x28(%rbp), %rdi
callq 0x4360
movq 0x10(%rbx), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4360
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x5442
leaq -0x28(%rbp), %rdi
callq 0x4360
jmp 0x5499
leaq 0x16e02(%rip), %rax     # 0x1c24b
leaq 0x16e19(%rip), %rsi     # 0x1c269
cmpb $0x0, 0x20(%rbx)
cmovneq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4360
movl 0x8(%rbx), %edi
callq 0x730e
leaq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4360
leaq 0x16e0f(%rip), %rsi     # 0x1c28b
leaq -0x28(%rbp), %rdi
callq 0x4360
movl 0xc(%rbx), %edi
callq 0x730e
leaq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4360
movq -0x28(%rbp), %rdi
callq 0x152e4
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x40e0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x54be
jmp 0x54d5
jmp 0x54be
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x40e0
jmp 0x54d8
jmp 0x54d5
jmp 0x54d5
movq %rax, %rbx
jmp 0x54e1
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4230
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/exceptions.cpp
// Function: OutOfBoundsException::what() const
const char* OutOfBoundsException::what() const throw() {

	std::string str = "";

	if(startLine == endLine) {
		str.append("OutOfBoundsException on line ");
		str.append(std::to_string(startLine));
	} else {
		str.append("OutOfBoundsException from line ");
		str.append(std::to_string(startLine));
		str.append(" to ");
		str.append(std::to_string(endLine));
	}

	str.append(":\n\t");
	str.append(context);

	//error message
	str.append("The index ");
	str.append(std::to_string(index));
	str.append(" is out of bounds in ");
	str.append((isArray) ? "array" : "string");
	str.append(" of length ");
	str.append(std::to_string(length));

	return copyString(str.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1699a(%rip), %rsi     # 0x1c035
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x40a0
movl 0x1c(%rbx), %eax
cmpl 0x20(%rbx), %eax
jne 0x56db
leaq 0x16d12(%rip), %rsi     # 0x1c3c9
leaq -0x48(%rbp), %rdi
callq 0x4360
movl 0x1c(%rbx), %esi
leaq -0x28(%rbp), %rdi
callq 0x54e9
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4370
jmp 0x5736
leaq 0x16d05(%rip), %rsi     # 0x1c3e7
leaq -0x48(%rbp), %rdi
callq 0x4360
movl 0x1c(%rbx), %esi
leaq -0x28(%rbp), %rdi
callq 0x54e9
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4370
leaq -0x28(%rbp), %rdi
callq 0x40e0
leaq 0x1bbe6(%rip), %rsi     # 0x212fa
leaq -0x48(%rbp), %rdi
callq 0x4360
movl 0x20(%rbx), %esi
leaq -0x28(%rbp), %rdi
callq 0x54e9
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4370
leaq -0x28(%rbp), %rdi
callq 0x40e0
leaq 0x168ec(%rip), %rsi     # 0x1c032
leaq -0x48(%rbp), %rdi
callq 0x4360
movq 0x8(%rbx), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4360
leaq 0x16ca4(%rip), %rsi     # 0x1c407
leaq -0x48(%rbp), %rdi
callq 0x4360
movl 0x18(%rbx), %esi
leaq -0x28(%rbp), %rdi
callq 0x5847
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4370
leaq -0x28(%rbp), %rdi
callq 0x40e0
leaq 0x16c7d(%rip), %rsi     # 0x1c412
leaq -0x48(%rbp), %rdi
callq 0x4360
leaq 0x16c83(%rip), %rax     # 0x1c428
leaq 0x16c82(%rip), %rsi     # 0x1c42e
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x4360
leaq 0x16c71(%rip), %rsi     # 0x1c435
leaq -0x48(%rbp), %rdi
callq 0x4360
movl 0x14(%rbx), %esi
leaq -0x28(%rbp), %rdi
callq 0x5847
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4370
leaq -0x28(%rbp), %rdi
callq 0x40e0
movq -0x48(%rbp), %rdi
callq 0x152e4
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x40e0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x581e
jmp 0x5833
jmp 0x581e
jmp 0x581e
jmp 0x5833
jmp 0x5833
jmp 0x581e
jmp 0x5833
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x40e0
jmp 0x5836
jmp 0x5833
movq %rax, %rbx
jmp 0x583f
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4230
// File: /workspace/github_cpp_makefile_star2_O2/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 0x152e4
movq %rax, 0x18(%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x152e4
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x40c0
movq %rax, %r15
leaq 0x16d96(%rip), %r13     # 0x1c6ec
xorl %r14d, %r14d
cmpq $0xf8, %r14
je 0x599d
leaq 0x24da7(%rip), %rax     # 0x2a710
movq (%r14,%rax), %r12
movq %r12, %rdi
callq 0x40c0
movq %r15, %rdx
cmpq %rax, %r15
ja 0x5980
movq %rax, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40f0
addq $0x4, %r13
addq $0x8, %r14
testl %eax, %eax
jne 0x5959
movl (%r13), %eax
jmp 0x59a0
pushq $0x3b
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5b0c
imulq $0xa, %rax, %rax
movl %esi, %ecx
movsbq (%rdi,%rcx), %rcx
addq %rcx, %rax
addq $-0x30, %rax
incl %esi
jmp 0x5af2
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movsd 0x16d96(%rip), %xmm1    # 0x1c8b0
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd 0x16d90(%rip), %xmm3    # 0x1c8b8
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm4
cmpl %edx, %esi
ja 0x5b6f
movl %esi, %eax
movsbl (%rdi,%rax), %r8d
movb $0x1, %al
cmpl $0x2e, %r8d
je 0x5b69
addl $-0x30, %r8d
cvtsi2sd %r8d, %xmm5
testb $0x1, %cl
je 0x5b5f
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm4
jmp 0x5b69
mulsd %xmm3, %xmm0
addsd %xmm5, %xmm0
xorl %eax, %eax
incl %esi
movl %eax, %ecx
jmp 0x5b30
addsd %xmm2, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7113
cmpl $0xb, %ebx
jne 0x717c
movq %r15, %rdi
callq 0x152e4
jmp 0x7179
movl 0x4(%r15), %r12d
movq 0x8(%r15), %r13
pushq $0x10
popq %rdi
callq 0x4250
movl %r12d, 0x4(%rax)
movl (%r15), %ecx
movq %rax, -0x30(%rbp)
movl %ecx, (%rax)
cmpl $0x2, %r12d
pushq $0x1
popq %rdi
cmovgel %r12d, %edi
shlq $0x4, %rdi
callq 0x4250
movq %rax, %r15
shlq $0x4, %r12
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x7171
movl (%r13,%r14), %edi
movq 0x8(%r13,%r14), %rsi
callq 0x70ec
movl %eax, (%r15,%r14)
movq %rdx, 0x8(%r15,%r14)
addq $0x10, %r14
jmp 0x714e
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_O2/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
je 0x71e1
movl $0xa, %eax
retq
movl %edi, %eax
xorl $0x8, %eax
movl %esi, %ecx
xorl $0x8, %ecx
orl %eax, %ecx
jne 0x71f5
movl $0x8, %eax
retq
cmpl $0x8, %edi
movl $0x4, %eax
cmovel %eax, %edi
cmpl $0x8, %esi
cmovel %eax, %esi
xorl %edx, %edx
leaq 0x15bb1(%rip), %rax     # 0x1cdc0
leaq 0x15bba(%rip), %rcx     # 0x1cdd0
movzbl %dl, %edx
cmpl %edi, (%rax,%rdx,4)
je 0x7227
cmpl %edi, (%rcx,%rdx,4)
je 0x7227
incb %dl
jmp 0x7216
xorl %r8d, %r8d
movzbl %r8b, %r8d
cmpl %esi, (%rax,%r8,4)
je 0x723f
cmpl %esi, (%rcx,%r8,4)
je 0x723f
incb %r8b
jmp 0x722a
pushq %rbp
movq %rsp, %rbp
cmpb %r8b, %dl
cmovaq %rdx, %r8
addl $-0x4, %edi
addl $-0x4, %esi
cmpl $0x5, %esi
cmovaeq %rax, %rcx
cmpl $0x5, %edi
cmovaeq %rax, %rcx
movl (%rcx,%r8,4), %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movl %r9d, -0x2c(%rbp)
movq %r8, %r13
movq %rcx, %r14
movl %edx, %r12d
movq %rdi, %r15
leaq 0x22f4f(%rip), %rax     # 0x2a828
movq %rax, (%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %rbx, %rdi
callq 0x4140
movl %r12d, 0x38(%r15)
movq %r14, 0x40(%r15)
movq %r13, 0x48(%r15)
movl %r12d, 0x10(%r15)
cmpl $0xb, %r12d
je 0x791b
cmpl $0xc, %r12d
jne 0x791f
movl 0x14(%r14), %eax
jmp 0x7922
pushq $0x8
jmp 0x7921
pushq $0x11
popq %rax
movl %eax, 0x14(%r15)
movl -0x2c(%rbp), %eax
movl %eax, 0x8(%r15)
movl 0xc(%r14), %eax
movl %eax, 0xc(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22ed7(%rip), %rax     # 0x2a848
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_O2/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 0x22ea3(%rip), %rcx     # 0x2a868
movq %rcx, (%rdi)
movl %esi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movl 0x10(%rdx), %esi
movl %eax, %edi
callq 0x1413d
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_O2/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 0x22e4a(%rip), %rdx     # 0x2a868
movq %rdx, (%rdi)
movl %esi, 0x18(%rdi)
movq %r15, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movl 0x10(%r15), %esi
movl %eax, %edi
callq 0x1413d
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_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14edc(%rip), %rsi     # 0x1c970
leaq -0x30(%rbp), %rdx
callq 0x40a0
movl 0x18(%r14), %edi
callq 0x7335
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4360
leaq 0x15672(%rip), %rsi     # 0x1d12a
movq %rbx, %rdi
callq 0x4360
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x15036(%rip), %rsi     # 0x1cb20
movq %rbx, %rdi
callq 0x4360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x40e0
jmp 0x7b11
jmp 0x7b0e
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x155ef(%rip), %rsi     # 0x1d129
leaq -0x30(%rbp), %rdx
callq 0x40a0
movl 0x18(%r14), %edi
callq 0x7335
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4360
leaq 0x155cc(%rip), %rsi     # 0x1d12a
movq %rbx, %rdi
callq 0x4360
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x1559a(%rip), %rsi     # 0x1d12a
movq %rbx, %rdi
callq 0x4360
movq 0x28(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x14f5e(%rip), %rsi     # 0x1cb20
movq %rbx, %rdi
callq 0x4360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x7bda
jmp 0x7bea
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x40e0
jmp 0x7bed
jmp 0x7bea
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22c78(%rip), %rsi     # 0x2a888
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 0x1417a
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_O2/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 0x22c3a(%rip), %rsi     # 0x2a8a8
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 0x14222
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_O2/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 0x22bfc(%rip), %rsi     # 0x2a8c8
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 0x14281
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_O2/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 0x22bc5(%rip), %rax     # 0x2a8e8
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_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14c0c(%rip), %rsi     # 0x1c970
leaq -0x30(%rbp), %rdx
callq 0x40a0
movl 0x20(%r14), %edi
callq 0x730e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4360
leaq 0x153a2(%rip), %rsi     # 0x1d12a
movq %rbx, %rdi
callq 0x4360
movq 0x18(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x14d66(%rip), %rsi     # 0x1cb20
movq %rbx, %rdi
callq 0x4360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x40e0
jmp 0x7de1
jmp 0x7dde
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22b01(%rip), %rax     # 0x2a908
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_O2/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 0x22abf(%rip), %rax     # 0x2a908
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%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_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15292(%rip), %rsi     # 0x1d12c
leaq -0x30(%rbp), %rdx
callq 0x40a0
cmpb $0x1, 0x38(%r14)
jne 0x7f08
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x14aa6(%rip), %rsi     # 0x1c97a
movq %rbx, %rdi
callq 0x4360
movq 0x28(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x15229(%rip), %rsi     # 0x1d12f
jmp 0x7f0f
leaq 0x14a63(%rip), %rsi     # 0x1c972
movq %rbx, %rdi
callq 0x4360
movq 0x18(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x14bdf(%rip), %rsi     # 0x1cb20
movq %rbx, %rdi
callq 0x4360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x7f5d
jmp 0x7f6d
jmp 0x7f5d
jmp 0x7f6d
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x40e0
jmp 0x7f70
jmp 0x7f6d
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2299a(%rip), %r10     # 0x2a928
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_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14063(%rip), %rsi     # 0x1c035
leaq -0x30(%rbp), %rdx
callq 0x40a0
leaq 0x15150(%rip), %rsi     # 0x1d132
movq %rbx, %rdi
callq 0x4360
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x15129(%rip), %rsi     # 0x1d13d
movq %rbx, %rdi
callq 0x4360
movl 0x14(%r14), %edi
callq 0x730e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4360
leaq 0x1493b(%rip), %rsi     # 0x1c972
movq %rbx, %rdi
callq 0x4360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x40e0
jmp 0x805e
jmp 0x805b
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %r12d
movq %rdi, %r14
leaq 0x228be(%rip), %rax     # 0x2a948
movq %rax, (%rdi)
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r15
leaq 0x20(%rdi), %rbx
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), %rdi
movq %r15, %rsi
callq 0x4290
leaq -0x60(%rbp), %rsi
movq %r12, %rdi
callq 0x14476
movl %eax, 0x10(%r14)
leaq -0x60(%rbp), %rdi
callq 0x40e0
movl 0x10(%r14), %eax
cmpl $0xc, %eax
jne 0x8118
movq 0x18(%r14), %r12
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x4290
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x14476
movl (%rdx), %eax
movl %eax, 0x14(%r14)
leaq -0x40(%rbp), %rdi
callq 0x40e0
jmp 0x812a
xorl %ecx, %ecx
cmpl $0xb, %eax
setne %cl
leal (%rcx,%rcx,8), %eax
addl $0x8, %eax
movl %eax, 0x14(%r14)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
jmp 0x8149
jmp 0x8152
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x40e0
jmp 0x8155
jmp 0x8152
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2277e(%rip), %r10     # 0x2a968
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_O2/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 0x2272f(%rip), %rax     # 0x2a988
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 0x827f
cmpl $0xc, %esi
jne 0x8286
pushq %rbp
movq %rsp, %rbp
movl (%rdx), %eax
popq %rbp
jmp 0x828b
movl $0x8, %eax
jmp 0x828b
movl $0x11, %eax
movl %eax, 0x14(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x226d5(%rip), %rax     # 0x2a9a8
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 0x82f5
cmpl $0xc, %eax
jne 0x82fc
movl 0x14(%rsi), %eax
jmp 0x8301
movl $0x8, %eax
jmp 0x8301
movl $0x11, %eax
movl %eax, 0x14(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: GroupedExpressionNode::toString[abi:cxx11]()
std::string GroupedExpressionNode::toString() {
  std::string str = "(";
  str.append(closedExpression->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14648(%rip), %rsi     # 0x1c970
leaq -0x30(%rbp), %rdx
callq 0x40a0
movq 0x18(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
callq 0x40e0
leaq 0x147c5(%rip), %rsi     # 0x1cb20
movq %rbx, %rdi
callq 0x4360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x837f
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x40e0
jmp 0x8382
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<bool, char*>(bool, char*, ParseDataType)
ParseData additionHelper<bool, char*>(bool n1, char* n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  const char* arg1Str = (arg1) ? "true" : "false";
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r14
movl %edi, %r15d
leaq 0x1411e(%rip), %rax     # 0x1c6da
leaq 0x1411c(%rip), %r12     # 0x1c6df
testl %edi, %edi
cmovneq %rax, %r12
xorl $0x5, %r15d
movq %rsi, %rdi
callq 0x40c0
movq %rax, %r13
addl %r15d, %eax
movq %rax, -0x38(%rbp)
leal (%r15,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, bool>(char*, bool, ParseDataType)
ParseData additionHelper<char*, bool>(char* n1, bool n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  bool arg2 = (bool) n2;
  const char* arg2Str = (arg2) ? "true" : "false";
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movl %esi, %r14d
movq %rdi, %r12
leaq 0x1408e(%rip), %rax     # 0x1c6da
leaq 0x1408c(%rip), %r15     # 0x1c6df
testl %esi, %esi
cmovneq %rax, %r15
callq 0x40c0
movq %rax, %r13
xorl $0x5, %r14d
addl %r14d, %eax
movq %rax, -0x38(%rbp)
leal (%r14,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r13d, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4160
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, int>(char*, int, ParseDataType)
ParseData additionHelper<char*, int32_t>(char* n1, int32_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  int32_t arg2 = (int32_t) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rdi, %r15
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x5847
movq (%r12), %r14
movq %r12, %rdi
callq 0x40e0
movq %r15, %rdi
callq 0x40c0
movq %rax, %r12
movq %r14, %rdi
callq 0x40c0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<int, char*>(int, char*, ParseDataType)
ParseData additionHelper<int32_t, char*>(int32_t n1, char* n2, ParseDataType type) {

  int32_t arg1 = (int32_t) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r14
movl %edi, %esi
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x5847
movq (%r12), %r15
movq %r12, %rdi
callq 0x40e0
movq %r15, %rdi
callq 0x40c0
movq %rax, %r12
movq %r14, %rdi
callq 0x40c0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<Array*, Array*>(Array*, Array*, ParseDataType)
ParseData additionHelper<Array*, Array*>(Array* a1, Array* a2, ParseDataType type) {

	//get fields out of the array structs
	uint32_t len1 = a1->length;
	uint32_t len2 = a2->length;
	ParseDataType type1 = a1->subtype;
	ParseDataType type2 = a2->subtype;
	ParseData* values1 = a1->values;
	ParseData* values2 = a2->values;

	uint32_t length = len1 + len2;
	ParseDataType finalType = getTypeArithmeticExpression(ADD_OP, type1, type2);
	ParseData* values = (ParseData*) malloc(sizeof(ParseData) * length);

	for(uint32_t i = 0; i < len1; i++) {
		values[i] = castHelper(values1[i], finalType);
	}

	for(uint32_t i = 0; i < len2; i++) {
		values[i+len1] = castHelper(values2[i], finalType);
	}

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

	ParseData d;
	d.type = ARRAY_T;
	d.value.allocated = (void*) arr;

	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
movl 0x4(%rdi), %r15d
movl (%rsi), %edx
movl 0x4(%rsi), %ecx
movq 0x8(%rdi), %r13
movq 0x8(%rsi), %rsi
movq %rsi, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
leal (%rcx,%r15), %ebx
pushq $0xf
popq %rdi
movl %eax, %esi
callq 0x1417a
movl %eax, -0x2c(%rbp)
movq %rbx, -0x48(%rbp)
movq %rbx, %rdi
shlq $0x4, %rdi
callq 0x4250
movq %rax, %r14
movq %r15, %r12
shlq $0x4, %r12
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x8e11
movl (%r13,%rbx), %edi
movq 0x8(%r13,%rbx), %rsi
movl -0x2c(%rbp), %edx
callq 0x13380
movl %eax, (%r14,%rbx)
movq %rdx, 0x8(%r14,%rbx)
addq $0x10, %rbx
jmp 0x8deb
movq -0x40(%rbp), %rbx
shlq $0x4, %rbx
xorl %r13d, %r13d
movq -0x38(%rbp), %r12
cmpq %r13, %rbx
je 0x8e4f
movl (%r12,%r13), %edi
movq 0x8(%r12,%r13), %rsi
movl -0x2c(%rbp), %edx
callq 0x13380
movl %r15d, %ecx
shlq $0x4, %rcx
movl %eax, (%r14,%rcx)
movq %rdx, 0x8(%r14,%rcx)
addq $0x10, %r13
incl %r15d
jmp 0x8e20
pushq $0x10
popq %rdi
callq 0x4250
movq %rax, %rdx
movq -0x48(%rbp), %rax
movl %eax, 0x4(%rdx)
movl -0x2c(%rbp), %eax
movl %eax, (%rdx)
movq %r14, 0x8(%rdx)
pushq $0xc
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq