LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayAccessNode::toString[abi:cxx11]()
std::string ArrayAccessNode::toString() {
  
  std::string str = "([";
  if(isSlice) {
    
    str.append(start->toString());
    str.append(":");
    str.append(end->toString());
    str.append("] ");
    
  } else {
    str.append("]");
  }
 
  str.append(array->toString());
  str.append(")");
 
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4430
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x32904(%rip), %rsi     # 0x4036c
callq 0x4350
jmp 0xda6f
leaq -0x12(%rbp), %rdi
callq 0x4290
movq -0xa0(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0xdb7e
movq -0xa0(%rbp), %rax
movq 0x20(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0xdaa3
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4470
jmp 0xdab5
leaq -0x48(%rbp), %rdi
callq 0x4170
movq -0x98(%rbp), %rdi
leaq 0x320d2(%rip), %rsi     # 0x3fb9e
callq 0x4460
jmp 0xdad3
movq -0xa0(%rbp), %rax
movq 0x28(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0xdaed
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4470
jmp 0xdaff
leaq -0x68(%rbp), %rdi
callq 0x4170
movq -0x98(%rbp), %rdi
leaq 0x32859(%rip), %rsi     # 0x4036f
callq 0x4460
jmp 0xdb1d
jmp 0xdb95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4290
jmp 0xdc36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xdc2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4170
jmp 0xdc2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4170
jmp 0xdc2a
movq -0x98(%rbp), %rdi
leaq 0x3200a(%rip), %rsi     # 0x3fb96
callq 0x4460
jmp 0xdb93
jmp 0xdb95
movq -0xa0(%rbp), %rax
movq 0x18(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0xdbb2
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4470
jmp 0xdbc7
leaq -0x88(%rbp), %rdi
callq 0x4170
movq -0x98(%rbp), %rdi
leaq 0x32163(%rip), %rsi     # 0x3fd44
callq 0x4460
jmp 0xdbe8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xdc1a
jmp 0xdc0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4170
jmp 0xdc2a
movq -0x98(%rbp), %rdi
callq 0x4170
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4170
movq -0x20(%rbp), %rdi
callq 0x4420
nop
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayNode::ArrayNode(ParseDataType, bool, AbstractExpressionNode*, AbstractExpressionNode**, unsigned int, unsigned int)
ArrayNode::ArrayNode(ParseDataType sType, bool isInit, AbstractExpressionNode* len, AbstractExpressionNode** vals, uint32_t startLine, uint32_t endLine) {
	evalType = ARRAY_T;
	subType = sType;
	isInitialized = isInit;
	length = len;
	values = vals;
	this->startLine = startLine;
	this->endLine = endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movl 0x10(%rbp), %edx
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xe5a0
movq -0x30(%rbp), %rax
leaq 0x45c43(%rip), %rcx     # 0x538c0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0xc, 0x10(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
movb -0xd(%rbp), %cl
andb $0x1, %cl
movb %cl, 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)
movl 0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayNode::toString[abi:cxx11]()
std::string ArrayNode::toString() {
	std::string str = "";
	str.append("[length = ");
	str.append(length->toString());
	str.append(", type = ");
	str.append(toStringParseDataType(subType));
	str.append("]");
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4430
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x31302(%rip), %rsi     # 0x3f035
callq 0x4350
jmp 0xdd3a
leaq -0x12(%rbp), %rdi
callq 0x4290
movq -0x58(%rbp), %rdi
leaq 0x32624(%rip), %rsi     # 0x40372
callq 0x4460
jmp 0xdd55
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0xdd6c
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4470
jmp 0xdd7b
leaq -0x48(%rbp), %rdi
callq 0x4170
movq -0x58(%rbp), %rdi
leaq 0x325ee(%rip), %rsi     # 0x4037d
callq 0x4460
jmp 0xdd96
movq -0x60(%rbp), %rax
movl 0x14(%rax), %edi
callq 0xb8a0
movq %rax, -0x70(%rbp)
jmp 0xdda8
movq -0x70(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x4460
jmp 0xddb7
movq -0x58(%rbp), %rdi
leaq 0x31dd4(%rip), %rsi     # 0x3fb96
callq 0x4460
jmp 0xddc9
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xde1a
jmp 0xde11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4290
jmp 0xde2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xde24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4170
jmp 0xde24
movq -0x58(%rbp), %rdi
callq 0x4170
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4170
movq -0x20(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: VariableNode::VariableNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, SymbolTable*, unsigned int)
VariableNode::VariableNode(std::string var, SymbolTable* table, uint32_t line) {
  symbolTable = table;
  variable = var;
  startLine = endLine = line;
  evalType = (symbolTable->get(var)).type;
	subType = (evalType == ARRAY_T) ? ((Array*) (symbolTable->get(var)).value.allocated)->subtype : 
						(evalType == STRING_T) ? CHAR_T :
						INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xe5a0
movq -0xb0(%rbp), %rdi
leaq 0x45a71(%rip), %rax     # 0x538f0
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4360
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
callq 0x4040
jmp 0xdeb6
movq -0xa0(%rbp), %rsi
movq -0xb0(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl %ecx, 0x8(%rax)
movq 0x18(%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x40f0
jmp 0xdee3
movq -0xb8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2c020
movq %rdx, -0xc8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xdf02
movq -0xb0(%rbp), %rax
movq -0xc8(%rbp), %rcx
movl -0xbc(%rbp), %edx
movl %edx, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movl -0x40(%rbp), %ecx
movl %ecx, 0x10(%rax)
leaq -0x60(%rbp), %rdi
callq 0x4170
movq -0xb0(%rbp), %rax
movl 0x10(%rax), %eax
movb $0x0, -0x91(%rbp)
cmpl $0xc, %eax
jne 0xdfb4
movq -0xa0(%rbp), %rsi
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xd0(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x40f0
jmp 0xdf69
movq -0xd0(%rbp), %rdi
movb $0x1, -0x91(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x2c020
movq %rdx, -0xe0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0xdf92
movq -0xe0(%rbp), %rax
movl -0xd4(%rbp), %ecx
movl %ecx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xe4(%rbp)
jmp 0xdfd4
movq -0xb0(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x11, %eax
movl $0x8, %ecx
cmpl $0xb, %edx
cmovel %ecx, %eax
movl %eax, -0xe4(%rbp)
movq -0xb0(%rbp), %rax
movl -0xe4(%rbp), %ecx
movl %ecx, 0x14(%rax)
testb $0x1, -0x91(%rbp)
jne 0xdfef
jmp 0xdffb
leaq -0x90(%rbp), %rdi
callq 0x4170
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xe04e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4170
jmp 0xe04e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
testb $0x1, -0x91(%rbp)
jne 0xe040
jmp 0xe04c
leaq -0x90(%rbp), %rdi
callq 0x4170
jmp 0xe04e
movq -0xa8(%rbp), %rdi
callq 0x4170
movq -0x28(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: FunctionExpressionNode::FunctionExpressionNode(unsigned int, AbstractExpressionNode**, Function*, SymbolTable*, unsigned int, unsigned int)
FunctionExpressionNode::FunctionExpressionNode(uint32_t nArgs, AbstractExpressionNode** args, Function* f, SymbolTable* table, uint32_t startLine, uint32_t endLine) {
	numArgs = nArgs;
	arguments = args;
	function = f;
	symbolTable = table;
	evalType = f->returnType;
	subType = (evalType == STRING_T) ? CHAR_T :
						INVALID_T;

	isReturned = f->returnFlag;
	returnValue = f->returnValue;

  this->startLine = startLine;
  this->endLine = endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xe5a0
movq -0x38(%rbp), %rax
leaq 0x45796(%rip), %rcx     # 0x53900
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 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 -0x20(%rbp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %esi
movl $0x11, %ecx
movl $0x8, %edx
cmpl $0xb, %esi
cmovel %edx, %ecx
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0x40(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: LiteralNode::LiteralNode(ParseData, unsigned int)
LiteralNode::LiteralNode(ParseData d, uint32_t line) {
  data = d;
  startLine = endLine = line;
  evalType = d.type;
	subType = (d.type == STRING_T) ? CHAR_T :
						(d.type == ARRAY_T) ? ((Array*) d.value.allocated)->subtype :
						INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xe5a0
movq -0x28(%rbp), %rax
leaq 0x45692(%rip), %rcx     # 0x53920
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0xb, -0x10(%rbp)
jne 0xe2c4
movl $0x8, %eax
movl %eax, -0x2c(%rbp)
jmp 0xe2e5
cmpl $0xc, -0x10(%rbp)
jne 0xe2d5
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0xe2df
movl $0x11, %eax
movl %eax, -0x30(%rbp)
jmp 0xe2df
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: GroupedExpressionNode::GroupedExpressionNode(AbstractExpressionNode*, unsigned int, unsigned int)
GroupedExpressionNode::GroupedExpressionNode(AbstractExpressionNode* exp, uint32_t startLin, uint32_t endLin) {
  closedExpression = exp;
  startLine = startLin;
  endLine = endLin;
  evalType = exp->evalType;
	subType = (evalType == STRING_T) ? CHAR_T :
						(evalType == ARRAY_T) ? exp->subType :
						INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xe5a0
movq -0x20(%rbp), %rax
leaq 0x45552(%rip), %rcx     # 0x53940
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
cmpl $0xb, 0x10(%rax)
jne 0xe423
movl $0x8, %eax
movl %eax, -0x24(%rbp)
jmp 0xe449
movq -0x20(%rbp), %rax
cmpl $0xc, 0x10(%rax)
jne 0xe439
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0xe443
movl $0x11, %eax
movl %eax, -0x28(%rbp)
jmp 0xe443
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: GroupedExpressionNode::toString[abi:cxx11]()
std::string GroupedExpressionNode::toString() {
  std::string str = "(";
  str.append(closedExpression->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4430
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x316c1(%rip), %rsi     # 0x3fb94
callq 0x4350
jmp 0xe4da
leaq -0x12(%rbp), %rdi
callq 0x4290
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0xe4fa
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4470
jmp 0xe509
leaq -0x48(%rbp), %rdi
callq 0x4170
movq -0x58(%rbp), %rdi
leaq 0x31827(%rip), %rsi     # 0x3fd44
callq 0x4460
jmp 0xe524
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xe575
jmp 0xe56c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4290
jmp 0xe588
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xe57f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4170
jmp 0xe57f
movq -0x58(%rbp), %rdi
callq 0x4170
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4170
movq -0x20(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, unsigned char>(char*, unsigned char, ParseDataType)
ParseData additionHelper<char*, unsigned char>(char* n1, unsigned char n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  unsigned char arg2 = (unsigned char) n2;
  uint32_t len = strlen(arg1);
  
  char* res = new char[len+2];
  res[0] = '\0';
  strncat(res, arg1, len);
  res[len] = arg2; res[len+1] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;

  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl %edx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4100
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl $0x2, %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %eax
movl %eax, %edx
callq 0x4190
movb -0x29(%rbp), %dl
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %ecx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %ecx
incl %ecx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nop
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<bool, char*>(bool, char*, ParseDataType)
ParseData additionHelper<bool, char*>(bool n1, char* n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  const char* arg1Str = (arg1) ? "true" : "false";
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x1, %eax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testq %rax, %rax
leaq 0x30e26(%rip), %rcx     # 0x3f8a6
leaq 0x30e24(%rip), %rax     # 0x3f8ab
cmovneq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4100
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
callq 0x4100
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %edx
movl -0x48(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x44(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x48(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x50(%rbp), %rax
movl -0x44(%rbp), %ecx
movl -0x48(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nop
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, bool>(char*, bool, ParseDataType)
ParseData additionHelper<char*, bool>(char* n1, bool n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  bool arg2 = (bool) n2;
  const char* arg2Str = (arg2) ? "true" : "false";
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl %edx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %dl
leaq 0x30d55(%rip), %rcx     # 0x3f8a6
leaq 0x30d53(%rip), %rax     # 0x3f8ab
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4100
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4100
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, (%rax)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x3c(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x40(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x48(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl -0x40(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, int>(char*, int, ParseDataType)
ParseData additionHelper<char*, int32_t>(char* n1, int32_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  int32_t arg2 = (int32_t) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7570
movq -0x78(%rbp), %rdi
callq 0x40e0
movq -0x78(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x4170
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4100
movl %eax, -0x5c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4100
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edx
movl -0x60(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movb $0x0, (%rax)
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x5c(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x60(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x68(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl -0x60(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, long>(char*, long, ParseDataType)
ParseData additionHelper<char*, int64_t>(char* n1, int64_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  int64_t arg2 = (int64_t) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xc600
movq -0x80(%rbp), %rdi
callq 0x40e0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x4170
movq -0x78(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4100
movl %eax, -0x64(%rbp)
movq -0x40(%rbp), %rdi
callq 0x4100
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %edx
movl -0x68(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
movq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x64(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x68(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x70(%rbp), %rax
movl -0x64(%rbp), %ecx
movl -0x68(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nop
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, double>(char*, double, ParseDataType)
ParseData additionHelper<char*, double>(char* n1, double n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  double arg2 = (double) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xc810
movq -0x80(%rbp), %rdi
callq 0x40e0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x4170
movq -0x78(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4100
movl %eax, -0x64(%rbp)
movq -0x40(%rbp), %rdi
callq 0x4100
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %edx
movl -0x68(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
movq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x64(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x68(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x70(%rbp), %rax
movl -0x64(%rbp), %ecx
movl -0x68(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, char*>(char*, char*, ParseDataType)
ParseData additionHelper<char*, char*>(char* n1, char* n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4100
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4100
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, (%rax)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x3c(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x40(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x48(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl -0x40(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<unsigned char, char*>(unsigned char, char*, ParseDataType)
ParseData additionHelper<unsigned char, char*>(unsigned char n1, char* n2, ParseDataType type) {

  unsigned char arg1 = (unsigned char) n1;
  char* arg2 = (char*) n2;
  uint32_t len = strlen(arg2);
  
  char* res = new char[len+2];
  res[0] = arg1; res[1] = '\0';
  strncat(res, arg2, len);
  res[len+1] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x11(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x25(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4100
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $0x2, %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x40(%rbp)
movb -0x25(%rbp), %cl
movq -0x40(%rbp), %rax
movb %cl, (%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
incl %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<int, char*>(int, char*, ParseDataType)
ParseData additionHelper<int32_t, char*>(int32_t n1, char* n2, ParseDataType type) {

  int32_t arg1 = (int32_t) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7570
movq -0x78(%rbp), %rdi
callq 0x40e0
movq -0x78(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x4170
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4100
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x4100
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edx
movl -0x60(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movb $0x0, (%rax)
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x5c(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x60(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x68(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl -0x60(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<long, char*>(long, char*, ParseDataType)
ParseData additionHelper<int64_t, char*>(int64_t n1, char* n2, ParseDataType type) {

  int64_t arg1 = (int64_t) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xc600
movq -0x80(%rbp), %rdi
callq 0x40e0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x4170
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4100
movl %eax, -0x64(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4100
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %edx
movl -0x68(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x64(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl -0x68(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x70(%rbp), %rax
movl -0x64(%rbp), %ecx
movl -0x68(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nop
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<double, char*>(double, char*, ParseDataType)
ParseData additionHelper<double, char*>(double n1, char* n2, ParseDataType type) {

  double arg1 = (double) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xc810
movq -0x80(%rbp), %rdi
callq 0x40e0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x4170
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4100
movl %eax, -0x64(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4100
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %edx
movl -0x68(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x64(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl -0x68(%rbp), %eax
movl %eax, %edx
callq 0x4190
movq -0x70(%rbp), %rax
movl -0x64(%rbp), %ecx
movl -0x68(%rbp), %edx
addl %edx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData exponentHelper<unsigned char, unsigned char>(unsigned char, unsigned char)
ParseData exponentHelper(T1 n1, T2 n2) {
 
  //first store the values in appropriate variables
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = DOUBLE_T;
  d.value.floatingPoint = pow((double) arg1, (double) arg2);
 
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x13(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x14(%rbp)
movl $0xa, -0x10(%rbp)
movzbl -0x13(%rbp), %eax
cvtsi2sd %eax, %xmm0
movzbl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm1
callq 0x4410
movsd %xmm0, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nop
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData divisionHelper<unsigned char, unsigned char>(unsigned char, unsigned char, ParseDataType)
ParseData divisionHelper(T1 n1, T2 n2, ParseDataType type) {
 
  //first store the values in appropriate variables
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = type;
  
  switch(type) {
    case CHAR_T: d.value.integer = (unsigned char) (arg1/arg2); break;
    case INT32_T: d.value.integer = (int32_t) (arg1/arg2); break;
    case INT64_T: d.value.integer = (int64_t) (arg1/arg2); break;
    case UINT32_T: d.value.integer = (uint32_t) (arg1/arg2); break;
    case UINT64_T: d.value.integer = (uint64_t) (arg1/arg2); break;
    case DOUBLE_T: d.value.floatingPoint = (double) (arg1/arg2); break;
  }
 
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movl %edx, -0x18(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x1a(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x8, %eax
ja 0x133f2
movq -0x28(%rbp), %rax
leaq 0x2d82b(%rip), %rcx     # 0x40ba0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x133f2
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
cltq
movq %rax, -0x8(%rbp)
jmp 0x133f2
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
cltq
movq %rax, -0x8(%rbp)
jmp 0x133f2
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x133f2
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
cltq
movq %rax, -0x8(%rbp)
jmp 0x133f2
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData modHelper<unsigned char, unsigned char>(unsigned char, unsigned char, ParseDataType)
ParseData modHelper(T1 n1, T2 n2, ParseDataType type) {
 
  //first store the values in appropriate variables
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = type;
  
  switch(type) {
    case CHAR_T: d.value.integer = (unsigned char) (arg1 % arg2); break;
    case INT32_T: d.value.integer = (int32_t) (arg1 % arg2); break;
    case INT64_T: d.value.integer = (int64_t) (arg1 % arg2); break;
    case UINT32_T: d.value.integer = (uint32_t) (arg1 % arg2); break;
    case UINT64_T: d.value.integer = (uint64_t) (arg1 % arg2); break;
  }
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movl %edx, -0x18(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x1a(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x6, %eax
ja 0x1790d
movq -0x28(%rbp), %rax
leaq 0x29d2b(%rip), %rcx     # 0x415cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
movb %dl, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x1790d
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x8(%rbp)
jmp 0x1790d
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x8(%rbp)
jmp 0x1790d
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
movl %edx, %eax
movq %rax, -0x8(%rbp)
jmp 0x1790d
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/assignmenteval.cpp
// Function: evaluateAssignmentExpression(AssignmentExpressionNode*)
ParseData evaluateAssignmentExpression(AssignmentExpressionNode* node) {

  //get stuff out of the node first
  SymbolTable* symbolTable = node->symbolTable;
  std::string variable = node->variable;
  AbstractExpressionNode* value = node->value;
  
  ParseDataType type = node->evalType;
  ParseData d = value->evaluate();
  
  //update variable value (innermost scope)
  symbolTable->update(variable, castHelper(d, type));
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x40(%rbp), %rdi
callq 0x40f0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rdx, -0xb0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x1cdbd
movq -0xb0(%rbp), %rax
movl -0xa4(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x40f0
jmp 0x1cdeb
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movl -0x4c(%rbp), %edx
movl -0xa0(%rbp), %edi
movq -0x98(%rbp), %rsi
callq 0x29c10
movq %rdx, -0xc8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1ce1a
movq -0xb8(%rbp), %rdi
movq -0xc8(%rbp), %rax
movl -0xbc(%rbp), %ecx
movl %ecx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
movl -0x90(%rbp), %edx
movq -0x88(%rbp), %rcx
leaq -0x80(%rbp), %rsi
callq 0x2bdf0
jmp 0x1ce53
leaq -0x80(%rbp), %rdi
callq 0x4170
leaq -0x40(%rbp), %rdi
callq 0x4170
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1ce98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4170
leaq -0x40(%rbp), %rdi
callq 0x4170
movq -0x58(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/bitlogicaleval.cpp
// Function: logicHelper(bool, bool, ParseOperatorType)
ParseData logicHelper(bool n1, bool n2, ParseOperatorType op) {
 
  ParseData d;
  d.type = BOOL_T;
  
  switch(op) {
    case AND_OP: d.value.integer = n1 && n2; break;
    case XOR_OP: d.value.integer = n1 ^ n2; break;
    case OR_OP: d.value.integer = n1 || n2; break;
  }
 
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movl %edx, -0x18(%rbp)
movl $0x9, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1c, %eax
je 0x1d230
jmp 0x1d21c
movl -0x1c(%rbp), %eax
subl $0x1d, %eax
je 0x1d24f
jmp 0x1d226
movl -0x1c(%rbp), %eax
subl $0x1e, %eax
je 0x1d26a
jmp 0x1d287
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x1d(%rbp)
je 0x1d241
movb -0x12(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x1d287
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x12(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x1d287
movb $0x1, %al
testb $0x1, -0x11(%rbp)
movb %al, -0x1e(%rbp)
jne 0x1d27b
movb -0x12(%rbp), %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
popq %rbp
retq
// File: AshOlogn[P]ash-language-interpreter/src/comparisoneval.cpp
// Function: ParseData inequalityHelper<char*, char*>(char*, char*, ParseOperatorType)
ParseData inequalityHelper<char*, char*>(char* str1, char* str2, ParseOperatorType op) {
 
  char* arg1 = str1;
  char* arg2 = str2;
  
  ParseData d;
  d.type = BOOL_T;
  int32_t res = strcmp(str1, str2);
  
  switch(op) { 
    case GREATER_OP: d.value.integer = res > 0; break;
    case GREATER_EQ_OP: d.value.integer = res >= 0; break;
    case LESS_OP: d.value.integer = res < 0; break;
    case LESS_EQ_OP: d.value.integer = res <= 0; break;
  }
  
  return d; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x9, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4370
movl %eax, -0x3c(%rbp)
movl -0x24(%rbp), %eax
addl $-0x13, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x3, %eax
ja 0x23205
movq -0x48(%rbp), %rax
leaq 0x2066a(%rip), %rcx     # 0x43820
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, -0x3c(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x23205
cmpl $0x0, -0x3c(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x23205
cmpl $0x0, -0x3c(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x23205
cmpl $0x0, -0x3c(%rbp)
setle %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/comparisoneval.cpp
// Function: ParseData equalityHelper<char*, char*>(char*, char*, ParseOperatorType)
ParseData equalityHelper<char*, char*>(char* str1, char* str2, ParseOperatorType op) {
 
  char* arg1 = str1;
  char* arg2 = str2;
  
  ParseData d;
  d.type = BOOL_T;
  int32_t res = strcmp(str1, str2);
  
  switch(op) { 
    case EQ_EQ_OP: d.value.integer = res == 0; break;
    case NOT_EQ_OP: d.value.integer = res != 0; break;
  }
  
  return d; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x9, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4370
movl %eax, -0x3c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
subl $0x17, %eax
je 0x23271
jmp 0x23267
movl -0x40(%rbp), %eax
subl $0x18, %eax
je 0x23283
jmp 0x23293
cmpl $0x0, -0x3c(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x23293
cmpl $0x0, -0x3c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
// File: AshOlogn[P]ash-language-interpreter/src/comparisoneval.cpp
// Function: ParseData inequalityHelper<unsigned char, unsigned char>(unsigned char, unsigned char, ParseOperatorType)
ParseData inequalityHelper(T1 n1, T2 n2, ParseOperatorType op) {
  
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = BOOL_T;
  
  switch(op) { 
    case GREATER_OP: d.value.integer = n1 > n2; break;
    case GREATER_EQ_OP: d.value.integer = n1 >= n2; break;
    case LESS_OP: d.value.integer = n1 < n2; break;
    case LESS_EQ_OP: d.value.integer = n1 <= n2; break;
  }

  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movl %edx, -0x18(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x1a(%rbp)
movl $0x9, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $-0x13, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x25849
movq -0x28(%rbp), %rax
leaq 0x1e666(%rip), %rcx     # 0x43e48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x25849
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x25849
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x25849
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/comparisoneval.cpp
// Function: ParseData equalityHelper<bool, bool>(bool, bool, ParseOperatorType)
ParseData equalityHelper(T1 n1, T2 n2, ParseOperatorType op) {
  
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = BOOL_T;
  
  switch(op) {
    case EQ_EQ_OP: d.value.integer = n1 == n2; break;
    case NOT_EQ_OP: d.value.integer = n1 != n2; break;
  }

  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movl %edx, -0x18(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
movl $0x9, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x17, %eax
je 0x27326
jmp 0x2731c
movl -0x20(%rbp), %eax
subl $0x18, %eax
je 0x27347
jmp 0x27366
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x12(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x27366
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x12(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nop