LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x70, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2c440
movq -0x68(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2c460
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x68(%rbp), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2c4e0
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2c4b0
testb $0x1, %al
jne 0x2c080
jmp 0x2c0ff
leaq -0x28(%rbp), %rdi
callq 0x2c530
movq -0x70(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2c590
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2c630
movq -0x40(%rbp), %rdi
callq 0x2c5c0
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2c560
testb $0x1, %al
jne 0x2c0ce
jmp 0x2c0e9
leaq -0x48(%rbp), %rdi
callq 0x2c660
movq 0x20(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c106
jmp 0x2c0eb
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x2c5f0
jmp 0x2c05d
movl $0x11, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4430
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x12ecc(%rip), %rsi     # 0x3f035
callq 0x4350
jmp 0x2c170
leaq -0x12(%rbp), %rdi
callq 0x4290
leaq -0x30(%rbp), %rdi
callq 0x2c690
movq -0x80(%rbp), %rax
movq (%rax), %rdi
callq 0x2c6b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x80(%rbp), %rax
movq (%rax), %rdi
callq 0x2c720
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2c6e0
testb $0x1, %al
jne 0x2c1c0
jmp 0x2c2e6
leaq -0x48(%rbp), %rdi
callq 0x2c750
jmp 0x2c1cb
leaq -0x30(%rbp), %rdi
callq 0x2c770
movq (%rax), %rdi
callq 0x2c790
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2c770
movq (%rax), %rdi
callq 0x2c5c0
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2c560
testb $0x1, %al
jne 0x2c213
jmp 0x2c2be
leaq -0x48(%rbp), %rdi
callq 0x2c7c0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x4470
jmp 0x2c22a
movq -0x78(%rbp), %rdi
leaq 0x14036(%rip), %rsi     # 0x4026b
callq 0x4460
jmp 0x2c23c
leaq -0x48(%rbp), %rdi
callq 0x2c7c0
movl 0x20(%rax), %edi
callq 0xb8a0
movq %rax, -0x90(%rbp)
jmp 0x2c256
movq -0x90(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x4460
jmp 0x2c268
movq -0x78(%rbp), %rdi
leaq 0x182b1(%rip), %rsi     # 0x44524
callq 0x4460
jmp 0x2c27a
jmp 0x2c27c
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x2c7f0
movq %rax, -0x60(%rbp)
jmp 0x2c1e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4290
jmp 0x2c31b
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4170
jmp 0x2c31b
movq -0x78(%rbp), %rdi
leaq 0x1823f(%rip), %rsi     # 0x44508
callq 0x4460
jmp 0x2c2d0
jmp 0x2c2d2
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x2c820
movq %rax, -0x68(%rbp)
jmp 0x2c19a
movq -0x78(%rbp), %rdi
leaq 0x18235(%rip), %rsi     # 0x44526
callq 0x4460
jmp 0x2c2f8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2c30b
movq -0x78(%rbp), %rdi
callq 0x4170
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2bd00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5300
movq -0x10(%rbp), %rdi
callq 0x5320
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5390
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5350
testb $0x1, %al
jne 0x2ec03
jmp 0x2ec25
leaq -0x18(%rbp), %rdi
callq 0x53c0
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x53e0
movq %rax, -0x30(%rbp)
jmp 0x2ebe3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2bd70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2f9c0
leaq -0x28(%rbp), %rdi
callq 0x5300
movq -0x10(%rbp), %rdi
callq 0x2f9e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5320
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa50
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2fa10
testb $0x1, %al
jne 0x2ecc0
jmp 0x2ed1a
leaq -0x20(%rbp), %rdi
callq 0x2fa80
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
cmpl $0x9, -0x50(%rbp)
jne 0x2ecf8
cmpq $0x0, -0x48(%rbp)
je 0x2ecf8
leaq -0x28(%rbp), %rdi
callq 0x53c0
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0x2ed1a
jmp 0x2ecfa
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x2faa0
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x53e0
movq %rax, -0x60(%rbp)
jmp 0x2eca0
addq $0x60, %rsp
popq %rbp
retq
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x40f0
movq -0xa0(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0xd, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x40f0
jmp 0x2f8db
movq -0x98(%rbp), %rdi
movups -0x48(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %edx
movq -0x88(%rbp), %rcx
leaq -0x68(%rbp), %rsi
callq 0x2bda0
jmp 0x2f905
leaq -0x68(%rbp), %rdi
callq 0x4170
leaq -0x30(%rbp), %rdi
callq 0x4170
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2f943
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4170
leaq -0x30(%rbp), %rdi
callq 0x4170
movq -0x70(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4100
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4230
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc5c0
movslq (%rax), %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x4030
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2fbf1
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2fbc3
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0xc5c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x24(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc5c0
movslq (%rax), %rdi
shlq $0x4, %rdi
callq 0x4310
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2fcc5
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %edx
subl -0xc(%rbp), %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fc81
movl $0x10, %edi
callq 0x4310
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
leaq -0x3c(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc5c0
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x4, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movb $0x0, -0x16(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2f9c0
movq -0x10(%rbp), %rdi
callq 0x2f9e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa50
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fa10
testb $0x1, %al
jne 0x2fd79
jmp 0x2fdd6
leaq -0x20(%rbp), %rdi
callq 0x2fa80
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0xb, -0x34(%rbp)
jne 0x2fd97
movb $0x1, -0x15(%rbp)
jmp 0x2fdc3
cmpl $0xa, -0x34(%rbp)
jne 0x2fda3
movb $0x1, -0x16(%rbp)
jmp 0x2fdc1
movl -0x34(%rbp), %edi
callq 0xb240
testb $0x1, %al
jne 0x2fdb1
jmp 0x2fdbf
movl -0x14(%rbp), %edi
movl -0x34(%rbp), %esi
callq 0xb340
movl %eax, -0x14(%rbp)
jmp 0x2fdc1
jmp 0x2fdc3
jmp 0x2fdc5
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x2faa0
movq %rax, -0x40(%rbp)
jmp 0x2fd59
testb $0x1, -0x15(%rbp)
je 0x2fde5
movl $0xb, -0x4(%rbp)
jmp 0x2fdfa
testb $0x1, -0x16(%rbp)
je 0x2fdf4
movl $0xa, -0x4(%rbp)
jmp 0x2fdfa
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: getCodeLineBlock(unsigned int, unsigned int)
char* getCodeLineBlock(uint32_t startIndex, uint32_t endIndex) {

  //append all lines to a string object
  string str;
  for(uint32_t i = startIndex; i <= endIndex; i++) {
    str.append("\t");
    str.append(codeLines->at(i));
  }
  
  //return deep copy
  return copyString(str.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4360
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
ja 0x2ff34
leaq 0xf158(%rip), %rsi      # 0x3f034
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x2fee7
movq 0x2451a(%rip), %rdi     # 0x54408
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xa7c0
movq %rax, -0x48(%rbp)
jmp 0x2fefe
movq -0x48(%rbp), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x2ff10
jmp 0x2ff12
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fecd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4170
jmp 0x2ff5e
leaq -0x28(%rbp), %rdi
callq 0x40e0
movq %rax, %rdi
callq 0x2fb10
movq %rax, -0x50(%rbp)
jmp 0x2ff4b
leaq -0x28(%rbp), %rdi
callq 0x4170
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalExponent()
AbstractExpressionNode* evalExponent() {

  AbstractExpressionNode* head = evalPrefixCastSignNot();
  AbstractExpressionNode* next;

  while(peek()->type == EXPONENT) {

    consume(); 
    next = evalPrefixCastSignNot();

    if(typecheckArithmeticExpression(EXPONENT_OP, head->evalType, next->evalType)) {
      head = new ArithmeticOperatorNode(EXPONENT_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "exponentiation", head->evalType, next->evalType);
    }
  }
  
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x37b10
movq %rax, -0x8(%rbp)
callq 0x2fe60
cmpl $0xb, (%rax)
jne 0x38340
callq 0x2fe10
callq 0x37b10
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movl $0xb, %edi
callq 0x2b6e0
testb $0x1, %al
jne 0x3825b
jmp 0x382aa
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0xb, %esi
callq 0xd440
jmp 0x38283
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3833b
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4240
jmp 0x3834a
movl $0x38, %edi
callq 0x4130
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x34(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x30(%rbp)
jmp 0x382db
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
movq %rsp, %rax
movl %r8d, (%rax)
leaq 0x7db5(%rip), %r8       # 0x400bb
callq 0x3a820
jmp 0x3830d
movq -0x40(%rbp), %rdi
leaq 0x1b3d0(%rip), %rsi     # 0x536e8
leaq -0x3135f(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41d0
jmp 0x3834a
jmp 0x38221
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalMultiplyDivideMod()
AbstractExpressionNode* evalMultiplyDivideMod() {

  AbstractExpressionNode* head = evalExponent();
  AbstractExpressionNode* next;

  while(isMultiplyDivideModTokenType(peek()->type)) {
    ParseOperatorType op = binaryTokenConversion(consume()->type);
    next = evalExponent();

    if(typecheckArithmeticExpression(op, head->evalType, next->evalType)) {
      head = new ArithmeticOperatorNode(op, head, next);
    } else {
      //!!!
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), toWordParseOperatorType(op), head->evalType, next->evalType);
    }

  }

  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
callq 0x38210
movq %rax, -0x8(%rbp)
callq 0x2fe60
movl (%rax), %edi
callq 0x8340
testb $0x1, %al
jne 0x38386
jmp 0x384a8
callq 0x2fe10
movl (%rax), %edi
callq 0xb700
movl %eax, -0x14(%rbp)
callq 0x38210
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2b6e0
testb $0x1, %al
jne 0x383ba
jmp 0x38407
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xd440
jmp 0x383e0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x384a3
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4240
jmp 0x384b2
movl $0x38, %edi
callq 0x4130
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x3c(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x38(%rbp)
jmp 0x38438
movl -0x14(%rbp), %edi
callq 0xbc30
movq %rax, -0x50(%rbp)
jmp 0x38446
movq -0x50(%rbp), %r8
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %esi
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0x3a820
jmp 0x38475
movq -0x48(%rbp), %rdi
leaq 0x1b268(%rip), %rsi     # 0x536e8
leaq -0x314c7(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x41d0
jmp 0x384b2
jmp 0x38371
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4420
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalAddSubtract()
AbstractExpressionNode* evalAddSubtract() {

  AbstractExpressionNode* head = evalMultiplyDivideMod();
  AbstractExpressionNode* next;

  while(isAddSubtractTokenType(peek()->type)) {
    ParseOperatorType op = binaryTokenConversion(consume()->type);
    next = evalMultiplyDivideMod();

    if(typecheckArithmeticExpression(op, head->evalType, next->evalType)) {
      head = new ArithmeticOperatorNode(op, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), toWordParseOperatorType(op), head->evalType, next->evalType);
    }
  }
  
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
callq 0x38360
movq %rax, -0x8(%rbp)
callq 0x2fe60
movl (%rax), %edi
callq 0x8370
testb $0x1, %al
jne 0x384e6
jmp 0x38608
callq 0x2fe10
movl (%rax), %edi
callq 0xb700
movl %eax, -0x14(%rbp)
callq 0x38360
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2b6e0
testb $0x1, %al
jne 0x3851a
jmp 0x38567
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xd440
jmp 0x38540
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38603
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4240
jmp 0x38612
movl $0x38, %edi
callq 0x4130
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x3c(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x38(%rbp)
jmp 0x38598
movl -0x14(%rbp), %edi
callq 0xbc30
movq %rax, -0x50(%rbp)
jmp 0x385a6
movq -0x50(%rbp), %r8
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %esi
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0x3a820
jmp 0x385d5
movq -0x48(%rbp), %rdi
leaq 0x1b108(%rip), %rsi     # 0x536e8
leaq -0x31627(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x41d0
jmp 0x38612
jmp 0x384d1
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4420
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalBitShift()
AbstractExpressionNode* evalBitShift() {

  AbstractExpressionNode* head = evalAddSubtract();
  AbstractExpressionNode* next;

  while(isBitShiftTokenType(peek()->type)) {
    ParseOperatorType op = binaryTokenConversion(consume()->type);
    next = evalAddSubtract();

    if(typecheckBitLogicalExpression(op, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(op, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), toWordParseOperatorType(op), head->evalType, next->evalType);
    }
  }
  
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
callq 0x384c0
movq %rax, -0x8(%rbp)
callq 0x2fe60
movl (%rax), %edi
callq 0x83a0
testb $0x1, %al
jne 0x38646
jmp 0x38768
callq 0x2fe10
movl (%rax), %edi
callq 0xb700
movl %eax, -0x14(%rbp)
callq 0x384c0
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2b8d0
testb $0x1, %al
jne 0x3867a
jmp 0x386c7
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xd510
jmp 0x386a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38763
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4240
jmp 0x38772
movl $0x38, %edi
callq 0x4130
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x3c(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x38(%rbp)
jmp 0x386f8
movl -0x14(%rbp), %edi
callq 0xbc30
movq %rax, -0x50(%rbp)
jmp 0x38706
movq -0x50(%rbp), %r8
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %esi
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0x3a820
jmp 0x38735
movq -0x48(%rbp), %rdi
leaq 0x1afa8(%rip), %rsi     # 0x536e8
leaq -0x31787(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x41d0
jmp 0x38772
jmp 0x38631
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4420
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalComparison()
AbstractExpressionNode* evalComparison() {

  AbstractExpressionNode* head = evalBitShift();
  AbstractExpressionNode* next;

  while(isInequalityTokenType(peek()->type)) {
    ParseOperatorType op = binaryTokenConversion(consume()->type);
    next = evalBitShift();

    if(typecheckComparisonExpression(op, head->evalType, next->evalType)) {
      head = new ComparisonOperatorNode(op, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), toWordParseOperatorType(op), head->evalType, next->evalType); 
    }
  }
  
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
callq 0x38620
movq %rax, -0x8(%rbp)
callq 0x2fe60
movl (%rax), %edi
callq 0x83d0
testb $0x1, %al
jne 0x387a6
jmp 0x388c8
callq 0x2fe10
movl (%rax), %edi
callq 0xb700
movl %eax, -0x14(%rbp)
callq 0x38620
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2b960
testb $0x1, %al
jne 0x387da
jmp 0x38827
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xd5e0
jmp 0x38800
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x388c3
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4240
jmp 0x388d2
movl $0x38, %edi
callq 0x4130
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x3c(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x38(%rbp)
jmp 0x38858
movl -0x14(%rbp), %edi
callq 0xbc30
movq %rax, -0x50(%rbp)
jmp 0x38866
movq -0x50(%rbp), %r8
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %esi
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0x3a820
jmp 0x38895
movq -0x48(%rbp), %rdi
leaq 0x1ae48(%rip), %rsi     # 0x536e8
leaq -0x318e7(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x41d0
jmp 0x388d2
jmp 0x38791
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4420
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalEquality()
AbstractExpressionNode* evalEquality() {

  AbstractExpressionNode* head = evalComparison();
  AbstractExpressionNode* next;

  while(isEqualityTokenType(peek()->type)) {
    ParseOperatorType op = binaryTokenConversion(consume()->type);
    next = evalComparison();

    if(typecheckComparisonExpression(op, head->evalType, next->evalType)) {
      head = new ComparisonOperatorNode(op, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), toWordParseOperatorType(op), head->evalType, next->evalType);  
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
callq 0x38780
movq %rax, -0x8(%rbp)
callq 0x2fe60
movl (%rax), %edi
callq 0x8410
testb $0x1, %al
jne 0x38906
jmp 0x38a28
callq 0x2fe10
movl (%rax), %edi
callq 0xb700
movl %eax, -0x14(%rbp)
callq 0x38780
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2b960
testb $0x1, %al
jne 0x3893a
jmp 0x38987
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xd5e0
jmp 0x38960
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38a23
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4240
jmp 0x38a32
movl $0x38, %edi
callq 0x4130
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x3c(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x38(%rbp)
jmp 0x389b8
movl -0x14(%rbp), %edi
callq 0xbc30
movq %rax, -0x50(%rbp)
jmp 0x389c6
movq -0x50(%rbp), %r8
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %esi
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0x3a820
jmp 0x389f5
movq -0x48(%rbp), %rdi
leaq 0x1ace8(%rip), %rsi     # 0x536e8
leaq -0x31a47(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x41d0
jmp 0x38a32
jmp 0x388f1
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4420
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalBitAnd()
AbstractExpressionNode* evalBitAnd() {

  AbstractExpressionNode* head = evalEquality();
  AbstractExpressionNode* next;

  while(peek()->type == BIT_AND) {
    consume();
    next = evalEquality();

    if(typecheckBitLogicalExpression(BIT_AND_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(BIT_AND_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "bitwise AND", head->evalType, next->evalType); 
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x388e0
movq %rax, -0x8(%rbp)
callq 0x2fe60
cmpl $0x17, (%rax)
jne 0x38b70
callq 0x2fe10
callq 0x388e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x19, %edi
callq 0x2b8d0
testb $0x1, %al
jne 0x38a8b
jmp 0x38ada
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x19, %esi
callq 0xd510
jmp 0x38ab3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38b6b
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4240
jmp 0x38b7a
movl $0x38, %edi
callq 0x4130
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x34(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x30(%rbp)
jmp 0x38b0b
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
movq %rsp, %rax
movl %r8d, (%rax)
leaq 0x7618(%rip), %r8       # 0x4014e
callq 0x3a820
jmp 0x38b3d
movq -0x40(%rbp), %rdi
leaq 0x1aba0(%rip), %rsi     # 0x536e8
leaq -0x31b8f(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41d0
jmp 0x38b7a
jmp 0x38a51
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalBitXor()
AbstractExpressionNode* evalBitXor() {

  AbstractExpressionNode* head = evalBitAnd();
  AbstractExpressionNode* next;

  while(peek()->type == BIT_XOR) {
    consume();
    next = evalBitAnd();

    if(typecheckBitLogicalExpression(BIT_XOR_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(BIT_XOR_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "bitwise XOR", head->evalType, next->evalType); 
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x38a40
movq %rax, -0x8(%rbp)
callq 0x2fe60
cmpl $0x18, (%rax)
jne 0x38cc0
callq 0x2fe10
callq 0x38a40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x1a, %edi
callq 0x2b8d0
testb $0x1, %al
jne 0x38bdb
jmp 0x38c2a
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1a, %esi
callq 0xd510
jmp 0x38c03
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38cbb
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4240
jmp 0x38cca
movl $0x38, %edi
callq 0x4130
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x34(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x30(%rbp)
jmp 0x38c5b
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
movq %rsp, %rax
movl %r8d, (%rax)
leaq 0x74d4(%rip), %r8       # 0x4015a
callq 0x3a820
jmp 0x38c8d
movq -0x40(%rbp), %rdi
leaq 0x1aa50(%rip), %rsi     # 0x536e8
leaq -0x31cdf(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41d0
jmp 0x38cca
jmp 0x38ba1
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalBitOr()
AbstractExpressionNode* evalBitOr() {

  AbstractExpressionNode* head = evalBitXor();
  AbstractExpressionNode* next;

  while(peek()->type == BIT_OR) {
    consume();
    next = evalBitXor();

    if(typecheckBitLogicalExpression(BIT_OR_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(BIT_OR_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "bitwise OR", head->evalType, next->evalType);
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x38b90
movq %rax, -0x8(%rbp)
callq 0x2fe60
cmpl $0x19, (%rax)
jne 0x38e10
callq 0x2fe10
callq 0x38b90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x1b, %edi
callq 0x2b8d0
testb $0x1, %al
jne 0x38d2b
jmp 0x38d7a
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1b, %esi
callq 0xd510
jmp 0x38d53
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38e0b
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4240
jmp 0x38e1a
movl $0x38, %edi
callq 0x4130
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x34(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x30(%rbp)
jmp 0x38dab
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
movq %rsp, %rax
movl %r8d, (%rax)
leaq 0x7390(%rip), %r8       # 0x40166
callq 0x3a820
jmp 0x38ddd
movq -0x40(%rbp), %rdi
leaq 0x1a900(%rip), %rsi     # 0x536e8
leaq -0x31e2f(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41d0
jmp 0x38e1a
jmp 0x38cf1
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalLogicAnd()
AbstractExpressionNode* evalLogicAnd() {

  AbstractExpressionNode* head = evalBitOr();
  AbstractExpressionNode* next;

  while(peek()->type == AND) {
    consume();
    next = evalBitOr();

    if(typecheckBitLogicalExpression(AND_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(AND_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "logical AND", head->evalType, next->evalType);  
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x38ce0
movq %rax, -0x8(%rbp)
callq 0x2fe60
cmpl $0x1a, (%rax)
jne 0x38f60
callq 0x2fe10
callq 0x38ce0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x1c, %edi
callq 0x2b8d0
testb $0x1, %al
jne 0x38e7b
jmp 0x38eca
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1c, %esi
callq 0xd510
jmp 0x38ea3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38f5b
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4240
jmp 0x38f6a
movl $0x38, %edi
callq 0x4130
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x34(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x30(%rbp)
jmp 0x38efb
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
movq %rsp, %rax
movl %r8d, (%rax)
leaq 0x724b(%rip), %r8       # 0x40171
callq 0x3a820
jmp 0x38f2d
movq -0x40(%rbp), %rdi
leaq 0x1a7b0(%rip), %rsi     # 0x536e8
leaq -0x31f7f(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41d0
jmp 0x38f6a
jmp 0x38e41
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalLogicXor()
AbstractExpressionNode* evalLogicXor() {

  AbstractExpressionNode* head = evalLogicAnd();
  AbstractExpressionNode* next;

  while(peek()->type == XOR) {
    consume();
    next = evalLogicAnd();

    if(typecheckBitLogicalExpression(XOR_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(XOR_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "logical XOR", head->evalType, next->evalType); 
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x38e30
movq %rax, -0x8(%rbp)
callq 0x2fe60
cmpl $0x1b, (%rax)
jne 0x390b0
callq 0x2fe10
callq 0x38e30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x1d, %edi
callq 0x2b8d0
testb $0x1, %al
jne 0x38fcb
jmp 0x3901a
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1d, %esi
callq 0xd510
jmp 0x38ff3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x390ab
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4240
jmp 0x390ba
movl $0x38, %edi
callq 0x4130
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x34(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x30(%rbp)
jmp 0x3904b
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
movq %rsp, %rax
movl %r8d, (%rax)
leaq 0x7107(%rip), %r8       # 0x4017d
callq 0x3a820
jmp 0x3907d
movq -0x40(%rbp), %rdi
leaq 0x1a660(%rip), %rsi     # 0x536e8
leaq -0x320cf(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41d0
jmp 0x390ba
jmp 0x38f91
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalLogicOr()
AbstractExpressionNode* evalLogicOr() {

  AbstractExpressionNode* head = evalLogicXor();
  AbstractExpressionNode* next;

  while(peek()->type == OR) {
    consume();
    next = evalLogicXor();

    if(typecheckBitLogicalExpression(OR_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(OR_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "logical OR", head->evalType, next->evalType);  
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x38f80
movq %rax, -0x8(%rbp)
callq 0x2fe60
cmpl $0x1c, (%rax)
jne 0x39200
callq 0x2fe10
callq 0x38f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x1e, %edi
callq 0x2b8d0
testb $0x1, %al
jne 0x3911b
jmp 0x3916a
movl $0x30, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1e, %esi
callq 0xd510
jmp 0x39143
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x391fb
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4240
jmp 0x3920a
movl $0x38, %edi
callq 0x4130
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl %edi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, -0x34(%rbp)
decl %edi
decl %esi
callq 0x2feb0
movq %rax, -0x30(%rbp)
jmp 0x3919b
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
movq %rsp, %rax
movl %r8d, (%rax)
leaq 0x6fc3(%rip), %r8       # 0x40189
callq 0x3a820
jmp 0x391cd
movq -0x40(%rbp), %rdi
leaq 0x1a510(%rip), %rsi     # 0x536e8
leaq -0x3221f(%rip), %rdx    # 0x6fc0
callq 0x43f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41d0
jmp 0x3920a
jmp 0x390e1
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)