LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22639(%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 0x897a
leaq -0x70(%rbp), %rsi
movq %r12, %rdi
callq 0x165ec
movl %eax, 0x10(%r14)
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x9383
callq 0x41e0
movl 0x10(%r14), %eax
cmpl $0xc, %eax
jne 0x93c9
movq 0x18(%r14), %r12
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x897a
leaq -0x50(%rbp), %rsi
movq %r12, %rdi
callq 0x165ec
movl (%rdx), %eax
movl %eax, 0x14(%r14)
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x93db
callq 0x41e0
jmp 0x93db
xorl %ecx, %ecx
cmpl $0xb, %eax
setne %cl
leal (%rcx,%rcx,8), %eax
addl $0x8, %eax
movl %eax, 0x14(%r14)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
jmp 0x93fc
jmp 0x940a
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x940d
callq 0x41e0
jmp 0x940d
jmp 0x940a
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x941b
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2243f(%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 0x956f
cmpl $0xc, %esi
jne 0x9576
pushq %rbp
movq %rsp, %rbp
movl (%rdx), %eax
popq %rbp
jmp 0x957b
movl $0x8, %eax
jmp 0x957b
movl $0x11, %eax
movl %eax, 0x14(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x223e5(%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 0x95e5
cmpl $0xc, %eax
jne 0x95ec
movl 0x14(%rsi), %eax
jmp 0x95f1
movl $0x8, %eax
jmp 0x95f1
movl $0x11, %eax
movl %eax, 0x14(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x1536f(%rip), %rsi     # 0x1e990
leaq 0x15369(%rip), %rdx     # 0x1e991
callq 0x5cb8
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 0x965d
callq 0x41e0
leaq 0x154dc(%rip), %rsi     # 0x1eb40
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9693
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9696
callq 0x41e0
jmp 0x9696
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x96a3
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14e1a(%rip), %rax     # 0x1e6fa
leaq 0x14e18(%rip), %r12     # 0x1e6ff
testl %edi, %edi
cmovneq %rax, %r12
xorl $0x5, %r15d
movq %rsi, %rdi
callq 0x40e0
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_O3/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)
movl %esi, %r12d
movq %rdi, -0x40(%rbp)
movl %esi, %r15d
negl %r15d
cmovsl %esi, %r15d
movl $0x1, %r13d
cmpl $0xa, %r15d
jb 0x9a57
movl $0x4, %r13d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r15d, %ecx
cmpl $0x63, %ecx
jbe 0x9a4e
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x9a54
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x9a57
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r13d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x9a1b
addl $-0x3, %r13d
jmp 0x9a57
addl $-0x2, %r13d
jmp 0x9a57
decl %r13d
shrl $0x1f, %r12d
leal (%r12,%r13), %esi
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x4250
addq (%rbx), %r12
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x5c46
movq (%rbx), %r15
cmpq %r14, %r15
je 0x9a99
movq %r15, %rdi
callq 0x41e0
movq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x40e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
addl %ebx, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%rbx), %edi
incl %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %ebx, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
movl %r12d, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, long>(char*, long, ParseDataType)
ParseData additionHelper<char*, int64_t>(char* n1, int64_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  int64_t arg2 = (int64_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 %rsi, %r12
movq %rdi, -0x40(%rbp)
movq %rsi, %r15
negq %r15
cmovsq %rsi, %r15
movl $0x1, %r13d
cmpq $0xa, %r15
jb 0x9b8d
movl $0x4, %r13d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x9b84
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x9b8a
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x9b8d
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r13d
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x9b4c
addl $-0x3, %r13d
jmp 0x9b8d
addl $-0x2, %r13d
jmp 0x9b8d
decl %r13d
shrq $0x3f, %r12
leal (%r12,%r13), %esi
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x4250
addq (%rbx), %r12
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x8849
movq (%rbx), %r15
cmpq %r14, %r15
je 0x9bcf
movq %r15, %rdi
callq 0x41e0
movq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x40e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
addl %ebx, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%rbx), %edi
incl %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %ebx, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
movl %r12d, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, unsigned int>(char*, unsigned int, ParseDataType)
ParseData additionHelper<char*, uint32_t>(char* n1, uint32_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  uint32_t arg2 = (uint32_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)
movl %esi, %r15d
movq %rdi, %r14
movl $0x1, %eax
cmpl $0xa, %esi
jb 0x9ca7
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r15d, %edx
cmpl $0x63, %edx
jbe 0x9ca0
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x9ca5
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x9ca7
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x9c6f
addl $-0x3, %eax
jmp 0x9ca7
addl $-0x2, %eax
jmp 0x9ca7
decl %eax
movl %eax, %esi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4250
movq (%r12), %rdi
movl 0x8(%r12), %esi
movl %r15d, %edx
callq 0x5c46
movq (%r12), %r15
cmpq %rbx, %r15
je 0x9ce1
movq %r15, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
movq %r15, %rdi
callq 0x40e0
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 %r14, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r15, %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_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, unsigned long>(char*, unsigned long, ParseDataType)
ParseData additionHelper<char*, uint64_t>(char* n1, uint64_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  uint64_t arg2 = (uint64_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 %rsi, %r15
movq %rdi, %r14
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x9dbe
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x9db7
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x9dbc
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x9dbe
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x9d81
addl $-0x3, %esi
jmp 0x9dbe
addl $-0x2, %esi
jmp 0x9dbe
decl %esi
movl %esi, %esi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4250
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x8849
movq (%r12), %r15
cmpq %rbx, %r15
je 0x9df8
movq %r15, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
movq %r15, %rdi
callq 0x40e0
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 %r14, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r15, %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_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, double>(char*, double, ParseDataType)
ParseData additionHelper<char*, double>(char* n1, double n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  double arg2 = (double) 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 %esi, -0x2c(%rbp)
movq %rdi, %r14
movq 0x22139(%rip), %rsi     # 0x2bfb8
leaq 0x151cd(%rip), %rcx     # 0x1f053
leaq -0x58(%rbp), %r15
movl $0x148, %edx            # imm = 0x148
movq %r15, %rdi
movb $0x1, %al
callq 0x88c9
movq (%r15), %r15
leaq -0x48(%rbp), %rax
cmpq %rax, %r15
je 0x9ead
movq %r15, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
movq %r15, %rdi
callq 0x40e0
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 %r14, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r15, %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_O3/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, -0x40(%rbp)
movl %edi, %r12d
movl %edi, %r15d
negl %r15d
cmovsl %edi, %r15d
movl $0x1, %r13d
cmpl $0xa, %r15d
jb 0xa071
movl $0x4, %r13d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r15d, %ecx
cmpl $0x63, %ecx
jbe 0xa068
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0xa06e
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0xa071
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r13d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0xa035
addl $-0x3, %r13d
jmp 0xa071
addl $-0x2, %r13d
jmp 0xa071
decl %r13d
shrl $0x1f, %r12d
leal (%r12,%r13), %esi
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x4250
addq (%rbx), %r12
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x5c46
movq (%rbx), %r15
cmpq %r14, %r15
je 0xa0b3
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %rbx
movq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
addl %ebx, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%rbx), %edi
incl %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %ebx, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movl %r12d, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<long, char*>(long, char*, ParseDataType)
ParseData additionHelper<int64_t, char*>(int64_t n1, char* n2, ParseDataType type) {

  int64_t arg1 = (int64_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, -0x40(%rbp)
movq %rdi, %r12
movq %rdi, %r15
negq %r15
cmovsq %rdi, %r15
movl $0x1, %r13d
cmpq $0xa, %r15
jb 0xa1a7
movl $0x4, %r13d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0xa19e
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0xa1a4
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0xa1a7
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r13d
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0xa166
addl $-0x3, %r13d
jmp 0xa1a7
addl $-0x2, %r13d
jmp 0xa1a7
decl %r13d
shrq $0x3f, %r12
leal (%r12,%r13), %esi
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x4250
addq (%rbx), %r12
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x8849
movq (%rbx), %r15
cmpq %r14, %r15
je 0xa1e9
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %rbx
movq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
addl %ebx, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%rbx), %edi
incl %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %ebx, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movl %r12d, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<unsigned int, char*>(unsigned int, char*, ParseDataType)
ParseData additionHelper<uint32_t, char*>(uint32_t n1, char* n2, ParseDataType type) {

  uint32_t arg1 = (uint32_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, %r15d
movl $0x1, %eax
cmpl $0xa, %edi
jb 0xa2c1
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r15d, %edx
cmpl $0x63, %edx
jbe 0xa2ba
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0xa2bf
cmpl $0x2710, %edx           # imm = 0x2710
jb 0xa2c1
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0xa289
addl $-0x3, %eax
jmp 0xa2c1
addl $-0x2, %eax
jmp 0xa2c1
decl %eax
movl %eax, %esi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4250
movq (%r12), %rdi
movl 0x8(%r12), %esi
movl %r15d, %edx
callq 0x5c46
movq (%r12), %r15
cmpq %rbx, %r15
je 0xa2fb
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
movq %r14, %rdi
callq 0x40e0
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_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<unsigned long, char*>(unsigned long, char*, ParseDataType)
ParseData additionHelper<uint64_t, char*>(uint64_t n1, char* n2, ParseDataType type) {

  uint64_t arg1 = (uint64_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
movq %rdi, %r15
movl $0x1, %esi
cmpq $0xa, %rdi
jb 0xa3d8
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0xa3d1
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0xa3d6
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0xa3d8
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0xa39b
addl $-0x3, %esi
jmp 0xa3d8
addl $-0x2, %esi
jmp 0xa3d8
decl %esi
movl %esi, %esi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4250
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x8849
movq (%r12), %r15
cmpq %rbx, %r15
je 0xa412
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
movq %r14, %rdi
callq 0x40e0
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_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<double, char*>(double, char*, ParseDataType)
ParseData additionHelper<double, char*>(double n1, char* n2, ParseDataType type) {

  double arg1 = (double) 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 %esi, -0x2c(%rbp)
movq %rdi, %r14
movq 0x21b1f(%rip), %rsi     # 0x2bfb8
leaq 0x14bb3(%rip), %rcx     # 0x1f053
leaq -0x58(%rbp), %r15
movl $0x148, %edx            # imm = 0x148
movq %r15, %rdi
movb $0x1, %al
callq 0x88c9
movq (%r15), %r15
leaq -0x48(%rbp), %rax
cmpq %rax, %r15
je 0xa4c7
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
movq %r14, %rdi
callq 0x40e0
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_O3/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), %r12
movq 0x8(%rsi), %rsi
movq %rsi, -0x38(%rbp)
movq %rcx, -0x48(%rbp)
leal (%rcx,%r15), %ebx
movl $0xf, %edi
movl %eax, %esi
callq 0x162b0
movl %eax, -0x2c(%rbp)
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
shlq $0x4, %rdi
callq 0x4290
movq %rax, %r14
testq %r15, %r15
je 0xa5b3
movq %r15, %r13
shlq $0x4, %r13
xorl %ebx, %ebx
movl (%r12,%rbx), %edi
movq 0x8(%r12,%rbx), %rsi
movl -0x2c(%rbp), %edx
callq 0x15094
movl %eax, (%r14,%rbx)
movq %rdx, 0x8(%r14,%rbx)
addq $0x10, %rbx
cmpq %rbx, %r13
jne 0xa590
movq -0x48(%rbp), %rbx
testq %rbx, %rbx
movq -0x38(%rbp), %r13
je 0xa5f5
shlq $0x4, %rbx
xorl %r12d, %r12d
movl (%r13,%r12), %edi
movq 0x8(%r13,%r12), %rsi
movl -0x2c(%rbp), %edx
callq 0x15094
movl %r15d, %ecx
shlq $0x4, %rcx
movl %eax, (%r14,%rcx)
movq %rdx, 0x8(%r14,%rcx)
incl %r15d
addq $0x10, %r12
cmpq %r12, %rbx
jne 0xa5c7
movl $0x10, %edi
callq 0x4290
movq %rax, %rdx
movq -0x40(%rbp), %rax
movl %eax, 0x4(%rdx)
movl -0x2c(%rbp), %eax
movl %eax, (%rdx)
movq %r14, 0x8(%rdx)
movl $0xc, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData divisionHelper<unsigned char, double>(unsigned char, double, ParseDataType)
ParseData divisionHelper(T1 n1, T2 n2, ParseDataType type) {
 
  //first store the values in appropriate variables
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = type;
  
  switch(type) {
    case CHAR_T: d.value.integer = (unsigned char) (arg1/arg2); break;
    case INT32_T: d.value.integer = (int32_t) (arg1/arg2); break;
    case INT64_T: d.value.integer = (int64_t) (arg1/arg2); break;
    case UINT32_T: d.value.integer = (uint32_t) (arg1/arg2); break;
    case UINT64_T: d.value.integer = (uint64_t) (arg1/arg2); break;
    case DOUBLE_T: d.value.floatingPoint = (double) (arg1/arg2); break;
  }
 
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
leal -0x2(%rax), %ecx
cmpl $0x8, %ecx
ja 0xc3af
leaq 0x1370a(%rip), %rdx     # 0x1fa20
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %ecx
movslq %ecx, %rdx
jmp 0xc3af
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movl %ecx, %edx
jmp 0xc3af
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
movq %xmm1, %rdx
jmp 0xc3af
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rdx
jmp 0xc3af
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
subsd 0x13689(%rip), %xmm1    # 0x1fa18
cvttsd2si %xmm1, %rdx
andq %rsi, %rdx
orq %rcx, %rdx
jmp 0xc3af
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %ecx
movzbl %cl, %edx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData modHelper<int, unsigned long>(int, unsigned long, ParseDataType)
ParseData modHelper(T1 n1, T2 n2, ParseDataType type) {
 
  //first store the values in appropriate variables
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = type;
  
  switch(type) {
    case CHAR_T: d.value.integer = (unsigned char) (arg1 % arg2); break;
    case INT32_T: d.value.integer = (int32_t) (arg1 % arg2); break;
    case INT64_T: d.value.integer = (int64_t) (arg1 % arg2); break;
    case UINT32_T: d.value.integer = (uint32_t) (arg1 % arg2); break;
    case UINT64_T: d.value.integer = (uint64_t) (arg1 % arg2); break;
  }
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %ecx
leal -0x2(%rcx), %eax
cmpl $0x6, %eax
ja 0xe6a0
leaq 0x11d93(%rip), %rdx     # 0x203fc
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
jmp 0xe6a0
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movslq %edx, %rdx
jmp 0xe6a0
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movl %edx, %edx
jmp 0xe6a0
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movzbl %dl, %edx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/assignmenteval.cpp
// Function: evaluateAssignmentExpression(AssignmentExpressionNode*)
ParseData evaluateAssignmentExpression(AssignmentExpressionNode* node) {

  //get stuff out of the node first
  SymbolTable* symbolTable = node->symbolTable;
  std::string variable = node->variable;
  AbstractExpressionNode* value = node->value;
  
  ParseDataType type = node->evalType;
  ParseData d = value->evaluate();
  
  //update variable value (innermost scope)
  symbolTable->update(variable, castHelper(d, type));
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %r15
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x897a
movq 0x40(%rbx), %rdi
movl 0x10(%rbx), %r12d
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebx
movq %rdx, %r14
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x897a
movl %ebx, %edi
movq %r14, %rsi
movl %r12d, %edx
callq 0x15094
movq %rdx, %rcx
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
movl %eax, %edx
callq 0x16514
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x10c96
callq 0x41e0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10ca8
callq 0x41e0
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x10cd2
callq 0x41e0
jmp 0x10cd2
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10ce4
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/bitlogicaleval.cpp
// Function: logicHelper(bool, bool, ParseOperatorType)
ParseData logicHelper(bool n1, bool n2, ParseOperatorType op) {
 
  ParseData d;
  d.type = BOOL_T;
  
  switch(op) {
    case AND_OP: d.value.integer = n1 && n2; break;
    case XOR_OP: d.value.integer = n1 ^ n2; break;
    case OR_OP: d.value.integer = n1 || n2; break;
  }
 
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1e, %edx
je 0x10e3f
movl %edx, %eax
cmpl $0x1d, %edx
je 0x10e3a
cmpl $0x1c, %eax
jne 0x10e46
andb %sil, %dil
jmp 0x10e42
xorb %sil, %dil
jmp 0x10e42
orb %sil, %dil
movzbl %dil, %edx
movl $0x9, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/comparisoneval.cpp
// Function: ParseData inequalityHelper<char*, char*>(char*, char*, ParseOperatorType)
ParseData inequalityHelper<char*, char*>(char* str1, char* str2, ParseOperatorType op) {
 
  char* arg1 = str1;
  char* arg2 = str2;
  
  ParseData d;
  d.type = BOOL_T;
  int32_t res = strcmp(str1, str2);
  
  switch(op) { 
    case GREATER_OP: d.value.integer = res > 0; break;
    case GREATER_EQ_OP: d.value.integer = res >= 0; break;
    case LESS_OP: d.value.integer = res < 0; break;
    case LESS_EQ_OP: d.value.integer = res <= 0; break;
  }
  
  return d; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %ebx
callq 0x42d0
addl $-0x13, %ebx
cmpl $0x3, %ebx
ja 0x13948
leaq 0xec00(%rip), %rcx      # 0x2251c
movslq (%rcx,%rbx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorl %edx, %edx
testl %eax, %eax
setg %dl
jmp 0x13948
xorl %edx, %edx
testl %eax, %eax
setns %dl
jmp 0x13948
xorl %edx, %edx
testl %eax, %eax
setle %dl
jmp 0x13948
shrl $0x1f, %eax
movq %rax, %rdx
jmp 0x13948
movl $0x9, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/comparisoneval.cpp
// Function: ParseData equalityHelper<char*, char*>(char*, char*, ParseOperatorType)
ParseData equalityHelper<char*, char*>(char* str1, char* str2, ParseOperatorType op) {
 
  char* arg1 = str1;
  char* arg2 = str2;
  
  ParseData d;
  d.type = BOOL_T;
  int32_t res = strcmp(str1, str2);
  
  switch(op) { 
    case EQ_EQ_OP: d.value.integer = res == 0; break;
    case NOT_EQ_OP: d.value.integer = res != 0; break;
  }
  
  return d; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %ebx
callq 0x42d0
cmpl $0x18, %ebx
je 0x13974
cmpl $0x17, %ebx
jne 0x1397b
xorl %edx, %edx
testl %eax, %eax
sete %dl
jmp 0x1397b
xorl %edx, %edx
testl %eax, %eax
setne %dl
movl $0x9, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/functioneval.cpp
// Function: evaluateFunctionExpression(FunctionExpressionNode*)
ParseData evaluateFunctionExpression(FunctionExpressionNode* node) {
	
	SymbolTable* symbolTable = node->symbolTable;

	//function information
	Function* function = node->function;
	uint32_t numArgs = node->numArgs;
	AbstractExpressionNode** args = node->arguments;
	char** argNames = function->argNames;
	vector<AbstractStatementNode*>* body = function->body;
	
	
	//evaluate parameters
	ParseData* arguments = (ParseData*) malloc(sizeof(ParseData) * numArgs);
	for(uint32_t i = 0; i < numArgs; i++) {
		arguments[i] = args[i]->evaluate();
	}

	//enter function scope
	symbolTable->enterNewScope();

	//declare parameters with computed arguments
	for(uint32_t i = 0; i < numArgs; i++) {
		symbolTable->declare(argNames[i], arguments[i]);
	}

	//execute statements in the body
	vector<AbstractStatementNode*>::iterator it;
	bool* returnFlag = node->isReturned;
	*returnFlag = false;
	for(it = body->begin(); !(*returnFlag) && it != body->end(); it++) {
		(*it)->execute();
	}

	//return value placed in correct address by return statement
	symbolTable->leaveScope();
	return *(node->returnValue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x30(%rdi), %r14
movq 0x28(%rdi), %rax
movl 0x18(%rdi), %r12d
movq %rdi, -0x48(%rbp)
movq 0x20(%rdi), %r13
movq 0x18(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x20(%rax), %rbx
movq %r12, %rdi
shlq $0x4, %rdi
callq 0x4290
testq %r12, %r12
movq %r14, -0x38(%rbp)
je 0x14ca9
movq %rax, %r15
movq %r12, -0x40(%rbp)
leaq (,%r12,8), %r14
xorl %r12d, %r12d
movq (%r13,%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, (%r15,%r12,2)
movq %rdx, 0x8(%r15,%r12,2)
addq $0x8, %r12
cmpq %r12, %r14
jne 0x14c30
movq -0x38(%rbp), %rdi
callq 0x16468
cmpq $0x0, -0x40(%rbp)
je 0x14cb1
xorl %r13d, %r13d
leaq -0x70(%rbp), %r12
movq -0x50(%rbp), %rax
movq (%rax,%r13), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x40c0
movl (%r15,%r13,2), %edx
movq 0x8(%r15,%r13,2), %rcx
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x164ea
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x14c9e
callq 0x41e0
addq $0x8, %r13
cmpq %r13, %r14
jne 0x14c63
jmp 0x14cb1
movq %r14, %rdi
callq 0x16468
movq -0x48(%rbp), %r12
movq 0x38(%r12), %r14
movb $0x0, (%r14)
movq (%rbx), %r15
cmpq 0x8(%rbx), %r15
je 0x14cd9
movq (%r15), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r15
cmpb $0x1, (%r14)
jne 0x14cc1
movq -0x38(%rbp), %rdi
callq 0x164d8
movq 0x40(%r12), %rcx
movl (%rcx), %eax
movq 0x8(%rcx), %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x14d11
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/memberaccesseval.cpp
// Function: elementHelper(ArrayAccessNode*, ParseData, int)
ParseData elementHelper(ArrayAccessNode* node, ParseData arr, int32_t index) {
  
  ParseData d;
	ParseDataType type = arr.type;
	
	if(arr.type == STRING_T) {

		d.type = CHAR_T;
		char* str = (char*) arr.value.allocated;
		int32_t len = strlen(str);
		
		int32_t ind = index;
		if(ind < 0)
			ind += len+1;

		//if index is out-of-bounds, throw exception
		if(ind < 0 || ind > len-1) {
			throw OutOfBoundsException(false, len, index, copyString(node->context), node->startLine, node->endLine);
		}

		d.value.integer = str[ind];
		return d;
		
	} else if(type == ARRAY_T) {

		Array* array = (Array*) arr.value.allocated;
		int32_t len = array->length;
		ParseData* values = array->values;

		int32_t ind = index;
		if(ind < 0)
			ind += len; 
		
		//if index is out-of-bounds, throw exception
		if(ind < 0 || ind > len-1) {
			throw OutOfBoundsException(true, len, index, copyString(node->context), node->startLine, node->endLine);
		}

		ParseData val = values[ind];
		return val;
	}

  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r14
cmpl $0xc, %esi
je 0x14f4f
movl $0x8, %r12d
cmpl $0xb, %esi
jne 0x14f79
movq %r15, %rdi
callq 0x40e0
movq %rax, %r13
leal 0x1(%rax), %ecx
movl %ebx, %eax
sarl $0x1f, %eax
andl %ecx, %eax
addl %ebx, %eax
js 0x14f8b
cmpl %r13d, %eax
jge 0x14f8b
movl %eax, %eax
movsbq (%r15,%rax), %rdx
jmp 0x14f79
movl 0x4(%r15), %r12d
movl %ebx, %eax
sarl $0x1f, %eax
andl %r12d, %eax
addl %ebx, %eax
js 0x14fc2
cmpl %r12d, %eax
jge 0x14fc2
movq 0x8(%r15), %rcx
movl %eax, %eax
shlq $0x4, %rax
movl (%rcx,%rax), %r12d
movq 0x8(%rcx,%rax), %rdx
jmp 0x14f79
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x4110
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x175e8
movq 0x8(%r14), %rcx
leaq 0x16724(%rip), %rdx     # 0x2b6d0
addq $0x10, %rdx
movq %rdx, (%r15)
movq %rax, 0x8(%r15)
movb $0x0, 0x10(%r15)
movl %r13d, 0x14(%r15)
jmp 0x14ff7
movl $0x28, %edi
callq 0x4110
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x175e8
movq 0x8(%r14), %rcx
leaq 0x166ed(%rip), %rdx     # 0x2b6d0
addq $0x10, %rdx
movq %rdx, (%r15)
movq %rax, 0x8(%r15)
movb $0x1, 0x10(%r15)
movl %r12d, 0x14(%r15)
movl %ebx, 0x18(%r15)
movq %rcx, 0x1c(%r15)
leaq 0x166f2(%rip), %rsi     # 0x2b6f8
movq 0x16fcb(%rip), %rdx     # 0x2bfd8
movq %r15, %rdi
callq 0x4350
jmp 0x15017
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/memberaccesseval.cpp
// Function: evaluateArrayAccess(ArrayAccessNode*)
ParseData evaluateArrayAccess(ArrayAccessNode* node) {
  
	ParseDataType type = node->evalType;
  ParseData array = node->array->evaluate();
  ParseData start = node->start->evaluate();
  ParseData end;
  
  if(node->isSlice)
    end = node->end->evaluate();
  
  if(node->isSlice) {
    return sliceHelper(node, array, (int32_t) start.value.integer, (int32_t) end.value.integer);
  } else {
    return elementHelper(node, array, (int32_t) start.value.integer); 
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %r15d
movq %rdx, %r14
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rdx, %r12
movb 0x38(%rbx), %al
cmpb $0x1, %al
jne 0x15069
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rdx, %r8
movb 0x38(%rbx), %al
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r12d, %ecx
testb $0x1, %al
je 0x15086
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14d1c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14f02
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ExpressionStatementNode::ExpressionStatementNode(AbstractExpressionNode*, SymbolTable*)
ExpressionStatementNode::ExpressionStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable) {
  expression = exp;
  this->symbolTable = symbolTable;
	startLine = exp->startLine;
	endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1645d(%rip), %rax     # 0x2bb60
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: PrintStatementNode::PrintStatementNode(AbstractExpressionNode*, SymbolTable*, unsigned int)
PrintStatementNode::PrintStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable, uint32_t startLine) {
  expression = exp;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x16447(%rip), %rax     # 0x2bb78
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movl %ecx, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: PrintLineStatementNode::PrintLineStatementNode(AbstractExpressionNode*, SymbolTable*, unsigned int)
PrintLineStatementNode::PrintLineStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable, uint32_t startLine) {
  expression = exp;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x16433(%rip), %rax     # 0x2bb90
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movl %ecx, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: GroupedStatementNode::GroupedStatementNode(std::vector<AbstractStatementNode*, std::allocator<AbstractStatementNode*>>*, SymbolTable*, unsigned int, unsigned int)
GroupedStatementNode::GroupedStatementNode(std::vector<AbstractStatementNode*>* s, SymbolTable* symbolTable, uint32_t startLine, uint32_t endLine) {
  statements = s;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1641f(%rip), %rax     # 0x2bba8
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: WhileStatementNode::WhileStatementNode(AbstractExpressionNode*, AbstractStatementNode*, SymbolTable*, unsigned int)
WhileStatementNode::WhileStatementNode(AbstractExpressionNode* cond, AbstractStatementNode* bod, SymbolTable* symbolTable, uint32_t startLine) {
  condition = cond;
  body = bod;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = bod->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x163f7(%rip), %rax     # 0x2bbd8
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movl %r8d, 0x8(%rdi)
movl 0xc(%rdx), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: WhileStatementNode::execute()
void WhileStatementNode::execute() {
  
  //execute the body while the condition evaluates to true
  ParseData d = condition->evaluate();
  while(d.type == BOOL_T && d.value.integer) {
    
    body->execute();
    
    //get updated expression truth value
    d = condition->evaluate();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x9, %eax
sete %al
testq %rdx, %rdx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1583d
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x9, %eax
jne 0x1583d
testq %rdx, %rdx
jne 0x15821
addq $0x8, %rsp
popq %rbx
popq %rbp
retq