LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ForStatementNode::execute()
void ForStatementNode::execute() {

  symbolTable->enterNewScope();

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

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

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

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

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

  symbolTable->declare(variable, d);
}

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %r15
leaq 0x15f2a(%rip), %rax     # 0x2bc20
movq %rax, (%rdi)
leaq 0x18(%rdi), %r13
leaq 0x28(%rdi), %rbx
movq %rbx, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %r13, %rdi
callq 0x4140
movq %r14, 0x38(%r15)
movq %r12, 0x10(%r15)
movl -0x2c(%rbp), %eax
movl %eax, 0x8(%r15)
movl 0xc(%r14), %eax
movl %eax, 0xc(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
cmpq %rbx, %rdi
je 0x15d50
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: FunctionStatementNode::FunctionStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Function*, SymbolTable*)
FunctionStatementNode::FunctionStatementNode(std::string fName, Function* f, SymbolTable* symbolTable) {
	functionName = fName;
	function = f;
	this->symbolTable = symbolTable;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq 0x15e08(%rip), %rax     # 0x2bc68
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
leaq 0x30(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movq %rbx, %rdi
callq 0x4140
movq %r14, 0x18(%r13)
movq %r15, 0x10(%r13)
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x897a
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
movl $0xd, %edx
movq %r14, %rcx
callq 0x164ea
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x15ece
callq 0x41e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x15ef5
callq 0x41e0
jmp 0x15ef5
jmp 0x15ef2
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x15f03
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: FunctionStatementNode::FunctionStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, SymbolTable*)
FunctionStatementNode::FunctionStatementNode(std::string fName, SymbolTable* symbolTable) {
	functionName = fName;
	function = NULL;
	this->symbolTable = symbolTable;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    case MOD_OP: return getLargerNumberParseDataType(l, r);

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

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

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

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

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

  } else {

    return INVALID_T;

  }   
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %r14d
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq -0x8(%rax), %rdi
callq 0x1686e
movl %r14d, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1656d
movq -0x8(%rbx), %r13
addq $-0x8, %rbx
movq %r13, %rdi
movq %r15, %rsi
callq 0x16cc6
testq %rax, %rax
je 0x16536
movq %r13, %rdi
movq %r15, %rsi
callq 0x1686e
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_O3/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 0x165d6
leaq -0x8(%r15), %r13
movq -0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x16cc6
testq %rax, %rax
je 0x165b3
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_O3/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %r15
movq (%r14), %rax
cmpq (%rax), %r15
je 0x1662c
movq -0x8(%r15), %rdi
addq $-0x8, %r15
movq %rbx, %rsi
callq 0x16cc6
testq %rax, %rax
je 0x16603
movq %rax, %rcx
movl 0x28(%rax), %eax
movq 0x30(%rcx), %rdx
jmp 0x16631
movl $0x11, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/symboltable.cpp
// Function: SymbolTable::toString[abi:cxx11]()
std::string SymbolTable::toString() {

	std::string str = "";

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

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

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

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x79d0(%rip), %rdx      # 0x1e035
movq %rdx, %rsi
callq 0x5cb8
movq %r14, -0x38(%rbp)
movq (%r14), %rax
movq (%rax), %r15
cmpq 0x8(%rax), %r15
je 0x166f6
leaq 0x89c7(%rip), %r12      # 0x1f04b
leaq 0xc8d1(%rip), %r13      # 0x22f5c
movq (%r15), %r14
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x166d6
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x40a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x43a0
movl 0x28(%r14), %edi
callq 0x817c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x43a0
jmp 0x16692
movq %rbx, %rdi
leaq 0xc860(%rip), %rsi      # 0x22f40
callq 0x43a0
addq $0x8, %r15
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq 0x8(%rax), %r15
jne 0x1668b
leaq 0xc861(%rip), %rsi      # 0x22f5e
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1671b
jmp 0x1671b
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x1672c
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16468
movq 0x18(%rbx), %r14
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x16e3f
movq (%r15), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r15
jmp 0x16e2b
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x164d8
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/executor.cpp
// Function: executeConditionalStatement(ConditionalStatementNode*)
void executeConditionalStatement(ConditionalStatementNode* node) {
  
  std::vector<AbstractExpressionNode*>* conditions = node->conditions;
  std::vector<AbstractStatementNode*>* statements = node->statements;
  std::vector<AbstractExpressionNode*>::iterator it1;
  std::vector<AbstractStatementNode*>::iterator it2;
  
  it1 = conditions->begin();
  it2 = statements->begin();
  
  for(; it1 != conditions->end(); it1++, it2++) {
    
    ParseData d = (*it1)->evaluate();
    if(d.type == BOOL_T && d.value.integer != 0) {
      
      (*it2)->execute();
      return;
    }
  }
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rbx
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x897a
movq 0x18(%r14), %r14
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x897a
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
movl $0xd, %edx
movq %r14, %rcx
callq 0x164ea
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x17577
callq 0x41e0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x17585
callq 0x41e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x175aa
callq 0x41e0
jmp 0x175aa
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x175b8
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15d
movl %esi, %ebx
movq %rdi, %r14
movl %edx, %eax
subl %esi, %eax
xorl %r13d, %r13d
testl %eax, %eax
cmovgl %eax, %r13d
leal 0x1(%r13), %edi
callq 0x4030
movq %rax, %r12
cmpl %ebx, %r15d
jle 0x1767d
movslq %ebx, %rax
addq %rax, %r14
notl %ebx
addl %r15d, %ebx
incq %rbx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x41b0
movl %r13d, %eax
movb $0x0, (%r12,%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/utils.cpp
// Function: copySubarray(Array*, int, int)
Array* copySubarray(Array* arr, int32_t startIndex, int32_t pastEndIndex) {

	//extract fields from Array
	ParseData* values = arr->values;

	ParseData* subarrayValues = (ParseData*) malloc(sizeof(ParseData) * std::max(pastEndIndex-startIndex, 1));
	for(int32_t i = startIndex; i < pastEndIndex; i++) {
		subarrayValues[i-startIndex] = values[i];
	}

	//create subarray Array and return it
	Array* subarray = (Array*) malloc(sizeof(Array));
	subarray->length = (uint32_t) std::max(pastEndIndex-startIndex, 0);
	subarray->subtype = arr->subtype;
	subarray->values = subarrayValues;

	return subarray;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x177b6
movq %rdi, %rbx
movl $0x4, %r14d
movl $0x0, -0x2c(%rbp)
xorl %r13d, %r13d
movq (%r12), %rax
movl 0x10(%rax), %r15d
cmpl $0xb, %r15d
je 0x1776f
cmpl $0xa, %r15d
jne 0x17776
movb $0x1, %r13b
jmp 0x17790
movb $0x1, %al
movl %eax, -0x2c(%rbp)
jmp 0x17790
movl %r15d, %edi
callq 0x7fdb
testb %al, %al
je 0x17790
movl %r14d, %edi
movl %r15d, %esi
callq 0x8002
movl %eax, %r14d
addq $0x8, %r12
cmpq 0x8(%rbx), %r12
jne 0x17756
testb $0x1, %r13b
movl $0xa, %eax
cmovnel %eax, %r14d
testb $0x1, -0x2c(%rbp)
movl $0xb, %eax
cmovel %r14d, %eax
jmp 0x177bb
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %r14d
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %r13, %rdi
cmpl %esi, %r14d
ja 0x1790f
movl %esi, %ebx
leaq 0x6769(%rip), %r15      # 0x1e034
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x43a0
movq 0x149a7(%rip), %rcx     # 0x2c288
movl %r14d, %esi
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x17937
movq (%rax,%rsi,8), %rsi
movq %r12, %rdi
callq 0x43a0
incl %r14d
cmpl %ebx, %r14d
jbe 0x178cf
movq -0x48(%rbp), %rdi
callq 0x175e8
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x17925
callq 0x41e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x71ba(%rip), %rdi      # 0x1eaf8
xorl %eax, %eax
callq 0x42f0
jmp 0x17949
jmp 0x17949
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1795a
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1bc64
movq %rax, %rbx
callq 0x1781b
cmpl $0xb, (%rax)
jne 0x1c115
callq 0x177cc
callq 0x1bc64
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl $0xb, %edi
callq 0x160ee
testb %al, %al
je 0x1c127
movl $0x30, %edi
callq 0x4210
movq %rax, %r15
movq %rax, %rdi
movl $0xb, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8de0
movq %r15, %rbx
jmp 0x1c0c5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x17891
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xf4b8(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2d2a(%rip), %rax      # 0x1ee9b
movq %rax, 0x18(%r15)
movq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0xf4a4(%rip), %rsi      # 0x2b638
movq 0xfe3d(%rip), %rdx      # 0x2bfd8
movq %r15, %rdi
callq 0x4350
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
jmp 0x1c1bb
movq %rax, %rbx
movq %r15, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c0af
movq %rax, %rbx
callq 0x1781b
movl (%rax), %edi
callq 0x63b4
testb %al, %al
je 0x1c238
callq 0x177cc
movl (%rax), %edi
callq 0x815d
movl %eax, %r15d
callq 0x1c0af
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x160ee
testb %al, %al
je 0x1c24a
movl $0x30, %edi
callq 0x4210
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8de0
movq %r12, %rbx
jmp 0x1c1dc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r12
movl 0x8(%rbx), %r13d
movl 0xc(%r14), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x17891
movq %rax, -0x30(%rbp)
movl %r15d, %edi
callq 0x81c7
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xf387(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r12)
movw $0x1, 0x8(%r12)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r12)
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movl %r13d, 0x28(%r12)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r12)
movl %ecx, 0x30(%r12)
movl %edx, 0x34(%r12)
leaq 0xf369(%rip), %rsi      # 0x2b638
movq 0xfd02(%rip), %rdx      # 0x2bfd8
movq %r12, %rdi
callq 0x4350
movq %rax, %rbx
movq %r12, %rdi
callq 0x4190
jmp 0x1c2f6
movq %rax, %rbx
movq %r12, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c2fe
movq %rax, %rbx
callq 0x1781b
movl (%rax), %edi
callq 0x63dc
testb %al, %al
je 0x1c4ae
callq 0x177cc
movl (%rax), %edi
callq 0x815d
movl %eax, %r15d
callq 0x1c2fe
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x161d9
testb %al, %al
je 0x1c4c0
movl $0x30, %edi
callq 0x4210
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e3e
movq %r12, %rbx
jmp 0x1c452
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r12
movl 0x8(%rbx), %r13d
movl 0xc(%r14), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x17891
movq %rax, -0x30(%rbp)
movl %r15d, %edi
callq 0x81c7
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xf111(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r12)
movw $0x1, 0x8(%r12)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r12)
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movl %r13d, 0x28(%r12)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r12)
movl %ecx, 0x30(%r12)
movl %edx, 0x34(%r12)
leaq 0xf0f3(%rip), %rsi      # 0x2b638
movq 0xfa8c(%rip), %rdx      # 0x2bfd8
movq %r12, %rdi
callq 0x4350
movq %rax, %rbx
movq %r12, %rdi
callq 0x4190
jmp 0x1c56c
movq %rax, %rbx
movq %r12, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380