LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16397(%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_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ConditionalStatementNode::ConditionalStatementNode(std::vector<AbstractExpressionNode*, std::allocator<AbstractExpressionNode*>>*, std::vector<AbstractStatementNode*, std::allocator<AbstractStatementNode*>>*, SymbolTable*, unsigned int, unsigned int)
ConditionalStatementNode::ConditionalStatementNode(std::vector<AbstractExpressionNode*>* cond, std::vector<AbstractStatementNode*>* stat, SymbolTable* symbolTable, uint32_t startLine, uint32_t endLine) {
  conditions = cond;
  statements = stat;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x16385(%rip), %rax     # 0x2bbc0
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x10(%rdi)
movl %r8d, 0x8(%rdi)
movl %r9d, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1636f(%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_O1/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 0x158c5
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x9, %eax
jne 0x158c5
testq %rdx, %rdx
jne 0x158a9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ForStatementNode::ForStatementNode(AbstractStatementNode*, AbstractStatementNode*, AbstractStatementNode*, AbstractExpressionNode*, SymbolTable*, unsigned int)
ForStatementNode::ForStatementNode(AbstractStatementNode* init, AbstractStatementNode* upd, AbstractStatementNode* bod, AbstractExpressionNode* cond, SymbolTable* symbolTable, uint32_t startLine) {
  initialization = init;
  update = upd;
  body = bod;
  condition = cond;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = bod->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
leaq 0x16316(%rip), %r10     # 0x2bbf0
movq %r10, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq %r9, 0x38(%rdi)
movl %eax, 0x8(%rdi)
movl 0xc(%rcx), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ForStatementNode::execute()
void ForStatementNode::execute() {

  symbolTable->enterNewScope();

  //first run initialization statement
  initialization->execute();
  
  //now execute the body while the terminating condition is true
  ParseData d = condition->evaluate();
  while(d.type == BOOL_T && d.value.integer) {
    body->execute();
    
    //update statement
    update->execute();
    d = condition->evaluate();
  }
  
  symbolTable->leaveScope();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x1650a
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x9, %eax
sete %al
testq %rdx, %rdx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x15958
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x9, %eax
jne 0x15958
testq %rdx, %rdx
jne 0x15933
movq 0x38(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x16586
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: NewAssignmentStatementNode::NewAssignmentStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseDataType, AbstractExpressionNode*, SymbolTable*, unsigned int)
NewAssignmentStatementNode::NewAssignmentStatementNode(std::string var, ParseDataType typ, AbstractExpressionNode* val, SymbolTable* symbolTable, uint32_t startLine) {
  
	variable = var;
	type = typ;
	value = val;
	this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = val->endLine;
  
  //add variable to table with correctly-typed dummy value    
  ParseData d;
  d.type = type;

	//array case should be handled in alternate constructor that takes subtype input
  symbolTable->declare(variable, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r13d
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %r14d
movq %rdi, %r12
leaq 0x16279(%rip), %rax     # 0x2bc08
movq %rax, (%rdi)
addq $0x18, %rdi
leaq 0x28(%r12), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movb $0x0, 0x28(%r12)
movq %rdi, -0x38(%rbp)
callq 0x4140
movl %r14d, 0x38(%r12)
movq %rbx, 0x40(%r12)
movq %r15, 0x10(%r12)
movl %r13d, 0x8(%r12)
movl 0xc(%rbx), %eax
movl %eax, 0xc(%r12)
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x18(%r12), %rsi
movq 0x20(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x8ac2
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
callq 0x16598
movq -0x58(%rbp), %rdi
cmpq %rbx, %rdi
je 0x15a13
callq 0x41e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %rbx, %rdi
je 0x15a3a
callq 0x41e0
jmp 0x15a3a
jmp 0x15a37
movq %rax, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x15a4c
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: NewAssignmentStatementNode::NewAssignmentStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseDataType, ParseDataType, AbstractExpressionNode*, SymbolTable*, unsigned int)
NewAssignmentStatementNode::NewAssignmentStatementNode(std::string var, ParseDataType typ, ParseDataType subTyp, AbstractExpressionNode* val, SymbolTable* symbolTable, uint32_t startLine) {
  
	variable = var;
	type = typ;
	subType = subTyp;
	value = val;
	this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = val->endLine;
  
  //add variable to table with correctly-typed dummy value    
  ParseData d;
  d.type = type;

	//if it's an array, add a subtype (this constructor should always be called for array type)
	if(typ == ARRAY_T) {
		Array* arr = (Array*) malloc(sizeof(Array));
		arr->subtype = subTyp;
		d.value.allocated = (void*) arr;
	}

  symbolTable->declare(variable, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %rbx
movl %ecx, %r13d
movl %edx, %r15d
movq %rdi, %r12
leaq 0x1618d(%rip), %rax     # 0x2bc08
movq %rax, (%rdi)
addq $0x18, %rdi
leaq 0x28(%r12), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movb $0x0, 0x28(%r12)
movq %rdi, -0x38(%rbp)
callq 0x4140
movl 0x10(%rbp), %eax
movl %r15d, 0x38(%r12)
movl %r13d, 0x3c(%r12)
movq %rbx, 0x40(%r12)
movq %r14, 0x10(%r12)
movl %eax, 0x8(%r12)
movl 0xc(%rbx), %eax
movl %eax, 0xc(%r12)
cmpl $0xc, %r15d
jne 0x15ae2
movl $0x10, %edi
callq 0x4290
movq %rax, %rbx
movl %r13d, (%rax)
leaq -0x48(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x18(%r12), %rsi
movq 0x20(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x8ac2
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
movl %r15d, %edx
movq %rbx, %rcx
callq 0x16598
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x15b20
callq 0x41e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x15b47
callq 0x41e0
jmp 0x15b47
jmp 0x15b44
movq %rax, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x15b59
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: NewAssignmentStatementNode::NewAssignmentStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseDataType, SymbolTable*, unsigned int, unsigned int)
NewAssignmentStatementNode::NewAssignmentStatementNode(std::string var, ParseDataType typ, SymbolTable* symbolTable, uint32_t startLine, uint32_t endLine) {
	variable = var;
	type = typ;
  value = NULL;
	this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = endLine;
  
  //add variable to table with correctly-typed dummy value    
  ParseData d;
  d.type = type;
  symbolTable->declare(variable, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r12d
movl %r8d, %ebx
movq %rcx, %r15
movl %edx, %r14d
movq %rdi, %r13
leaq 0x1607f(%rip), %rax     # 0x2bc08
movq %rax, (%rdi)
addq $0x18, %rdi
leaq 0x28(%r13), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x18(%r13)
movq $0x0, 0x20(%r13)
movb $0x0, 0x28(%r13)
movq %rdi, -0x38(%rbp)
callq 0x4140
movl %r14d, 0x38(%r13)
movq $0x0, 0x40(%r13)
movq %r15, 0x10(%r13)
movl %ebx, 0x8(%r13)
movl %r12d, 0xc(%r13)
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x18(%r13), %rsi
movq 0x20(%r13), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x8ac2
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
callq 0x16598
movq -0x58(%rbp), %rdi
cmpq %rbx, %rdi
je 0x15c03
callq 0x41e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %rbx, %rdi
je 0x15c2a
callq 0x41e0
jmp 0x15c2a
jmp 0x15c27
movq %rax, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x15c3c
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: NewAssignmentStatementNode::NewAssignmentStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseDataType, ParseDataType, SymbolTable*, unsigned int, unsigned int)
NewAssignmentStatementNode::NewAssignmentStatementNode(std::string var, ParseDataType typ, ParseDataType subTyp, SymbolTable* symbolTable, uint32_t startLine, uint32_t endLine) {
	variable = var;
	type = typ;
	subType = subTyp;
  value = NULL;
	this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = endLine;
  
  //add variable to table with correctly-typed dummy value    
  ParseData d;
  d.type = type;

	//if it's an array, add a subtype (this constructor should always be called for array type)
	if(typ == ARRAY_T) {
		Array* arr = (Array*) malloc(sizeof(Array));
		arr->subtype = subTyp;
		d.value.allocated = (void*) arr;
	}
	
  symbolTable->declare(variable, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movq %r8, %r15
movl %ecx, %r13d
movl %edx, %r14d
movq %rdi, %r12
leaq 0x15f9d(%rip), %rax     # 0x2bc08
movq %rax, (%rdi)
addq $0x18, %rdi
leaq 0x28(%r12), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movb $0x0, 0x28(%r12)
movq %rdi, -0x38(%rbp)
callq 0x4140
movl 0x10(%rbp), %eax
movl %r14d, 0x38(%r12)
movl %r13d, 0x3c(%r12)
movq $0x0, 0x40(%r12)
movq %r15, 0x10(%r12)
movl %ebx, 0x8(%r12)
movl %eax, 0xc(%r12)
cmpl $0xc, %r14d
jne 0x15cd3
movl $0x10, %edi
callq 0x4290
movq %rax, %rbx
movl %r13d, (%rax)
leaq -0x48(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x18(%r12), %rsi
movq 0x20(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x8ac2
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x16598
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x15d11
callq 0x41e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x15d38
callq 0x41e0
jmp 0x15d38
jmp 0x15d35
movq %rax, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x15d4a
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: AssignmentStatementNode::AssignmentStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, AbstractExpressionNode*, SymbolTable*, unsigned int)
AssignmentStatementNode::AssignmentStatementNode(std::string var, AbstractExpressionNode* val, SymbolTable* symbolTable, uint32_t startLine) {
  variable = var;
  value = val;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = val->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %r15
leaq 0x15ea2(%rip), %rax     # 0x2bc20
movq %rax, (%rdi)
leaq 0x18(%rdi), %r13
leaq 0x28(%rdi), %rbx
movq %rbx, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %r13, %rdi
callq 0x4140
movq %r14, 0x38(%r15)
movq %r12, 0x10(%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 (%r13), %rdi
cmpq %rbx, %rdi
je 0x15dd8
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ArrayAssignmentStatementNode::ArrayAssignmentStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, AbstractExpressionNode*, AbstractExpressionNode*, SymbolTable*, char*, unsigned int)
ArrayAssignmentStatementNode::ArrayAssignmentStatementNode(std::string var, bool isArray, AbstractExpressionNode* ind, AbstractExpressionNode* val, SymbolTable* symbolTable, char* context, uint32_t startLine) {
	variable = var;
	index = ind;
	value = val;
	this->isArray = isArray;
	this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = val->endLine;
	this->context = context;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x38(%rbp)
movq %r8, %rbx
movq %rcx, %r13
movl %edx, -0x2c(%rbp)
movq %rdi, %r15
leaq 0x15e26(%rip), %rax     # 0x2bc38
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %r12
movq %r12, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %r14, %rdi
callq 0x4140
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rcx
movq %r13, 0x38(%r15)
movq %rbx, 0x40(%r15)
movl -0x2c(%rbp), %edx
movb %dl, 0x50(%r15)
movq -0x38(%rbp), %rdx
movq %rdx, 0x10(%r15)
movl %eax, 0x8(%r15)
movl 0xc(%rbx), %eax
movl %eax, 0xc(%r15)
movq %rcx, 0x48(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x15e81
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ReturnStatementNode::ReturnStatementNode(AbstractExpressionNode*, bool*, ParseData*, unsigned int)
ReturnStatementNode::ReturnStatementNode(AbstractExpressionNode* exp, bool* retFlag, ParseData* retVal, uint32_t startLine) {
	expression = exp;
	returnFlag = retFlag;
	returnValue = retVal;
	this->startLine = startLine;
	this->endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x15db1(%rip), %rax     # 0x2bc50
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movl %r8d, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: FunctionStatementNode::FunctionStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Function*, SymbolTable*)
FunctionStatementNode::FunctionStatementNode(std::string fName, Function* f, SymbolTable* symbolTable) {
	functionName = fName;
	function = f;
	this->symbolTable = symbolTable;

	ParseData d;
	d.type = FUN_T;
	d.value.allocated = f;
	symbolTable->declare(fName, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq 0x15d80(%rip), %rax     # 0x2bc68
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 %rbx, %rdi
callq 0x4140
movq %r14, 0x18(%r13)
movq %r15, 0x10(%r13)
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x8ac2
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
movl $0xd, %edx
movq %r14, %rcx
callq 0x16598
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x15f56
callq 0x41e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x15f7d
callq 0x41e0
jmp 0x15f7d
jmp 0x15f7a
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x15f8b
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: FunctionStatementNode::FunctionStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, SymbolTable*)
FunctionStatementNode::FunctionStatementNode(std::string fName, SymbolTable* symbolTable) {
	functionName = fName;
	function = NULL;
	this->symbolTable = symbolTable;

	ParseData d;
	d.type = FUN_T;
	symbolTable->declare(fName, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x15cb3(%rip), %rax     # 0x2bc68
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
leaq 0x30(%rdi), %r13
movq %r13, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movq %rbx, %rdi
callq 0x4140
movq $0x0, 0x18(%r12)
movq %r14, 0x10(%r12)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x8ac2
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
movl $0xd, %edx
callq 0x16598
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x16021
callq 0x41e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x16048
callq 0x41e0
jmp 0x16048
jmp 0x16045
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x16055
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/typehandler.cpp
// Function: typecheckImplicitCastExpression(ParseDataType, ParseDataType)
bool typecheckImplicitCastExpression(ParseDataType origType, ParseDataType finalType) {

  switch(finalType) {
    
    case INT32_T: return origType == CHAR_T || origType == INT32_T || origType == UINT32_T;
                         
    case INT64_T: return isIntParseDataType(origType);
                         
    case UINT32_T: return origType == CHAR_T || origType == INT32_T || origType == UINT32_T;
                         
    case UINT64_T: return isIntParseDataType(origType);
    case CHAR_T: return origType == CHAR_T;
    case BOOL_T: return origType == BOOL_T;
    case DOUBLE_T: return isNumberParseDataType(origType);
    case STRING_T: return true;
    default: return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addl $-0x2, %esi
cmpl $0x9, %esi
ja 0x160ab
leaq 0xce4a(%rip), %rax      # 0x22edc
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpl $0x9, %edi
jae 0x160ab
movl $0x144, %eax            # imm = 0x144
movl %edi, %ecx
shrl %cl, %eax
jmp 0x160ca
xorl %eax, %eax
jmp 0x160ca
popq %rbp
jmp 0x80ff
cmpl $0x9, %edi
jmp 0x160c7
popq %rbp
jmp 0x80eb
movb $0x1, %al
jmp 0x160ca
cmpl $0x8, %edi
sete %al
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/typehandler.cpp
// Function: typecheckExplicitCastExpression(ParseDataType, ParseDataType)
bool typecheckExplicitCastExpression(ParseDataType origType, ParseDataType finalType) {
  
  if(isNumberParseDataType(finalType)) {
    return isNumberParseDataType(origType) || origType == BOOL_T;
  } else if(finalType == BOOL_T) {
    return isIntParseDataType(origType) || origType == BOOL_T;  
  } else if(finalType == STRING_T) {
    return true;
  } else {
    return false; 
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movl %edi, %ebx
movl %esi, %edi
callq 0x80eb
testb %al, %al
je 0x160ee
movl %ebx, %edi
callq 0x80eb
jmp 0x16101
cmpl $0xb, %r14d
je 0x16110
cmpl $0x9, %r14d
jne 0x16114
movl %ebx, %edi
callq 0x80ff
movl %eax, %ecx
cmpl $0x9, %ebx
sete %al
orb %cl, %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x1610b
xorl %eax, %eax
jmp 0x1610b
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/typehandler.cpp
// Function: typecheckUnaryExpression(ParseOperatorType, ParseDataType)
bool typecheckUnaryExpression(ParseOperatorType op, ParseDataType arg) {
  
  switch(op) {
    case POSTFIX_INC_OP: return isNumberParseDataType(arg);
    case PREFIX_INC_OP: return isNumberParseDataType(arg);
    case POSTFIX_DEC_OP: return isNumberParseDataType(arg);
    case PREFIX_DEC_OP: return isNumberParseDataType(arg);
    case POSITIVE_OP: return isNumberParseDataType(arg) || arg == STRING_T || arg == ARRAY_T;
    case NEGATIVE_OP: return isNumberParseDataType(arg) || arg == STRING_T || arg == ARRAY_T;
    case BIT_NOT_OP: return isIntParseDataType(arg);
    case NOT_OP: return arg == BOOL_T;
    default: return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
cmpl $0xa, %edi
ja 0x16162
movl %esi, %ebx
movl %edi, %ecx
leaq 0xcdd4(%rip), %rdx      # 0x22f04
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x80eb
movl %ebx, %edi
callq 0x80eb
movl %eax, %ecx
addl $-0xb, %ebx
cmpl $0x2, %ebx
setb %al
orb %cl, %al
jmp 0x16162
cmpl $0x9, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x80ff
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/typehandler.cpp
// Function: typecheckArithmeticExpression(ParseOperatorType, ParseDataType, ParseDataType)
bool typecheckArithmeticExpression(ParseOperatorType op, ParseDataType l, ParseDataType r) {
  
  switch(op) {
  
    case EXPONENT_OP: return isNumberParseDataType(l) && isNumberParseDataType(r);
    case DIVIDE_OP: return isNumberParseDataType(l) && isNumberParseDataType(r);
    case MULTIPLY_OP: return (isNumberParseDataType(l) && isNumberParseDataType(r)) ||
                             (isIntParseDataType(l) && r == STRING_T) ||
                             (l == STRING_T && isIntParseDataType(r)) ||
														 (isIntParseDataType(l) && r == ARRAY_T) ||
                             (l == ARRAY_T && isIntParseDataType(r));

    case MOD_OP: return isNumberParseDataType(l) && isNumberParseDataType(r);

    case ADD_OP: return l == STRING_T || r == STRING_T ||
												(l == ARRAY_T && r == ARRAY_T) ||
                        (isNumberParseDataType(l) && isNumberParseDataType(r));

    case SUBTRACT_OP: return isNumberParseDataType(l) && isNumberParseDataType(r);
    default: return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
addl $-0xb, %edi
cmpl $0x5, %edi
ja 0x16227
movl %edx, %ebx
movl %esi, %r14d
leaq 0xcd98(%rip), %rax      # 0x22f30
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %r14d, %edi
callq 0x80eb
testb %al, %al
je 0x16227
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x80eb
movl %r14d, %edi
callq 0x80eb
testb %al, %al
je 0x161d8
movl %ebx, %edi
callq 0x80eb
movb $0x1, %r15b
testb %al, %al
jne 0x1622a
movl %r14d, %edi
callq 0x80ff
cmpl $0xb, %ebx
sete %cl
movb $0x1, %r15b
testb %al, %cl
jne 0x1622a
cmpl $0xb, %r14d
jne 0x161fe
movl %ebx, %edi
callq 0x80ff
testb %al, %al
jne 0x1622a
movl %r14d, %edi
callq 0x80ff
cmpl $0xc, %ebx
sete %cl
testb %al, %cl
jne 0x1622a
cmpl $0xc, %r14d
jne 0x16227
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x80ff
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0xb, %r14d
sete %al
cmpl $0xb, %ebx
sete %cl
orb %al, %cl
movb $0x1, %r15b
jne 0x1622a
movl %r14d, %eax
xorl $0xc, %eax
movl %ebx, %ecx
xorl $0xc, %ecx
orl %eax, %ecx
jne 0x161a1
jmp 0x1622a
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/typehandler.cpp
// Function: typecheckBitLogicalExpression(ParseOperatorType, ParseDataType, ParseDataType)
bool typecheckBitLogicalExpression(ParseOperatorType op, ParseDataType l, ParseDataType r) {

  if(isBitwiseParseOperatorType(op)) {
    return isIntParseDataType(l) && isIntParseDataType(r);
  } else if(isLogicalParseOperatorType(op)) {
    return l == BOOL_T && r == BOOL_T;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
callq 0x8211
testb %al, %al
je 0x16299
movl %r14d, %edi
callq 0x80ff
testb %al, %al
je 0x162b4
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x80ff
movl %r15d, %edi
callq 0x8228
testb %al, %al
je 0x162b4
xorl $0x9, %r14d
xorl $0x9, %ebx
orl %r14d, %ebx
sete %al
jmp 0x162b6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/typehandler.cpp
// Function: getTypeUnaryExpression(ParseOperatorType, ParseDataType)
ParseDataType getTypeUnaryExpression(ParseOperatorType op, ParseDataType arg) {
  
  if(!typecheckUnaryExpression(op, arg))
    return INVALID_T;

  switch(op) {
    case POSTFIX_INC_OP: return arg;
    case POSTFIX_DEC_OP: return arg;
    case PREFIX_INC_OP: return arg;
    case PREFIX_DEC_OP: return arg;
    case POSITIVE_OP: return arg;
    case NEGATIVE_OP: return arg;
    case BIT_NOT_OP: return arg;
    case NOT_OP: return BOOL_T;
    default: return INVALID_T;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
callq 0x16118
testb %al, %al
je 0x1632c
cmpl $0xa, %r14d
ja 0x1632c
movl $0x58f, %eax            # imm = 0x58F
btl %r14d, %eax
jb 0x16331
cmpl $0x9, %r14d
jne 0x1632c
movl $0x9, %ebx
jmp 0x16331
movl $0x11, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/typehandler.cpp
// Function: getTypeArithmeticExpression(ParseOperatorType, ParseDataType, ParseDataType)
ParseDataType getTypeArithmeticExpression(ParseOperatorType op, ParseDataType l, ParseDataType r) {
  
  if(!typecheckArithmeticExpression(op, l, r))
    return INVALID_T;

  switch(op) {
  
    case EXPONENT_OP: return DOUBLE_T;
    case DIVIDE_OP: return getLargerNumberParseDataType(l, r);    
    case MULTIPLY_OP: return (l == STRING_T || r == STRING_T) ? STRING_T :
														 (l == ARRAY_T || r == ARRAY_T) ? ARRAY_T :
                             getLargerNumberParseDataType(l, r);

    case MOD_OP: return getLargerNumberParseDataType(l, r);

    case ADD_OP: return (l == STRING_T || r == STRING_T) ? STRING_T :
												(l == ARRAY_T && r == ARRAY_T) ? ARRAY_T :
                        getLargerNumberParseDataType(l, r);   
    
    case SUBTRACT_OP: return getLargerNumberParseDataType(l, r);
    default: return INVALID_T;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
callq 0x16176
movl %eax, %ecx
movl $0x11, %eax
testb %cl, %cl
je 0x163ef
addl $-0xb, %r15d
cmpl $0x5, %r15d
ja 0x163ef
leaq 0xcbd5(%rip), %rax      # 0x22f48
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %r14d, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8126
cmpl $0xb, %r14d
sete %al
cmpl $0xb, %ebx
sete %cl
orb %al, %cl
movl $0xb, %eax
jne 0x163ef
cmpl $0xc, %r14d
sete %al
cmpl $0xc, %ebx
sete %cl
orb %al, %cl
movl $0xc, %eax
je 0x1637c
jmp 0x163ef
movl $0xa, %eax
jmp 0x163ef
cmpl $0xb, %r14d
sete %al
cmpl $0xb, %ebx
sete %cl
orb %al, %cl
movl $0xb, %eax
jne 0x163ef
movl %r14d, %ecx
xorl $0xc, %ecx
movl %ebx, %edx
xorl $0xc, %edx
movl $0xc, %eax
orl %ecx, %edx
jne 0x1637c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/typehandler.cpp
// Function: getTypeBitLogicalExpression(ParseOperatorType, ParseDataType, ParseDataType)
ParseDataType getTypeBitLogicalExpression(ParseOperatorType op, ParseDataType l, ParseDataType r) {

  if(!typecheckBitLogicalExpression(op, l, r))
    return INVALID_T;

  if(isBitwiseParseOperatorType(op)) {
  
    return getLargerNumberParseDataType(l, r);

  } else if(isLogicalParseOperatorType(op)) {
  
    return BOOL_T;

  } else {

    return INVALID_T;

  }   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movl %edi, %r14d
callq 0x16261
movl %eax, %ecx
movl $0x11, %eax
testb %cl, %cl
je 0x16450
movl %r14d, %edi
callq 0x8211
testb %al, %al
je 0x1643c
movl %r15d, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8126
movl %r14d, %edi
callq 0x8228
xorb $0x1, %al
movzbl %al, %eax
leal 0x9(,%rax,8), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/symboltable.cpp
// Function: SymbolTable::declare(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseData)
void SymbolTable::declare(string var, ParseData value) {
  
  //get symbol table at innermost scope
  unordered_map<string, ParseData>* map = table->back();
  
  //add element to the map
  (*map)[var] = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %r14d
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq -0x8(%rax), %rdi
callq 0x16930
movl %r14d, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/symboltable.cpp
// Function: SymbolTable::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseData)
void SymbolTable::update(string var, ParseData value) {

  //start at innermost scope and work your way up
  vector<unordered_map<string, ParseData>*>::reverse_iterator rit;
  
  for(rit = table->rbegin(); rit != table->rend(); rit++) {
    //map at this particular scope
    unordered_map<string, ParseData>* map = (*rit);
    
    //if this map contains it, update its value
    if(map->find(var) != map->end()) {
      (*map)[var] = value;
      return;
    } 
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rax
movq 0x8(%rax), %rbx
movq (%r12), %rax
cmpq (%rax), %rbx
je 0x1661b
movq -0x8(%rbx), %r13
addq $-0x8, %rbx
movq %r13, %rdi
movq %r15, %rsi
callq 0x16d90
testq %rax, %rax
je 0x165e4
movq %r13, %rdi
movq %r15, %rsi
callq 0x16930
movl %r14d, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/symboltable.cpp
// Function: SymbolTable::isDeclared(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool SymbolTable::isDeclared(string var) {
  
  //start at innermost scope and work your way up
  vector<unordered_map<string, ParseData>*>::reverse_iterator rit;
  
  for(rit = table->rbegin(); rit != table->rend(); rit++) {
    //map at this particular scope
    unordered_map<string, ParseData>* map = (*rit);

    //if this map contains it, return true
    if(map->find(var) != map->end())
      return true; 
  }
  
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %r13
movq %r13, %r15
movq (%r14), %rax
movq (%rax), %r12
cmpq %r12, %r13
je 0x16684
leaq -0x8(%r15), %r13
movq -0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x16d90
testq %rax, %rax
je 0x16661
cmpq %r12, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/symboltable.cpp
// Function: SymbolTable::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ParseData SymbolTable::get(string var) {
  
  //start at innermost scope and work your way up
  vector<unordered_map<string, ParseData>*>::reverse_iterator rit;
  for(rit = table->rbegin(); rit != table->rend(); rit++) {
  
    //map at this particular scope
    unordered_map<string, ParseData>* map = (*rit);
    
    //see if this map contains the variable
    unordered_map<string, ParseData>::const_iterator value = map->find(var);
    if(value != map->end())
      return value->second;
  }
  
  //not found, return "invalid" data
  ParseData d;
  d.type = INVALID_T;
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq (%rdi), %rax
movq 0x8(%rax), %r13
movq (%r12), %rax
cmpq (%rax), %r13
je 0x166e2
movq -0x8(%r13), %rdi
movq %rbx, %rsi
callq 0x16d90
testq %rax, %rax
je 0x166d7
movl 0x28(%rax), %r15d
movq 0x30(%rax), %r14
addq $-0x8, %r13
testq %rax, %rax
je 0x166b5
jmp 0x166e8
movl $0x11, %r15d
movl %r15d, %eax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/symboltable.cpp
// Function: SymbolTable::toString[abi:cxx11]()
std::string SymbolTable::toString() {

	std::string str = "";

	//loop through all the hash maps
	std::vector<std::unordered_map<string, ParseData>*>::iterator it;
	for(it = table->begin(); it != table->end(); it++) {

		//loop through the keys in the hash map and print those
		std::unordered_map<string, ParseData>::iterator it2;
		for(it2 = (*it)->begin(); it2 != (*it)->end(); it2++) {
			str.append(it2->first);
			str.append(", ");
			str.append(toStringParseDataType(it2->second.type));
			str.append("\n");
		}

		str.append("----------------------------\n");
	}
	str.append("end of table");

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x792a(%rip), %rdx      # 0x1e051
movq %rdx, %rsi
callq 0x5ce4
movq %r14, -0x38(%rbp)
movq (%r14), %rax
movq (%rax), %r15
cmpq 0x8(%rax), %r15
je 0x167b8
leaq 0x8925(%rip), %r12      # 0x1f06b
leaq 0xc82f(%rip), %r13      # 0x22f7c
movq (%r15), %r14
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x16798
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x40a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x43a0
movl 0x28(%r14), %edi
callq 0x82a8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x43a0
jmp 0x16754
movq %rbx, %rdi
leaq 0xc7be(%rip), %rsi      # 0x22f60
callq 0x43a0
addq $0x8, %r15
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq 0x8(%rax), %r15
jne 0x1674d
leaq 0xc7bf(%rip), %rsi      # 0x22f7e
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x167dd
jmp 0x167dd
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x167ee
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/executor.cpp
// Function: executeGroupedStatement(GroupedStatementNode*)
void executeGroupedStatement(GroupedStatementNode* node) {
  
  //symbol table enters new scope
  node->symbolTable->enterNewScope();
  
  //sequentially execute statements
  std::vector<AbstractStatementNode*>* statements = node->statements;
  std::vector<AbstractStatementNode*>::iterator it;
  
  for(it = statements->begin(); it != statements->end(); it++) {
    (*it)->execute();
  }
	
	//leave the block scope
	node->symbolTable->leaveScope();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1650a
movq 0x18(%rbx), %r14
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x16f07
movq (%r15), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r15
jmp 0x16ef3
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16586
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/executor.cpp
// Function: executeConditionalStatement(ConditionalStatementNode*)
void executeConditionalStatement(ConditionalStatementNode* node) {
  
  std::vector<AbstractExpressionNode*>* conditions = node->conditions;
  std::vector<AbstractStatementNode*>* statements = node->statements;
  std::vector<AbstractExpressionNode*>::iterator it1;
  std::vector<AbstractStatementNode*>::iterator it2;
  
  it1 = conditions->begin();
  it2 = statements->begin();
  
  for(; it1 != conditions->end(); it1++, it2++) {
    
    ParseData d = (*it1)->evaluate();
    if(d.type == BOOL_T && d.value.integer != 0) {
      
      (*it2)->execute();
      return;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
movq (%rbx), %r14
cmpq 0x8(%rbx), %r14
je 0x16f5e
movq 0x20(%rdi), %rax
movq (%rax), %r15
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x9, %eax
setne %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x16f69
addq $0x8, %r14
addq $0x8, %r15
cmpq 0x8(%rbx), %r14
jne 0x16f38
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/executor.cpp
// Function: executeFunctionStatement(FunctionStatementNode*)
void executeFunctionStatement(FunctionStatementNode* node) {

	SymbolTable* symbolTable = node->symbolTable;
	std::string functionName = node->functionName;
	Function* function = node->function;

	ParseData d;
	d.type = FUN_T;
	d.value.allocated = (void*) function;

	//declare the function, with or without implementation
	symbolTable->declare(functionName, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rbx
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x8ac2
movq 0x18(%r14), %r14
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x8ac2
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
movl $0xd, %edx
movq %r14, %rcx
callq 0x16598
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1763f
callq 0x41e0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1764d
callq 0x41e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x17672
callq 0x41e0
jmp 0x17672
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x17680
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/executor.cpp
// Function: executeReturnStatement(ReturnStatementNode*)
void executeReturnStatement(ReturnStatementNode* node) {
	bool* returnFlag = node->returnFlag;
	ParseData* returnValue = node->returnValue;
	*returnValue = node->expression->evaluate();
	*returnFlag = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, (%r14)
movq %rdx, 0x8(%r14)
movb $0x1, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/utils.cpp
// Function: copyString(char const*)
char* copyString(const char* str) {

	uint32_t len = strlen(str);
	char* copy = new char[len+1];
	copy[0] = '\0';

	strcpy(copy, str);
	copy[len] = '\0';

	return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x40e0
movq %rax, %r14
leal 0x1(%rax), %edi
callq 0x4030
movq %rax, %r15
xorl %r12d, %r12d
movb %r12b, (%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41d0
movl %r14d, %eax
movb %r12b, (%r15,%rax)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/utils.cpp
// Function: copySubstring(char const*, int, int)
char* copySubstring(const char* str, int32_t startIndex, int32_t pastEndIndex) {

	char* copy = new char[std::max(pastEndIndex-startIndex+1, 1)];
	for(int32_t i = startIndex; i < pastEndIndex; i++) {
		copy[i-startIndex] = str[i];
	}

	copy[std::max(pastEndIndex-startIndex, 0)] = '\0';
	return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebx
movq %rdi, -0x30(%rbp)
movl %edx, %edi
subl %esi, %edi
xorl %r13d, %r13d
testl %edi, %edi
cmovlel %r13d, %edi
incl %edi
callq 0x4030
movq %rax, %r15
movl %r14d, %r12d
subl %ebx, %r12d
jle 0x17748
movslq %ebx, %rax
movq -0x30(%rbp), %rsi
addq %rax, %rsi
notl %ebx
addl %r14d, %ebx
incq %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x41b0
testl %r12d, %r12d
cmovgl %r12d, %r13d
movb $0x0, (%r15,%r13)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/utils.cpp
// Function: copySubarray(Array*, int, int)
Array* copySubarray(Array* arr, int32_t startIndex, int32_t pastEndIndex) {

	//extract fields from Array
	ParseData* values = arr->values;

	ParseData* subarrayValues = (ParseData*) malloc(sizeof(ParseData) * std::max(pastEndIndex-startIndex, 1));
	for(int32_t i = startIndex; i < pastEndIndex; i++) {
		subarrayValues[i-startIndex] = values[i];
	}

	//create subarray Array and return it
	Array* subarray = (Array*) malloc(sizeof(Array));
	subarray->length = (uint32_t) std::max(pastEndIndex-startIndex, 0);
	subarray->subtype = arr->subtype;
	subarray->values = subarrayValues;

	return subarray;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, -0x30(%rbp)
movq 0x8(%rdi), %r13
movl %edx, %eax
subl %esi, %eax
cmpl $0x2, %eax
movl $0x1, %edi
cmovgel %eax, %edi
shlq $0x4, %rdi
callq 0x4290
movq %rax, %r14
movl %ebx, %r15d
subl %r12d, %r15d
jle 0x177ca
movslq %r12d, %rcx
movslq %ebx, %rax
subq %rcx, %rax
shlq $0x4, %rcx
addq %rcx, %r13
xorl %ecx, %ecx
movups (%r13,%rcx), %xmm0
movups %xmm0, (%r14,%rcx)
addq $0x10, %rcx
decq %rax
jne 0x177b6
movl $0x10, %edi
callq 0x4290
xorl %ecx, %ecx
testl %r15d, %r15d
cmovgl %r15d, %ecx
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/array.cpp
// Function: arrayListType(std::vector<AbstractExpressionNode*, std::allocator<AbstractExpressionNode*>>*)
ParseDataType arrayListType(std::vector<AbstractExpressionNode*>* initValues) {

	//keep track of most significant integer type
	ParseDataType largestIntegerType = UINT8_T;

	//keep track of whether there is a string or double
	bool existsString = false;
	bool existsDouble = false;

	std::vector<AbstractExpressionNode*>::iterator it;
	for(it = initValues->begin(); it != initValues->end(); it++) {

		ParseDataType type = (*it)->evalType;

		if(type == STRING_T)
			existsString = true;
		else if(type == DOUBLE_T)
			existsDouble = true;
		else if(isIntParseDataType(type))
			largestIntegerType = getLargerNumberParseDataType(largestIntegerType, type);
	}

	//if there is a single string, cast everything else to a string
	if(existsString)
		return STRING_T;
	else if(existsDouble)
		return DOUBLE_T;
	else
		return largestIntegerType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x17886
movq %rdi, %rbx
movl $0x4, %r14d
movl $0x0, -0x2c(%rbp)
xorl %r13d, %r13d
movq (%r12), %rax
movl 0x10(%rax), %r15d
cmpl $0xb, %r15d
je 0x1783f
cmpl $0xa, %r15d
jne 0x17846
movb $0x1, %r13b
jmp 0x17860
movb $0x1, %al
movl %eax, -0x2c(%rbp)
jmp 0x17860
movl %r15d, %edi
callq 0x80ff
testb %al, %al
je 0x17860
movl %r14d, %edi
movl %r15d, %esi
callq 0x8126
movl %eax, %r14d
addq $0x8, %r12
cmpq 0x8(%rbx), %r12
jne 0x17826
testb $0x1, %r13b
movl $0xa, %eax
cmovnel %eax, %r14d
testb $0x1, -0x2c(%rbp)
movl $0xb, %eax
cmovel %r14d, %eax
jmp 0x1788b
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop