LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0xab58
leaq 0x12f61(%rip), %rdx     # 0x1da20
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 0xab58
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movl %ecx, %edx
jmp 0xab58
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
movq %xmm1, %rdx
jmp 0xab58
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rdx
jmp 0xab58
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
subsd 0x12ee0(%rip), %xmm1    # 0x1da18
cvttsd2si %xmm1, %rdx
andq %rsi, %rdx
orq %rcx, %rdx
jmp 0xab58
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %ecx
movzbl %cl, %edx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xce49
leaq 0x115ea(%rip), %rdx     # 0x1e3fc
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
jmp 0xce49
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movslq %edx, %rdx
jmp 0xce49
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movl %edx, %edx
jmp 0xce49
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movzbl %dl, %edx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %r15
leaq 0x18(%rdi), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4290
movq 0x40(%rbx), %rdi
movl 0x10(%rbx), %r12d
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebx
movq %rdx, %r14
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4290
movl %ebx, %edi
movq %r14, %rsi
movl %r12d, %edx
callq 0x13380
movq %rdx, %rcx
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
movl %eax, %edx
callq 0x1439e
leaq -0x40(%rbp), %rdi
callq 0x40e0
leaq -0x60(%rbp), %rdi
callq 0x40e0
movl %ebx, %eax
movq %r14, %rdx
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x40e0
jmp 0xf445
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf5a3
movl %edx, %eax
cmpl $0x1d, %edx
je 0xf59e
cmpl $0x1c, %eax
jne 0xf5aa
andb %sil, %dil
jmp 0xf5a6
xorb %sil, %dil
jmp 0xf5a6
orb %sil, %dil
movzbl %dil, %edx
movl $0x9, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x42a0
addl $-0x13, %ebx
cmpl $0x3, %ebx
ja 0x11cb4
leaq 0xe894(%rip), %rcx      # 0x2051c
movslq (%rcx,%rbx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorl %edx, %edx
testl %eax, %eax
setg %dl
jmp 0x11cb4
xorl %edx, %edx
testl %eax, %eax
setns %dl
jmp 0x11cb4
xorl %edx, %edx
testl %eax, %eax
setle %dl
jmp 0x11cb4
shrl $0x1f, %eax
movq %rax, %rdx
jmp 0x11cb4
pushq $0x9
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x42a0
cmpl $0x18, %ebx
je 0x11cde
cmpl $0x17, %ebx
jne 0x11ce5
xorl %edx, %edx
testl %eax, %eax
sete %dl
jmp 0x11ce5
xorl %edx, %edx
testl %eax, %eax
setne %dl
pushq $0x9
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq %rax, -0x38(%rbp)
movq 0x28(%rdi), %rax
movl 0x18(%rdi), %ebx
movq %rdi, -0x48(%rbp)
movq 0x20(%rdi), %r12
movq 0x18(%rax), %r14
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq %rbx, %rdi
shlq $0x4, %rdi
callq 0x4250
movq %rax, %r15
shlq $0x3, %rbx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x12f5f
movq (%r12,%r13), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, (%r15,%r13,2)
movq %rdx, 0x8(%r15,%r13,2)
addq $0x8, %r13
jmp 0x12f42
movq -0x38(%rbp), %rdi
callq 0x14308
xorl %r13d, %r13d
leaq -0x68(%rbp), %r12
cmpq %r13, %rbx
je 0x12fa7
movq (%r14,%r13), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x40a0
movl (%r15,%r13,2), %edx
movq 0x8(%r15,%r13,2), %rcx
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x14374
movq %r12, %rdi
callq 0x40e0
addq $0x8, %r13
jmp 0x12f6f
movq -0x48(%rbp), %r15
movq 0x38(%r15), %rbx
movb $0x0, (%rbx)
movq -0x40(%rbp), %r12
movq (%r12), %r14
xorl %eax, %eax
testb $0x1, %al
jne 0x12fd7
cmpq 0x8(%r12), %r14
je 0x12fd7
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r14
movb (%rbx), %al
jmp 0x12fbc
movq -0x38(%rbp), %rdi
callq 0x14362
movq 0x40(%r15), %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
leaq -0x68(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1323e
pushq $0x8
popq %r13
cmpl $0xb, %esi
jne 0x13268
movq %r15, %rdi
callq 0x40c0
movq %rax, %r12
leal 0x1(%rax), %ecx
movl %ebx, %eax
sarl $0x1f, %eax
andl %ecx, %eax
addl %ebx, %eax
js 0x1327a
cmpl %r12d, %eax
jge 0x1327a
movl %eax, %eax
movsbq (%r15,%rax), %rdx
jmp 0x13268
movl 0x4(%r15), %r12d
movl %ebx, %eax
sarl $0x1f, %eax
andl %r12d, %eax
addl %ebx, %eax
js 0x132af
cmpl %r12d, %eax
jge 0x132af
movq 0x8(%r15), %rcx
movl %eax, %eax
shlq $0x4, %rax
movl (%rcx,%rax), %r13d
movq 0x8(%rcx,%rax), %rdx
jmp 0x13268
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x4110
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x152e4
movq 0x8(%r14), %rcx
leaq 0x17437(%rip), %rdx     # 0x2a6d0
addq $0x10, %rdx
movq %rdx, (%r15)
movq %rax, 0x8(%r15)
movb $0x0, 0x10(%r15)
movl %r12d, 0x14(%r15)
jmp 0x132e2
pushq $0x28
popq %rdi
callq 0x4110
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x152e4
movq 0x8(%r14), %rcx
leaq 0x17402(%rip), %rdx     # 0x2a6d0
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 0x17407(%rip), %rsi     # 0x2a6f8
movq 0x17ce0(%rip), %rdx     # 0x2afd8
movq %r15, %rdi
callq 0x4310
jmp 0x13302
movq %rax, %rbx
movq %r15, %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13354
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 0x13371
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x131f3
nop
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/arrayeval.cpp
// Function: evaluateArrayExpression(ArrayNode*)
ParseData evaluateArrayExpression(ArrayNode* node) {

	//extract instance fields
	bool isInitialized = node->isInitialized;
	ParseDataType subtype = node->subType;
	uint32_t length = (uint32_t) (node->length->evaluate().value.integer);
	AbstractExpressionNode** elements = node->values;

	//construct the array
	Array* arr = (Array*) malloc(sizeof(Array));
	arr->subtype = subtype;
	arr->length = length;
	
	ParseData* values = (ParseData*) malloc(sizeof(ParseData) * length);
	
	//if the array is initialized, fill it accordingly
	if(isInitialized) {
		for(uint32_t i = 0; i < length ; i++) {
			values[i] = elements[i]->evaluate();
		}
	}
	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
pushq %rax
movq %rdi, %rbx
movb 0x18(%rdi), %r13b
movl 0x14(%rdi), %r14d
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rdx, %r15
movq 0x28(%rbx), %r12
pushq $0x10
popq %rdi
callq 0x4250
movq %rax, %rbx
movl %r14d, (%rax)
movl %r15d, 0x4(%rax)
movl %r15d, %edi
shlq $0x4, %rdi
callq 0x4250
movq %rax, %r14
cmpb $0x1, %r13b
jne 0x1371b
movl %r15d, %r15d
shlq $0x3, %r15
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x1371b
movq (%r12,%r13), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, (%r14,%r13,2)
movq %rdx, 0x8(%r14,%r13,2)
addq $0x8, %r13
jmp 0x136fe
movq %r14, 0x8(%rbx)
pushq $0xc
popq %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/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 0x17415(%rip), %rax     # 0x2ab60
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_O2/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 0x173ff(%rip), %rax     # 0x2ab78
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_O2/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 0x173eb(%rip), %rax     # 0x2ab90
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_O2/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 0x173d7(%rip), %rax     # 0x2aba8
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_O2/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 0x173c5(%rip), %rax     # 0x2abc0
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_O2/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 0x173af(%rip), %rax     # 0x2abd8
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_O2/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
jne 0x1386f
testq %rdx, %rdx
je 0x1386f
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x18(%rbx), %rdi
jmp 0x13851
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1736c(%rip), %r10     # 0x2abf0
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_O2/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 0x14308
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x9, %eax
jne 0x138e3
testq %rdx, %rdx
je 0x138e3
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x20(%rbx), %rdi
jmp 0x138bc
movq 0x38(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x14362
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, %r15
movq %rcx, %r13
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x172ee(%rip), %rax     # 0x2ac08
movq %rax, (%rdi)
leaq 0x18(%rdi), %r12
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %r12, %rdi
callq 0x4140
movl %r14d, 0x38(%rbx)
movq %r13, 0x40(%rbx)
movq %r15, 0x10(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x8(%rbx)
movl 0xc(%r13), %eax
movl %eax, 0xc(%rbx)
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x4290
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
callq 0x14374
leaq -0x50(%rbp), %rdi
callq 0x40e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x40e0
jmp 0x13999
jmp 0x13996
movq %rax, %r14
movq %r12, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %r9, %r14
movq %r8, %r13
movl %ecx, %r12d
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x17237(%rip), %rax     # 0x2ac08
movq %rax, (%rdi)
addq $0x18, %rdi
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
movq %rdi, -0x30(%rbp)
callq 0x4140
movl 0x10(%rbp), %eax
movl %r15d, 0x38(%rbx)
movl %r12d, 0x3c(%rbx)
movq %r13, 0x40(%rbx)
movq %r14, 0x10(%rbx)
movl %eax, 0x8(%rbx)
movl 0xc(%r13), %eax
movl %eax, 0xc(%rbx)
cmpl $0xc, %r15d
jne 0x13a23
pushq $0x10
popq %rdi
callq 0x4250
movq %rax, %r13
movl %r12d, (%rax)
leaq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4290
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
movl %r15d, %edx
movq %r13, %rcx
callq 0x14374
leaq -0x50(%rbp), %rdi
callq 0x40e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x40e0
jmp 0x13a6d
jmp 0x13a6a
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %r9d, -0x2c(%rbp)
movl %r8d, %r13d
movq %rcx, %r15
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x17162(%rip), %rax     # 0x2ac08
movq %rax, (%rdi)
leaq 0x18(%rdi), %r12
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %r12, %rdi
callq 0x4140
movl %r14d, 0x38(%rbx)
andq $0x0, 0x40(%rbx)
movq %r15, 0x10(%rbx)
movl %r13d, 0x8(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0xc(%rbx)
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x4290
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
callq 0x14374
leaq -0x50(%rbp), %rdi
callq 0x40e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x40e0
jmp 0x13b23
jmp 0x13b20
movq %rax, %r14
movq %r12, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %r9d, %r13d
movq %r8, %r15
movl %ecx, %r12d
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x170ad(%rip), %rax     # 0x2ac08
movq %rax, (%rdi)
addq $0x18, %rdi
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
movq %rdi, -0x30(%rbp)
callq 0x4140
movl 0x10(%rbp), %eax
movl %r14d, 0x38(%rbx)
movl %r12d, 0x3c(%rbx)
andq $0x0, 0x40(%rbx)
movq %r15, 0x10(%rbx)
movl %r13d, 0x8(%rbx)
movl %eax, 0xc(%rbx)
cmpl $0xc, %r14d
jne 0x13bab
pushq $0x10
popq %rdi
callq 0x4250
movq %rax, %r13
movl %r12d, (%rax)
leaq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4290
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
movq %r13, %rcx
callq 0x14374
leaq -0x50(%rbp), %rdi
callq 0x40e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x40e0
jmp 0x13bf5
jmp 0x13bf2
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %r15
leaq 0x16fef(%rip), %rax     # 0x2ac20
movq %rax, (%rdi)
leaq 0x18(%rdi), %r13
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %r13, %rdi
callq 0x4140
movq %r14, 0x38(%r15)
movq %r12, 0x10(%r15)
movl %ebx, 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, %rbx
movq %r13, %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %r9, -0x30(%rbp)
movq %r8, %rbx
movq %rcx, %r13
movl %edx, %r12d
movq %rdi, %r15
leaq 0x16f81(%rip), %rax     # 0x2ac38
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $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)
movb %r12b, 0x50(%r15)
movq -0x30(%rbp), %rdx
movq %rdx, 0x10(%r15)
movl %eax, 0x8(%r15)
movl 0xc(%rbx), %eax
movl %eax, 0xc(%r15)
movq %rcx, 0x48(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16f17(%rip), %rax     # 0x2ac50
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_O2/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 0x16ee6(%rip), %rax     # 0x2ac68
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movq %rbx, %rdi
callq 0x4140
movq %r14, 0x18(%r13)
movq %r15, 0x10(%r13)
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x4290
leaq -0x48(%rbp), %rsi
pushq $0xd
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x14374
leaq -0x48(%rbp), %rdi
callq 0x40e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x40e0
jmp 0x13df3
jmp 0x13df0
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
nop
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x16e45(%rip), %rax     # 0x2ac68
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movq %rbx, %rdi
callq 0x4140
andq $0x0, 0x18(%r12)
movq %r14, 0x10(%r12)
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x4290
leaq -0x40(%rbp), %rsi
pushq $0xd
popq %rdx
movq %r14, %rdi
callq 0x14374
leaq -0x40(%rbp), %rdi
callq 0x40e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x40e0
jmp 0x13e92
jmp 0x13e8f
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/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 0x13eef
leaq 0xcfe6(%rip), %rax      # 0x20ebc
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpl $0x9, %edi
jae 0x13eef
movl $0x144, %eax            # imm = 0x144
movl %edi, %ecx
shrl %cl, %eax
jmp 0x13f0e
xorl %eax, %eax
jmp 0x13f0e
popq %rbp
jmp 0x71a4
cmpl $0x9, %edi
jmp 0x13f0b
popq %rbp
jmp 0x7190
movb $0x1, %al
jmp 0x13f0e
cmpl $0x8, %edi
sete %al
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7190
testb %al, %al
je 0x13f32
movl %ebx, %edi
callq 0x7190
jmp 0x13f45
cmpl $0xb, %r14d
je 0x13f54
cmpl $0x9, %r14d
jne 0x13f58
movl %ebx, %edi
callq 0x71a4
movl %eax, %ecx
cmpl $0x9, %ebx
sete %al
orb %cl, %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x13f4f
xorl %eax, %eax
jmp 0x13f4f
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13fa6
movl %esi, %ebx
movl %edi, %ecx
leaq 0xcf70(%rip), %rdx      # 0x20ee4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7190
movl %ebx, %edi
callq 0x7190
movl %eax, %ecx
addl $-0xb, %ebx
cmpl $0x2, %ebx
setb %al
orb %cl, %al
jmp 0x13fa6
cmpl $0x9, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x71a4
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1406b
movl %edx, %ebx
movl %esi, %r14d
leaq 0xcf34(%rip), %rax      # 0x20f10
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %r14d, %edi
callq 0x7190
testb %al, %al
je 0x1406b
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7190
movl %r14d, %edi
callq 0x7190
testb %al, %al
je 0x1401c
movl %ebx, %edi
callq 0x7190
movb $0x1, %r15b
testb %al, %al
jne 0x1406e
movl %r14d, %edi
callq 0x71a4
cmpl $0xb, %ebx
sete %cl
movb $0x1, %r15b
testb %al, %cl
jne 0x1406e
cmpl $0xb, %r14d
jne 0x14042
movl %ebx, %edi
callq 0x71a4
testb %al, %al
jne 0x1406e
movl %r14d, %edi
callq 0x71a4
cmpl $0xc, %ebx
sete %cl
testb %al, %cl
jne 0x1406e
cmpl $0xc, %r14d
jne 0x1406b
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x71a4
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 0x1406e
movl %r14d, %eax
xorl $0xc, %eax
movl %ebx, %ecx
xorl $0xc, %ecx
orl %eax, %ecx
jne 0x13fe5
jmp 0x1406e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7273
testb %al, %al
je 0x140dd
movl %r14d, %edi
callq 0x71a4
testb %al, %al
je 0x140f8
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x71a4
movl %r15d, %edi
callq 0x728a
testb %al, %al
je 0x140f8
xorl $0x9, %r14d
xorl $0x9, %ebx
orl %r14d, %ebx
sete %al
jmp 0x140fa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/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 0x13f5c
pushq $0x11
popq %rcx
testb %al, %al
je 0x14171
cmpl $0xa, %r14d
ja 0x14171
movl $0x58f, %eax            # imm = 0x58F
btl %r14d, %eax
jb 0x14173
cmpl $0x9, %r14d
jne 0x14171
pushq $0x9
popq %rbx
jmp 0x14173
movl %ecx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13fba
movl %eax, %ecx
pushq $0x11
popq %rax
testb %cl, %cl
je 0x14217
addl $-0xb, %r15d
cmpl $0x5, %r15d
ja 0x14217
leaq 0xcd7d(%rip), %rax      # 0x20f28
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 0x71cb
cmpl $0xb, %r14d
sete %al
cmpl $0xb, %ebx
sete %cl
orb %al, %cl
jne 0x14201
cmpl $0xc, %r14d
sete %al
cmpl $0xc, %ebx
sete %cl
orb %al, %cl
jne 0x14214
jmp 0x141b4
pushq $0xa
jmp 0x14216
cmpl $0xb, %r14d
sete %al
cmpl $0xb, %ebx
sete %cl
orb %al, %cl
je 0x14205
pushq $0xb
jmp 0x14216
movl %r14d, %eax
xorl $0xc, %eax
movl %ebx, %ecx
xorl $0xc, %ecx
orl %eax, %ecx
jne 0x141b4
pushq $0xc
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/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 0x140a5
testb %al, %al
je 0x1425d
movl %r14d, %edi
callq 0x7273
testb %al, %al
je 0x14262
movl %r15d, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x71cb
pushq $0x11
popq %rax
jmp 0x14276
movl %r14d, %edi
callq 0x728a
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_O2/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 0x1471a
movl %r14d, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop