LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AshOlogn[P]ash-language-interpreter/src/memberaccesseval.cpp
// Function: evaluateArrayAccess(ArrayAccessNode*)
ParseData evaluateArrayAccess(ArrayAccessNode* node) {
  
	ParseDataType type = node->evalType;
  ParseData array = node->array->evaluate();
  ParseData start = node->start->evaluate();
  ParseData end;
  
  if(node->isSlice)
    end = node->end->evaluate();
  
  if(node->isSlice) {
    return sliceHelper(node, array, (int32_t) start.value.integer, (int32_t) end.value.integer);
  } else {
    return elementHelper(node, array, (int32_t) start.value.integer); 
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x29b8f
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x29bcf
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %eax, %r8d
movl -0x70(%rbp), %esi
movq -0x68(%rbp), %rdx
callq 0x294a0
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x29bfc
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movl -0x80(%rbp), %esi
movq -0x78(%rbp), %rdx
callq 0x29880
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arrayeval.cpp
// Function: evaluateArrayExpression(ArrayNode*)
ParseData evaluateArrayExpression(ArrayNode* node) {

	//extract instance fields
	bool isInitialized = node->isInitialized;
	ParseDataType subtype = node->subType;
	uint32_t length = (uint32_t) (node->length->evaluate().value.integer);
	AbstractExpressionNode** elements = node->values;

	//construct the array
	Array* arr = (Array*) malloc(sizeof(Array));
	arr->subtype = subtype;
	arr->length = length;
	
	ParseData* values = (ParseData*) malloc(sizeof(ParseData) * length);
	
	//if the array is initialized, fill it accordingly
	if(isInitialized) {
		for(uint32_t i = 0; i < length ; i++) {
			values[i] = elements[i]->evaluate();
		}
	}
	arr->values = values;

	ParseData d;
	d.type = ARRAY_T;
	d.value.allocated = (void*) arr;
	
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x4310
movq %rax, -0x48(%rbp)
movl -0x20(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x24(%rbp), %eax
movl %eax, %edi
shlq $0x4, %rdi
callq 0x4310
movq %rax, -0x50(%rbp)
testb $0x1, -0x19(%rbp)
je 0x2a522
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x2a520
movq -0x40(%rbp), %rax
movl -0x54(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x50(%rbp), %rax
movl -0x54(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x2a4d9
jmp 0x2a522
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0xc, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ExpressionStatementNode::ExpressionStatementNode(AbstractExpressionNode*, SymbolTable*)
ExpressionStatementNode::ExpressionStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable) {
  expression = exp;
  this->symbolTable = symbolTable;
	startLine = exp->startLine;
	endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x2b3e0
movq -0x20(%rbp), %rax
leaq 0x2958c(%rip), %rcx     # 0x53b38
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: PrintStatementNode::PrintStatementNode(AbstractExpressionNode*, SymbolTable*, unsigned int)
PrintStatementNode::PrintStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable, uint32_t startLine) {
  expression = exp;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2b3e0
movq -0x28(%rbp), %rax
leaq 0x29521(%rip), %rcx     # 0x53b50
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: PrintLineStatementNode::PrintLineStatementNode(AbstractExpressionNode*, SymbolTable*, unsigned int)
PrintLineStatementNode::PrintLineStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable, uint32_t startLine) {
  expression = exp;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2b3e0
movq -0x28(%rbp), %rax
leaq 0x294b9(%rip), %rcx     # 0x53b68
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: GroupedStatementNode::GroupedStatementNode(std::vector<AbstractStatementNode*, std::allocator<AbstractStatementNode*>>*, SymbolTable*, unsigned int, unsigned int)
GroupedStatementNode::GroupedStatementNode(std::vector<AbstractStatementNode*>* s, SymbolTable* symbolTable, uint32_t startLine, uint32_t endLine) {
  statements = s;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2b3e0
movq -0x28(%rbp), %rax
leaq 0x2944d(%rip), %rcx     # 0x53b80
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ConditionalStatementNode::ConditionalStatementNode(std::vector<AbstractExpressionNode*, std::allocator<AbstractExpressionNode*>>*, std::vector<AbstractStatementNode*, std::allocator<AbstractStatementNode*>>*, SymbolTable*, unsigned int, unsigned int)
ConditionalStatementNode::ConditionalStatementNode(std::vector<AbstractExpressionNode*>* cond, std::vector<AbstractStatementNode*>* stat, SymbolTable* symbolTable, uint32_t startLine, uint32_t endLine) {
  conditions = cond;
  statements = stat;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2b3e0
movq -0x30(%rbp), %rax
leaq 0x293e0(%rip), %rcx     # 0x53b98
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: WhileStatementNode::WhileStatementNode(AbstractExpressionNode*, AbstractStatementNode*, SymbolTable*, unsigned int)
WhileStatementNode::WhileStatementNode(AbstractExpressionNode* cond, AbstractStatementNode* bod, SymbolTable* symbolTable, uint32_t startLine) {
  condition = cond;
  body = bod;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = bod->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2b3e0
movq -0x30(%rbp), %rax
leaq 0x2936c(%rip), %rcx     # 0x53bb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: WhileStatementNode::execute()
void WhileStatementNode::execute() {
  
  //execute the body while the condition evaluates to true
  ParseData d = condition->evaluate();
  while(d.type == BOOL_T && d.value.integer) {
    
    body->execute();
    
    //get updated expression truth value
    d = condition->evaluate();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x9, -0x18(%rbp)
movb %al, -0x31(%rbp)
jne 0x2a8ba
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2a8c3
jmp 0x2a8f6
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2a8a4
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ForStatementNode::ForStatementNode(AbstractStatementNode*, AbstractStatementNode*, AbstractStatementNode*, AbstractExpressionNode*, SymbolTable*, unsigned int)
ForStatementNode::ForStatementNode(AbstractStatementNode* init, AbstractStatementNode* upd, AbstractStatementNode* bod, AbstractExpressionNode* cond, SymbolTable* symbolTable, uint32_t startLine) {
  initialization = init;
  update = upd;
  body = bod;
  condition = cond;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = bod->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2b3e0
movq -0x38(%rbp), %rax
leaq 0x2928d(%rip), %rcx     # 0x53bc8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x38(%rax), %rdi
callq 0x2bd00
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x9, -0x18(%rbp)
movb %al, -0x31(%rbp)
jne 0x2a9d4
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2a9dd
jmp 0x2aa1d
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2a9be
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2bd70
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2b3e0
movq -0x98(%rbp), %rdi
leaq 0x29179(%rip), %rax     # 0x53bf0
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x90(%rbp)
callq 0x4360
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x4040
jmp 0x2aa9f
movq -0x98(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, 0x38(%rsi)
movq -0x20(%rbp), %rax
movq %rax, 0x40(%rsi)
movq -0x28(%rbp), %rax
movq %rax, 0x10(%rsi)
movl -0x2c(%rbp), %eax
movl %eax, 0x8(%rsi)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsi)
movl 0x38(%rsi), %eax
movl %eax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x18, %rsi
leaq -0x70(%rbp), %rdi
callq 0x40f0
jmp 0x2aaec
movq -0xa0(%rbp), %rdi
movups -0x50(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movl -0x80(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq -0x70(%rbp), %rsi
callq 0x2bda0
jmp 0x2ab0d
leaq -0x70(%rbp), %rdi
callq 0x4170
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2ab42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4170
movq -0x90(%rbp), %rdi
callq 0x4170
movq -0x38(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2b3e0
movq -0x98(%rbp), %rdi
leaq 0x29047(%rip), %rax     # 0x53bf0
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x90(%rbp)
callq 0x4360
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x4040
jmp 0x2abd1
movq -0x98(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x3c(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl 0x38(%rax), %eax
movl %eax, -0x48(%rbp)
cmpl $0xc, -0x14(%rbp)
jne 0x2ac3f
movl $0x10, %edi
callq 0x4310
movq %rax, -0x50(%rbp)
movl -0x18(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2ac3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2aca8
movq -0x98(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x18, %rsi
leaq -0x70(%rbp), %rdi
callq 0x40f0
jmp 0x2ac60
movq -0xa0(%rbp), %rdi
movups -0x48(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movl -0x80(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq -0x70(%rbp), %rsi
callq 0x2bda0
jmp 0x2ac81
leaq -0x70(%rbp), %rdi
callq 0x4170
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4170
movq -0x90(%rbp), %rdi
callq 0x4170
movq -0x30(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2b3e0
movq -0x98(%rbp), %rdi
leaq 0x28ee9(%rip), %rax     # 0x53bf0
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x90(%rbp)
callq 0x4360
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x4040
jmp 0x2ad2f
movq -0x98(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, 0x38(%rsi)
movq $0x0, 0x40(%rsi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rsi)
movl -0x24(%rbp), %eax
movl %eax, 0x8(%rsi)
movl -0x28(%rbp), %eax
movl %eax, 0xc(%rsi)
movl 0x38(%rsi), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x18, %rsi
leaq -0x68(%rbp), %rdi
callq 0x40f0
jmp 0x2ad78
movq -0xa0(%rbp), %rdi
movups -0x48(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movl -0x80(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq -0x68(%rbp), %rsi
callq 0x2bda0
jmp 0x2ad99
leaq -0x68(%rbp), %rdi
callq 0x4170
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2adce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4170
movq -0x90(%rbp), %rdi
callq 0x4170
movq -0x30(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2b3e0
movq -0x98(%rbp), %rdi
leaq 0x28db7(%rip), %rax     # 0x53bf0
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x90(%rbp)
callq 0x4360
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x4040
jmp 0x2ae61
movq -0x98(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x3c(%rax)
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl 0x38(%rax), %eax
movl %eax, -0x48(%rbp)
cmpl $0xc, -0x14(%rbp)
jne 0x2aecb
movl $0x10, %edi
callq 0x4310
movq %rax, -0x50(%rbp)
movl -0x18(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2aecb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2af34
movq -0x98(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x18, %rsi
leaq -0x70(%rbp), %rdi
callq 0x40f0
jmp 0x2aeec
movq -0xa0(%rbp), %rdi
movups -0x48(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movl -0x80(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq -0x70(%rbp), %rsi
callq 0x2bda0
jmp 0x2af0d
leaq -0x70(%rbp), %rdi
callq 0x4170
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4170
movq -0x90(%rbp), %rdi
callq 0x4170
movq -0x30(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2b3e0
movq -0x50(%rbp), %rdi
leaq 0x28c60(%rip), %rax     # 0x53c08
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x48(%rbp)
callq 0x4360
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x4040
jmp 0x2afc7
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4170
movq -0x30(%rbp), %rdi
callq 0x4420
nop
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ArrayAssignmentStatementNode::ArrayAssignmentStatementNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, AbstractExpressionNode*, AbstractExpressionNode*, SymbolTable*, char*, unsigned int)
ArrayAssignmentStatementNode::ArrayAssignmentStatementNode(std::string var, bool isArray, AbstractExpressionNode* ind, AbstractExpressionNode* val, SymbolTable* symbolTable, char* context, uint32_t startLine) {
	variable = var;
	index = ind;
	value = val;
	this->isArray = isArray;
	this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = val->endLine;
	this->context = context;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movb %dl, %al
movl 0x18(%rbp), %edx
movq 0x10(%rbp), %rdx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2b3e0
movq -0x58(%rbp), %rdi
leaq 0x28baa(%rip), %rax     # 0x53c20
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x4360
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x4040
jmp 0x2b095
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x40(%rax)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x50(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x10(%rbp), %rcx
movq %rcx, 0x48(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4170
movq -0x38(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ReturnStatementNode::ReturnStatementNode(AbstractExpressionNode*, bool*, ParseData*, unsigned int)
ReturnStatementNode::ReturnStatementNode(AbstractExpressionNode* exp, bool* retFlag, ParseData* retVal, uint32_t startLine) {
	expression = exp;
	returnFlag = retFlag;
	returnValue = retVal;
	this->startLine = startLine;
	this->endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2b3e0
movq -0x30(%rbp), %rax
leaq 0x28ad4(%rip), %rcx     # 0x53c28
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2b3e0
movq -0x88(%rbp), %rdi
leaq 0x28a63(%rip), %rax     # 0x53c50
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0x80(%rbp)
callq 0x4360
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x4040
jmp 0x2b20c
movq -0x78(%rbp), %rsi
movq -0x88(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0xd, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x40f0
jmp 0x2b24c
movq -0x90(%rbp), %rdi
movups -0x40(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movl -0x70(%rbp), %edx
movq -0x68(%rbp), %rcx
leaq -0x60(%rbp), %rsi
callq 0x2bda0
jmp 0x2b26d
leaq -0x60(%rbp), %rdi
callq 0x4170
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2b2a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4170
movq -0x80(%rbp), %rdi
callq 0x4170
movq -0x28(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2b3e0
movq -0x88(%rbp), %rdi
leaq 0x28957(%rip), %rax     # 0x53c50
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0x80(%rbp)
callq 0x4360
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x4040
jmp 0x2b318
movq -0x78(%rbp), %rsi
movq -0x88(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0xd, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x40f0
jmp 0x2b350
movq -0x90(%rbp), %rdi
movups -0x38(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movl -0x70(%rbp), %edx
movq -0x68(%rbp), %rcx
leaq -0x58(%rbp), %rsi
callq 0x2bda0
jmp 0x2b371
leaq -0x58(%rbp), %rdi
callq 0x4170
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b3a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4170
movq -0x80(%rbp), %rdi
callq 0x4170
movq -0x20(%rbp), %rdi
callq 0x4420
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0x2b52a
movq -0x18(%rbp), %rax
leaq 0x18fd6(%rip), %rcx     # 0x44454
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %al
cmpl $0x8, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0x2b4a7
movb $0x1, %al
cmpl $0x2, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0x2b4a7
cmpl $0x6, -0x8(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b52e
movl -0x8(%rbp), %edi
callq 0xb240
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b52e
movb $0x1, %al
cmpl $0x8, -0x8(%rbp)
movb %al, -0x1a(%rbp)
je 0x2b4e0
movb $0x1, %al
cmpl $0x2, -0x8(%rbp)
movb %al, -0x1a(%rbp)
je 0x2b4e0
cmpl $0x6, -0x8(%rbp)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b52e
movl -0x8(%rbp), %edi
callq 0xb240
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b52e
cmpl $0x8, -0x8(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b52e
cmpl $0x9, -0x8(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b52e
movl -0x8(%rbp), %edi
callq 0xb1c0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b52e
movb $0x1, -0x1(%rbp)
jmp 0x2b52e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0xb1c0
testb $0x1, %al
jne 0x2b55c
jmp 0x2b584
movl -0x8(%rbp), %edi
callq 0xb1c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xd(%rbp)
jne 0x2b57a
cmpl $0x9, -0x8(%rbp)
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b5c2
cmpl $0x9, -0xc(%rbp)
jne 0x2b5b2
movl -0x8(%rbp), %edi
callq 0xb240
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xe(%rbp)
jne 0x2b5a8
cmpl $0x9, -0x8(%rbp)
sete %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b5c2
cmpl $0xb, -0xc(%rbp)
jne 0x2b5be
movb $0x1, -0x1(%rbp)
jmp 0x2b5c2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0x2b6ce
movq -0x18(%rbp), %rax
leaq 0x18e82(%rip), %rcx     # 0x4447c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0xc(%rbp), %edi
callq 0xb1c0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b6d2
movl -0xc(%rbp), %edi
callq 0xb1c0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b6d2
movl -0xc(%rbp), %edi
callq 0xb1c0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b6d2
movl -0xc(%rbp), %edi
callq 0xb1c0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b6d2
movl -0xc(%rbp), %edi
callq 0xb1c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x2b674
movb $0x1, %al
cmpl $0xb, -0xc(%rbp)
movb %al, -0x19(%rbp)
je 0x2b674
cmpl $0xc, -0xc(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b6d2
movl -0xc(%rbp), %edi
callq 0xb1c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x2b6a7
movb $0x1, %al
cmpl $0xb, -0xc(%rbp)
movb %al, -0x1a(%rbp)
je 0x2b6a7
cmpl $0xc, -0xc(%rbp)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b6d2
movl -0xc(%rbp), %edi
callq 0xb240
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b6d2
cmpl $0x9, -0xc(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b6d2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0xb510
testb $0x1, %al
jne 0x2b8ef
jmp 0x2b91a
movl -0xc(%rbp), %edi
callq 0xb240
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x2b905
jmp 0x2b910
movl -0x10(%rbp), %edi
callq 0xb240
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b94b
movl -0x8(%rbp), %edi
callq 0xb560
testb $0x1, %al
jne 0x2b928
jmp 0x2b947
xorl %eax, %eax
cmpl $0x9, -0xc(%rbp)
movb %al, -0x12(%rbp)
jne 0x2b93d
cmpl $0x9, -0x10(%rbp)
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b94b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x2b5d0
testb $0x1, %al
jne 0x2b9e6
movl $0x11, -0x4(%rbp)
jmp 0x2ba4f
movl -0x8(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0x2ba48
movq -0x18(%rbp), %rax
leaq 0x18ac2(%rip), %rcx     # 0x444c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ba4f
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ba4f
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ba4f
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ba4f
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ba4f
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ba4f
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ba4f
movl $0x9, -0x4(%rbp)
jmp 0x2ba4f
movl $0x11, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2b6e0
testb $0x1, %al
jne 0x2ba8f
movl $0x11, -0x4(%rbp)
jmp 0x2bb8e
movl -0x8(%rbp), %eax
addl $-0xb, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x2bb87
movq -0x18(%rbp), %rax
leaq 0x18a3d(%rip), %rcx     # 0x444ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xa, -0x4(%rbp)
jmp 0x2bb8e
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xb340
movl %eax, -0x4(%rbp)
jmp 0x2bb8e
cmpl $0xb, -0xc(%rbp)
je 0x2bae3
cmpl $0xb, -0x10(%rbp)
jne 0x2baed
movl $0xb, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2bb17
cmpl $0xc, -0xc(%rbp)
je 0x2baf9
cmpl $0xc, -0x10(%rbp)
jne 0x2bb03
movl $0xc, %eax
movl %eax, -0x20(%rbp)
jmp 0x2bb11
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xb340
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2bb8e
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xb340
movl %eax, -0x4(%rbp)
jmp 0x2bb8e
cmpl $0xb, -0xc(%rbp)
je 0x2bb3b
cmpl $0xb, -0x10(%rbp)
jne 0x2bb45
movl $0xb, %eax
movl %eax, -0x24(%rbp)
jmp 0x2bb6f
cmpl $0xc, -0xc(%rbp)
jne 0x2bb5b
cmpl $0xc, -0x10(%rbp)
jne 0x2bb5b
movl $0xc, %eax
movl %eax, -0x28(%rbp)
jmp 0x2bb69
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xb340
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2bb8e
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xb340
movl %eax, -0x4(%rbp)
jmp 0x2bb8e
movl $0x11, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2b8d0
testb $0x1, %al
jne 0x2bbcc
movl $0x11, -0x4(%rbp)
jmp 0x2bc08
movl -0x8(%rbp), %edi
callq 0xb510
testb $0x1, %al
jne 0x2bbda
jmp 0x2bbea
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xb340
movl %eax, -0x4(%rbp)
jmp 0x2bc08
movl -0x8(%rbp), %edi
callq 0xb560
testb $0x1, %al
jne 0x2bbf8
jmp 0x2bc01
movl $0x9, -0x4(%rbp)
jmp 0x2bc08
movl $0x11, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2c440
movq -0x60(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2c460
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x60(%rbp), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2c4e0
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2c4b0
testb $0x1, %al
jne 0x2be57
jmp 0x2becc
leaq -0x28(%rbp), %rdi
callq 0x2c530
movq -0x68(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2c590
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2c5c0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2c560
testb $0x1, %al
jne 0x2be98
jmp 0x2beb6
movq -0x68(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x2c410
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2becc
jmp 0x2beb8
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x2c5f0
jmp 0x2be34
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2c440
movq -0x58(%rbp), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2c460
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2c4e0
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2c4b0
testb $0x1, %al
jne 0x2bfb0
jmp 0x2c00a
leaq -0x20(%rbp), %rdi
callq 0x2c530
movq -0x60(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2c590
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2c5c0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2c560
testb $0x1, %al
jne 0x2bff1
jmp 0x2bff7
movb $0x1, -0x1(%rbp)
jmp 0x2c00e
jmp 0x2bff9
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x2c5f0
jmp 0x2bf8d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)