LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/symboltable.cpp
// Function: SymbolTable::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseData)
void SymbolTable::update(string var, ParseData value) {

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

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

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

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

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

	std::string str = "";

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

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

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

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7b53(%rip), %rsi      # 0x1c035
leaq -0x29(%rbp), %rdx
callq 0x40a0
movq %r14, -0x38(%rbp)
movq (%r14), %rax
movq (%rax), %r15
leaq 0x8b2f(%rip), %r12      # 0x1d02b
leaq 0xca59(%rip), %r13      # 0x20f5c
cmpq 0x8(%rax), %r15
je 0x1456c
movq (%r15), %r14
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x14550
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4370
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4360
movl 0x28(%r14), %edi
callq 0x730e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4360
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4360
jmp 0x14510
movq %rbx, %rdi
leaq 0xc9e6(%rip), %rsi      # 0x20f40
callq 0x4360
addq $0x8, %r15
movq -0x38(%rbp), %rax
movq (%rax), %rax
jmp 0x14503
leaq 0xc9eb(%rip), %rsi      # 0x20f5e
movq %rbx, %rdi
callq 0x4360
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14591
jmp 0x14591
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/executor.cpp
// Function: executeGroupedStatement(GroupedStatementNode*)
void executeGroupedStatement(GroupedStatementNode* node) {
  
  //symbol table enters new scope
  node->symbolTable->enterNewScope();
  
  //sequentially execute statements
  std::vector<AbstractStatementNode*>* statements = node->statements;
  std::vector<AbstractStatementNode*>::iterator it;
  
  for(it = statements->begin(); it != statements->end(); it++) {
    (*it)->execute();
  }
	
	//leave the block scope
	node->symbolTable->leaveScope();
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %rax
movq (%rbx), %r15
movq (%rax), %r14
cmpq 0x8(%rbx), %r15
je 0x14d4c
movq (%r15), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x9, %eax
setne %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x14d57
addq $0x8, %r15
addq $0x8, %r14
jmp 0x14d24
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/executor.cpp
// Function: executeNewAssignmentStatement(NewAssignmentStatementNode*)
void executeNewAssignmentStatement(NewAssignmentStatementNode* node) {
  
  //get stuff out of the node first
  SymbolTable* symbolTable = node->symbolTable;
  std::string variable = node->variable;
  ParseDataType type = node->type;
	ParseDataType subType = node->subType;
  
  //add variable to table
  if(node->value != NULL) {

    ParseData d = node->value->evaluate();
				
		if(type == ARRAY_T) {

			//if array, change array value's subtype to fit variable's subtype
			Array* arr = (Array*) d.value.allocated;
			arr->subtype = subType;
			symbolTable->declare(variable, d);

		} else {
			//consider implicit casting
    	symbolTable->declare(variable, castHelper(d, type));
		}

  } else {
    
    ParseData d;
    d.type = symbolTable->get(variable).type;
    symbolTable->declare(variable, castHelper(d, type));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rbx
leaq 0x18(%rdi), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4290
movl 0x38(%r14), %r15d
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x14de4
movl 0x3c(%r14), %r14d
movq (%rdi), %rax
callq *(%rax)
movl %eax, %r13d
movq %rdx, %r12
cmpl $0xc, %r15d
jne 0x14e39
movl %r14d, (%r12)
leaq -0xc8(%rbp), %r14
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x4290
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
movq %r12, %rcx
callq 0x14374
jmp 0x14e6a
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4290
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x14476
movl %eax, %r12d
leaq -0x68(%rbp), %rdi
callq 0x40e0
leaq -0x88(%rbp), %r14
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x4290
movl %r12d, %edi
movl %r15d, %edx
callq 0x13380
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x14374
jmp 0x14e6a
leaq -0xa8(%rbp), %r14
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x4290
movl %r13d, %edi
movq %r12, %rsi
movl %r15d, %edx
callq 0x13380
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x14374
movq %r14, %rdi
callq 0x40e0
leaq -0x48(%rbp), %rdi
callq 0x40e0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
jmp 0x14ebe
jmp 0x14ec5
jmp 0x14ec5
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x14ebe
jmp 0x14ec5
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
jmp 0x14ebe
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x40e0
jmp 0x14ec8
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/executor.cpp
// Function: executeAssignmentStatement(AssignmentStatementNode*)
void executeAssignmentStatement(AssignmentStatementNode* node) {
	
  //get stuff out of the node first
  SymbolTable* symbolTable = node->symbolTable;
  std::string variable = node->variable;
  AbstractExpressionNode* value = node->value;
  
  ParseDataType type = (symbolTable->get(variable)).type;
  ParseData d = value->evaluate();

	if(type == ARRAY_T) {

		//deep copy of array, casting as necessary
		Array* arr = (Array*) (symbolTable->get(variable)).value.allocated;
		ParseDataType subType = arr->subtype;

		Array* origArr = (Array*) d.value.allocated;
		uint32_t length = arr->length = origArr->length;
		
		ParseData* values = new ParseData[length];
		ParseData* origValues = origArr->values;

		for(uint32_t i = 0; i < length; i++) {
			values[i] = castHelper(origValues[i], subType);
		}

		arr->values = values;

	} else {
		//update variable value (innermost scope)
  	symbolTable->update(variable, castHelper(d, type));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rbx
leaq 0x18(%rdi), %rsi
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x4290
movq 0x38(%r14), %r14
leaq -0xb0(%rbp), %rdi
movq %r15, %rsi
callq 0x4290
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0x14476
movl %eax, %r15d
leaq -0xb0(%rbp), %rdi
callq 0x40e0
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rdx, %r14
cmpl $0xc, %r15d
jne 0x14fbe
leaq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4290
leaq -0x90(%rbp), %rsi
movq %rbx, %rdi
callq 0x14476
movq %rdx, %rbx
leaq -0x90(%rbp), %rdi
callq 0x40e0
movl (%rbx), %r15d
movl 0x4(%r14), %r12d
movq %rbx, -0x30(%rbp)
movl %r12d, 0x4(%rbx)
shlq $0x4, %r12
movq %r12, %rdi
callq 0x4030
movq %rax, %r13
movq 0x8(%r14), %r14
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x14ff8
movl (%r14,%rbx), %edi
movq 0x8(%r14,%rbx), %rsi
movl %r15d, %edx
callq 0x13380
movl %eax, (%r13,%rbx)
movq %rdx, 0x8(%r13,%rbx)
addq $0x10, %rbx
jmp 0x14f98
movl %eax, %r12d
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4290
movl %r12d, %edi
movq %r14, %rsi
movl %r15d, %edx
callq 0x13380
movq %rdx, %rcx
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x1439e
leaq -0x70(%rbp), %rdi
callq 0x40e0
jmp 0x15000
movq -0x30(%rbp), %rax
movq %r13, 0x8(%rax)
leaq -0x50(%rbp), %rdi
callq 0x40e0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15049
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x1503e
jmp 0x15049
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x1503e
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x40e0
jmp 0x1504c
jmp 0x15049
jmp 0x15049
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/executor.cpp
// Function: executeFunctionStatement(FunctionStatementNode*)
void executeFunctionStatement(FunctionStatementNode* node) {

	SymbolTable* symbolTable = node->symbolTable;
	std::string functionName = node->functionName;
	Function* function = node->function;

	ParseData d;
	d.type = FUN_T;
	d.value.allocated = (void*) function;

	//declare the function, with or without implementation
	symbolTable->declare(functionName, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x4290
movq 0x18(%r14), %r14
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x4290
leaq -0x38(%rbp), %rsi
pushq $0xd
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x14374
leaq -0x38(%rbp), %rdi
callq 0x40e0
leaq -0x58(%rbp), %rdi
callq 0x40e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x40e0
jmp 0x152ac
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/utils.cpp
// Function: copyString(char const*)
char* copyString(const char* str) {

	uint32_t len = strlen(str);
	char* copy = new char[len+1];
	copy[0] = '\0';

	strcpy(copy, str);
	copy[len] = '\0';

	return copy;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl %edx, %r12d
subl %esi, %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
leal 0x1(%r12), %edi
callq 0x4030
movslq %r15d, %rcx
movslq %r14d, %rdx
addq %rcx, %rbx
leaq (%rcx,%r13), %rsi
cmpq %rdx, %rsi
jge 0x15379
movb (%rbx,%r13), %sil
movb %sil, (%rax,%r13)
incq %r13
jmp 0x15363
movl %r12d, %ecx
movb $0x0, (%rax,%rcx)
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/utils.cpp
// Function: copySubarray(Array*, int, int)
Array* copySubarray(Array* arr, int32_t startIndex, int32_t pastEndIndex) {

	//extract fields from Array
	ParseData* values = arr->values;

	ParseData* subarrayValues = (ParseData*) malloc(sizeof(ParseData) * std::max(pastEndIndex-startIndex, 1));
	for(int32_t i = startIndex; i < pastEndIndex; i++) {
		subarrayValues[i-startIndex] = values[i];
	}

	//create subarray Array and return it
	Array* subarray = (Array*) malloc(sizeof(Array));
	subarray->length = (uint32_t) std::max(pastEndIndex-startIndex, 0);
	subarray->subtype = arr->subtype;
	subarray->values = subarrayValues;

	return subarray;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %r12
pushq $0x4
popq %rbx
movl $0x0, -0x2c(%rbp)
xorl %r13d, %r13d
cmpq 0x8(%r14), %r12
je 0x15485
movq (%r12), %rax
movl 0x10(%rax), %r15d
cmpl $0xb, %r15d
je 0x15462
cmpl $0xa, %r15d
jne 0x15467
movb $0x1, %al
movl %eax, -0x2c(%rbp)
jmp 0x1547f
movb $0x1, %r13b
jmp 0x1547f
movl %r15d, %edi
callq 0x71a4
testb %al, %al
je 0x1547f
movl %ebx, %edi
movl %r15d, %esi
callq 0x71cb
movl %eax, %ebx
addq $0x8, %r12
jmp 0x15441
testb $0x1, -0x2c(%rbp)
pushq $0xa
popq %rax
cmovnel %eax, %ebx
testb $0x1, %r13b
pushq $0xb
popq %rax
cmovel %ebx, %eax
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/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movl %edi, %r14d
movb $0x0, (%rax)
leaq 0x6b05(%rip), %r15      # 0x1c034
leaq -0x40(%rbp), %r12
cmpl %ebx, %r14d
ja 0x15562
movq %r12, %rdi
movq %r15, %rsi
callq 0x4360
movq 0x15d26(%rip), %rdi     # 0x2b270
movl %r14d, %esi
callq 0x6f18
movq (%rax), %rsi
movq %r12, %rdi
callq 0x4360
incl %r14d
jmp 0x15533
movq -0x40(%rbp), %rdi
callq 0x152e4
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x40e0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15589
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1922b
movq %rax, %rbx
pushq $0xb
popq %r15
pushq $0x30
popq %r12
callq 0x154d4
cmpl $0xb, (%rax)
jne 0x196bd
callq 0x154a8
callq 0x1922b
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x13fba
testb %al, %al
je 0x196cf
movq %r12, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7bfe
movq %r13, %rbx
jmp 0x19673
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x15504
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0x10f12(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x3764(%rip), %rax      # 0x1ce7b
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0x10f01(%rip), %rsi     # 0x2a638
movq 0x1189a(%rip), %rdx     # 0x2afd8
movq %r15, %rdi
callq 0x4310
movq %rax, %rbx
movq %r15, %rdi
callq 0x4180
jmp 0x1975e
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x19655
movq %rax, %rbx
pushq $0x30
popq %r14
callq 0x154d4
movl (%rax), %edi
callq 0x5a85
testb %al, %al
je 0x197dd
callq 0x154a8
movl (%rax), %edi
callq 0x72ed
movl %eax, %r12d
callq 0x19655
movq %rax, %r15
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r12d, %edi
callq 0x13fba
testb %al, %al
je 0x197ef
movq %r14, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x7bfe
movq %r13, %rbx
jmp 0x19783
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r14
movl 0x8(%rbx), %r13d
movl 0xc(%r15), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x15504
movq %rax, -0x30(%rbp)
movl %r12d, %edi
callq 0x7359
movl 0x10(%rbx), %ecx
movl 0x10(%r15), %edx
leaq 0x10de4(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r14)
movw $0x1, 0x8(%r14)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r14)
movq %rax, 0x18(%r14)
andq $0x0, 0x20(%r14)
movl %r13d, 0x28(%r14)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r14)
movl %ecx, 0x30(%r14)
movl %edx, 0x34(%r14)
leaq 0x10dd2(%rip), %rsi     # 0x2a638
movq 0x1176b(%rip), %rdx     # 0x2afd8
movq %r14, %rdi
callq 0x4310
movq %rax, %rbx
movq %r14, %rdi
callq 0x4180
jmp 0x1988d
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x19766
movq %rax, %rbx
pushq $0x30
popq %r14
callq 0x154d4
movl (%rax), %edi
callq 0x5a9e
testb %al, %al
je 0x1990c
callq 0x154a8
movl (%rax), %edi
callq 0x72ed
movl %eax, %r12d
callq 0x19766
movq %rax, %r15
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r12d, %edi
callq 0x13fba
testb %al, %al
je 0x1991e
movq %r14, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x7bfe
movq %r13, %rbx
jmp 0x198b2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r14
movl 0x8(%rbx), %r13d
movl 0xc(%r15), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x15504
movq %rax, -0x30(%rbp)
movl %r12d, %edi
callq 0x7359
movl 0x10(%rbx), %ecx
movl 0x10(%r15), %edx
leaq 0x10cb5(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r14)
movw $0x1, 0x8(%r14)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r14)
movq %rax, 0x18(%r14)
andq $0x0, 0x20(%r14)
movl %r13d, 0x28(%r14)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r14)
movl %ecx, 0x30(%r14)
movl %edx, 0x34(%r14)
leaq 0x10ca3(%rip), %rsi     # 0x2a638
movq 0x1163c(%rip), %rdx     # 0x2afd8
movq %r14, %rdi
callq 0x4310
movq %rax, %rbx
movq %r14, %rdi
callq 0x4180
jmp 0x199bc
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x19895
movq %rax, %rbx
pushq $0x30
popq %r14
callq 0x154d4
movl (%rax), %edi
callq 0x5aad
testb %al, %al
je 0x19a3b
callq 0x154a8
movl (%rax), %edi
callq 0x72ed
movl %eax, %r12d
callq 0x19895
movq %rax, %r15
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r12d, %edi
callq 0x140a5
testb %al, %al
je 0x19a4d
movq %r14, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x7c5c
movq %r13, %rbx
jmp 0x199e1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r14
movl 0x8(%rbx), %r13d
movl 0xc(%r15), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x15504
movq %rax, -0x30(%rbp)
movl %r12d, %edi
callq 0x7359
movl 0x10(%rbx), %ecx
movl 0x10(%r15), %edx
leaq 0x10b86(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r14)
movw $0x1, 0x8(%r14)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r14)
movq %rax, 0x18(%r14)
andq $0x0, 0x20(%r14)
movl %r13d, 0x28(%r14)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r14)
movl %ecx, 0x30(%r14)
movl %edx, 0x34(%r14)
leaq 0x10b74(%rip), %rsi     # 0x2a638
movq 0x1150d(%rip), %rdx     # 0x2afd8
movq %r14, %rdi
callq 0x4310
movq %rax, %rbx
movq %r14, %rdi
callq 0x4180
jmp 0x19aeb
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x199c4
movq %rax, %rbx
pushq $0x30
popq %r14
callq 0x154d4
movl (%rax), %edi
callq 0x5abc
testb %al, %al
je 0x19b6a
callq 0x154a8
movl (%rax), %edi
callq 0x72ed
movl %eax, %r12d
callq 0x199c4
movq %rax, %r15
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r12d, %edi
callq 0x14105
testb %al, %al
je 0x19b7c
movq %r14, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x7cba
movq %r13, %rbx
jmp 0x19b10
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r14
movl 0x8(%rbx), %r13d
movl 0xc(%r15), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x15504
movq %rax, -0x30(%rbp)
movl %r12d, %edi
callq 0x7359
movl 0x10(%rbx), %ecx
movl 0x10(%r15), %edx
leaq 0x10a57(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r14)
movw $0x1, 0x8(%r14)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r14)
movq %rax, 0x18(%r14)
andq $0x0, 0x20(%r14)
movl %r13d, 0x28(%r14)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r14)
movl %ecx, 0x30(%r14)
movl %edx, 0x34(%r14)
leaq 0x10a45(%rip), %rsi     # 0x2a638
movq 0x113de(%rip), %rdx     # 0x2afd8
movq %r14, %rdi
callq 0x4310
movq %rax, %rbx
movq %r14, %rdi
callq 0x4180
jmp 0x19c1a
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x19af3
movq %rax, %rbx
pushq $0x30
popq %r14
callq 0x154d4
movl (%rax), %edi
callq 0x5acb
testb %al, %al
je 0x19c99
callq 0x154a8
movl (%rax), %edi
callq 0x72ed
movl %eax, %r12d
callq 0x19af3
movq %rax, %r15
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r12d, %edi
callq 0x14105
testb %al, %al
je 0x19cab
movq %r14, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x7cba
movq %r13, %rbx
jmp 0x19c3f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r14
movl 0x8(%rbx), %r13d
movl 0xc(%r15), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x15504
movq %rax, -0x30(%rbp)
movl %r12d, %edi
callq 0x7359
movl 0x10(%rbx), %ecx
movl 0x10(%r15), %edx
leaq 0x10928(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r14)
movw $0x1, 0x8(%r14)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r14)
movq %rax, 0x18(%r14)
andq $0x0, 0x20(%r14)
movl %r13d, 0x28(%r14)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r14)
movl %ecx, 0x30(%r14)
movl %edx, 0x34(%r14)
leaq 0x10916(%rip), %rsi     # 0x2a638
movq 0x112af(%rip), %rdx     # 0x2afd8
movq %r14, %rdi
callq 0x4310
movq %rax, %rbx
movq %r14, %rdi
callq 0x4180
jmp 0x19d49
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x19c22
movq %rax, %rbx
pushq $0x19
popq %r15
pushq $0x30
popq %r12
callq 0x154d4
cmpl $0x17, (%rax)
jne 0x19db9
callq 0x154a8
callq 0x19c22
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x140a5
testb %al, %al
je 0x19dcb
movq %r12, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7c5c
movq %r13, %rbx
jmp 0x19d6f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x15504
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0x10816(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x30fb(%rip), %rax      # 0x1cf0e
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0x10805(%rip), %rsi     # 0x2a638
movq 0x1119e(%rip), %rdx     # 0x2afd8
movq %r15, %rdi
callq 0x4310
movq %rax, %rbx
movq %r15, %rdi
callq 0x4180
jmp 0x19e5a
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x19d51
movq %rax, %rbx
pushq $0x1a
popq %r15
pushq $0x30
popq %r12
callq 0x154d4
cmpl $0x18, (%rax)
jne 0x19eca
callq 0x154a8
callq 0x19d51
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x140a5
testb %al, %al
je 0x19edc
movq %r12, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7c5c
movq %r13, %rbx
jmp 0x19e80
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x15504
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0x10705(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2ff6(%rip), %rax      # 0x1cf1a
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0x106f4(%rip), %rsi     # 0x2a638
movq 0x1108d(%rip), %rdx     # 0x2afd8
movq %r15, %rdi
callq 0x4310
movq %rax, %rbx
movq %r15, %rdi
callq 0x4180
jmp 0x19f6b
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x19e62
movq %rax, %rbx
pushq $0x1b
popq %r15
pushq $0x30
popq %r12
callq 0x154d4
cmpl $0x19, (%rax)
jne 0x19fdb
callq 0x154a8
callq 0x19e62
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x140a5
testb %al, %al
je 0x19fed
movq %r12, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7c5c
movq %r13, %rbx
jmp 0x19f91
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x15504
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0x105f4(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2ef1(%rip), %rax      # 0x1cf26
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0x105e3(%rip), %rsi     # 0x2a638
movq 0x10f7c(%rip), %rdx     # 0x2afd8
movq %r15, %rdi
callq 0x4310
movq %rax, %rbx
movq %r15, %rdi
callq 0x4180
jmp 0x1a07c
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x19f73
movq %rax, %rbx
pushq $0x1c
popq %r15
pushq $0x30
popq %r12
callq 0x154d4
cmpl $0x1a, (%rax)
jne 0x1a0ec
callq 0x154a8
callq 0x19f73
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x140a5
testb %al, %al
je 0x1a0fe
movq %r12, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7c5c
movq %r13, %rbx
jmp 0x1a0a2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x15504
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0x104e3(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2deb(%rip), %rax      # 0x1cf31
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0x104d2(%rip), %rsi     # 0x2a638
movq 0x10e6b(%rip), %rdx     # 0x2afd8
movq %r15, %rdi
callq 0x4310
movq %rax, %rbx
movq %r15, %rdi
callq 0x4180
jmp 0x1a18d
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1a084
movq %rax, %rbx
pushq $0x1d
popq %r15
pushq $0x30
popq %r12
callq 0x154d4
cmpl $0x1b, (%rax)
jne 0x1a1fd
callq 0x154a8
callq 0x1a084
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x140a5
testb %al, %al
je 0x1a20f
movq %r12, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7c5c
movq %r13, %rbx
jmp 0x1a1b3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x15504
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0x103d2(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2ce6(%rip), %rax      # 0x1cf3d
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0x103c1(%rip), %rsi     # 0x2a638
movq 0x10d5a(%rip), %rdx     # 0x2afd8
movq %r15, %rdi
callq 0x4310
movq %rax, %rbx
movq %r15, %rdi
callq 0x4180
jmp 0x1a29e
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1a195
movq %rax, %rbx
pushq $0x1e
popq %r15
pushq $0x30
popq %r12
callq 0x154d4
cmpl $0x1c, (%rax)
jne 0x1a30e
callq 0x154a8
callq 0x1a195
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x140a5
testb %al, %al
je 0x1a320
movq %r12, %rdi
callq 0x41f0
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7c5c
movq %r13, %rbx
jmp 0x1a2c4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x15504
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0x102c1(%rip), %rsi     # 0x2a610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2be1(%rip), %rax      # 0x1cf49
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0x102b0(%rip), %rsi     # 0x2a638
movq 0x10c49(%rip), %rdx     # 0x2afd8
movq %r15, %rdi
callq 0x4310
movq %rax, %rbx
movq %r15, %rdi
callq 0x4180
jmp 0x1a3af
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: parse(std::vector<Token, std::allocator<Token>>*, std::vector<char*, std::allocator<char*>>*)
vector<AbstractStatementNode*>* parse(vector<Token>* tokenRef, vector<char*>* sourceCodeLines) {

  codeLines = sourceCodeLines;

  //set static variables to correct initial values
  tokenIndex = 0;
  tokens = tokenRef;
  symbolTable = new SymbolTable();
	returnFlag = vector<bool*>();
	returnValue = vector<ParseData*>();
	returnType = vector<ParseDataType>();
	insideClassDefinition = false;
  
  //create empty statement vector
  vector<AbstractStatementNode*>* statements = new vector<AbstractStatementNode*>();
  
  //append statement nodes until END is reached
  while(peek()->type != END) {
    statements->push_back(addStatement());
  }
  
  return statements;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x10934(%rip)     # 0x2b270
andl $0x0, 0x10925(%rip)     # 0x2b268
movq %rdi, 0x10916(%rip)     # 0x2b260
pushq $0x10
popq %rdi
callq 0x41f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x14298
movq %rbx, 0x10914(%rip)     # 0x2b278
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x1089e(%rip), %rdi     # 0x2b218
movq %rbx, %rsi
callq 0x1b452
movq %rbx, %rdi
callq 0x1ab52
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x10894(%rip), %rdi     # 0x2b230
leaq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x1b4be
movq %r14, %rdi
callq 0x1ab66
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x10885(%rip), %rdi     # 0x2b248
movq %r14, %rsi
callq 0x1b52a
movq %r14, %rdi
callq 0x1ab7a
pushq $0x18
popq %rdi
callq 0x41f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
callq 0x154d4
cmpl $0x4e, (%rax)
je 0x1aa09
callq 0x15f4c
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1afce
jmp 0x1a9e9
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
movq %r14, %rdi
callq 0x4340