LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseExpressionList()
std::vector<Expression *> Parser::parseExpressionList()
{
	std::vector<Expression *> arguments;

	nextToken();
	arguments.push_back(parseExpression(LOWEST));

	while (peekToken.type == COMMA)
	{
		nextToken();
		nextToken();
		arguments.push_back(parseExpression(LOWEST));
	}

	return arguments;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x12736
leaq 0x70(%r14), %r15
leaq 0x1b50b(%rip), %r12     # 0x2baf8
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0xa7b4
testb %al, %al
je 0x1062d
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12736
jmp 0x105f2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x10644
jmp 0x10644
jmp 0x10644
movq %rax, %r14
movq %rbx, %rdi
callq 0xdcd0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/environment.cpp
// Function: Environment::Get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Object *Environment::Get(std::string name)
{
	if (store.find(name) == store.end())
	{
		if (outer != nullptr)
		{
			Object *obj = outer->Get(name);
			return obj;
		}

		return new Error("error : identifier not found -> " + name);
	}

	return store[name];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x12d3c
testq %rax, %rax
je 0x12c13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12e0c
movq (%rax), %rbx
jmp 0x12c71
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
je 0x12c41
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5260
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12bea
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x12c6c
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
leaq 0x9b1e(%rip), %rsi      # 0x1c771
movq %rsp, %rdi
movq %r14, %rdx
callq 0xd1c2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12cc2
movq %rsp, %rdi
callq 0x5388
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x5388
jmp 0x12c8e
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x51e0
jmp 0x12ca8
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: isTruthy(Object*)
bool isTruthy(Object *condition)
{
	if (condition == __TRUE)
		return true;
	else if (condition == __FALSE)
		return false;
	else if (condition == __NULL)
		return false;
	else if (condition->type() == INTEGER_OBJ && ((Integer *)condition)->value == 0)
		return false;
	else
		return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x16a99(%rip), %rcx     # 0x2c500
movb $0x1, %al
cmpq %rdi, (%rcx)
je 0x15acf
movq %rdi, %rbx
leaq 0x16a90(%rip), %rcx     # 0x2c508
xorl %eax, %eax
cmpq %rdi, (%rcx)
je 0x15acf
leaq 0x16a72(%rip), %rcx     # 0x2c4f8
cmpq %rbx, (%rcx)
je 0x15acf
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x176b6(%rip), %rsi     # 0x2d158
movq %r14, %rdi
callq 0xa7b4
testb %al, %al
je 0x15ac3
movl 0x8(%rbx), %ebx
leaq 0x8(%rsp), %rdi
callq 0x5388
testl %ebx, %ebx
jne 0x15acd
xorl %eax, %eax
jmp 0x15acf
leaq 0x8(%rsp), %rdi
callq 0x5388
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalProgram(Program*, Environment*)
Object *Evaluator::evalProgram(Program *program, Environment *env)
{
	Object *result;

	for (Statement *stmt : program->statements)
	{
		result = Eval(stmt, env);

		if (result->type() == RETURN_VALUE_OBJ || result->type() == ERROR_OBJ)
			return ((ReturnValue *)result)->value;

		else if (result->type() == ERROR_OBJ)
			return result;
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, (%rsp)
movq 0x8(%rsi), %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %r15
leaq 0x38(%rsp), %rbp
cmpq 0x10(%rsp), %rbx
je 0x166c4
movq (%rbx), %rsi
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x15ad8
movq %rax, %r13
movq (%rax), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *(%rax)
movq %r15, %rdi
leaq 0x16c92(%rip), %rsi     # 0x2d2d8
callq 0xa7b4
testb %al, %al
jne 0x166b6
movq (%r13), %rax
movq %rbp, %rdi
movq %r13, %rsi
callq *(%rax)
movq %rbp, %rdi
leaq 0x16cd3(%rip), %r14     # 0x2d338
movq %r14, %rsi
callq 0xa7b4
movl %eax, %r12d
movq %rbp, %rdi
callq 0x5388
movq %r15, %rdi
callq 0x5388
testb %r12b, %r12b
jne 0x166c0
movq (%r13), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0xa7b4
movl %eax, %r12d
movq %r15, %rdi
callq 0x5388
addq $0x8, %rbx
testb %r12b, %r12b
je 0x16612
jmp 0x166c4
leaq 0x18(%rsp), %rdi
callq 0x5388
movq 0x8(%r13), %r13
movq %r13, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalBlockStatement(BlockStatement*, Environment*)
Object *Evaluator::evalBlockStatement(BlockStatement *blockStmt, Environment *env)
{
	Object *result;

	for (Statement *stmt : blockStmt->statements)
	{
		result = Eval(stmt, env);
		if (result->type() == "RETURN_VALUE" || result->type() == "ERROR")
			return (ReturnValue *)result;
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x48(%rsi), %rbx
movq 0x50(%rsi), %r14
leaq 0x18(%rsp), %r15
leaq 0x38(%rsp), %r13
cmpq %r14, %rbx
je 0x16791
movq (%rbx), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x15ad8
movq %rax, %rbp
movq (%rax), %rax
movq %r15, %rdi
movq %rbp, %rsi
callq *(%rax)
movq %r15, %rdi
leaq 0x5981(%rip), %rsi      # 0x1c0c6
callq 0x18aa7
testb %al, %al
jne 0x16787
movq (%rbp), %rax
movq %r13, %rdi
movq %rbp, %rsi
callq *(%rax)
movq %r13, %rdi
leaq 0x597c(%rip), %rsi      # 0x1c0e0
callq 0x18aa7
movl %eax, %r12d
movq %r13, %rdi
callq 0x5388
movq %r15, %rdi
callq 0x5388
addq $0x8, %rbx
testb %r12b, %r12b
je 0x16716
jmp 0x16791
leaq 0x18(%rsp), %rdi
callq 0x5388
movq %rbp, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalPrefixExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Object*)
Object *Evaluator::evalPrefixExpression(std::string operand, Object *right)
{
	if (operand == "!")
		return evalBangPrefixExpression(right);
	else if (operand == "-")
		return evalMinusPrefixExpression(right);

	Object *error = new Error("error : unknown operator for " + right->type() + " -> " + operand);
	return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r15
movq %rsi, %r14
leaq 0x5856(%rip), %rsi      # 0x1c027
movq %r14, %rdi
callq 0x18aa7
testb %al, %al
je 0x167f1
movq %r15, %rsi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x17c08
leaq 0x6383(%rip), %rsi      # 0x1cb7b
movq %r14, %rdi
callq 0x18aa7
testb %al, %al
je 0x16818
movq %r15, %rsi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x17c90
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
callq *(%rax)
leaq 0x6324(%rip), %rsi      # 0x1cb59
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xd257
leaq 0x5f44(%rip), %rdx      # 0x1c78d
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd12a
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rdx
callq 0xd238
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x12cc2
leaq 0x60(%rsp), %rdi
callq 0x5388
leaq 0x40(%rsp), %rdi
callq 0x5388
leaq 0x20(%rsp), %rdi
callq 0x5388
movq %rsp, %rdi
callq 0x5388
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x5388
jmp 0x168bf
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x5388
jmp 0x168ce
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5388
jmp 0x168dd
movq %rax, %r14
movq %rsp, %rdi
callq 0x5388
jmp 0x168ea
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalIfExpression(IfExpression*, Environment*)
Object *Evaluator::evalIfExpression(IfExpression *ifExpr, Environment *env)
{
	Object *condition = Eval(ifExpr->condition, env);

	if (isTruthy(condition))
		return Eval(ifExpr->consequence, env);

	else if (ifExpr->alternative != nullptr)
		return Eval(ifExpr->alternative, env);

	return __NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x48(%rsi), %rsi
callq 0x15ad8
movq %rax, %rdi
callq 0x15a59
testb %al, %al
je 0x16dbb
movq 0x50(%r15), %rsi
jmp 0x16dc4
movq 0x58(%r15), %rsi
testq %rsi, %rsi
je 0x16dd4
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x15ad8
leaq 0x1571d(%rip), %rax     # 0x2c4f8
movq (%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalIdentifier(Identifier*, Environment*)
Object *Evaluator::evalIdentifier(Identifier *ident, Environment *env)
{
	Object *obj = env->Get(ident->value);

	if (obj->type() != ERROR_OBJ &&
		builtin.find(ident->value) != builtin.end())
		return builtin[ident->value];

	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %rbx
addq $0x48, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5260
movq %r14, %rdi
movq %r15, %rsi
callq 0x12bea
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5388
movq (%r14), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x16504(%rip), %rsi     # 0x2d338
movq %r15, %rdi
callq 0x10766
testb %al, %al
je 0x16e73
leaq 0x16511(%rip), %rdi     # 0x2d358
movq %rbx, %rsi
callq 0x1bb46
movq %rax, %r15
movq %rsp, %rdi
callq 0x5388
testq %r15, %r15
je 0x16e7b
leaq 0x164f2(%rip), %rdi     # 0x2d358
movq %rbx, %rsi
callq 0x1bb74
movq (%rax), %r14
jmp 0x16e7b
movq %rsp, %rdi
callq 0x5388
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x16e98
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalIndexExpression(Object*, Object*, Environment*)
Object *Evaluator::evalIndexExpression(Object *left, Object *index, Environment *env)
{
	if (left->type() == STRING_OBJ && index->type() == INTEGER_OBJ)
		return evalStringIndexExpression((String *)left, (Integer *)index);

	else if (left->type() == ARRAY_OBJ && index->type() == INTEGER_OBJ)
		return evalArrayIndexExpression((Array *)left, (Integer *)index);

	else if (left->type() == HASHMAP_OBJ)
		return evalHashMapIndexExpression((HashMap *)left, index);

	else
		return new Error("error: index operator [] not supported for -> " + left->type());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *(%rax)
leaq 0x15fcc(%rip), %rsi     # 0x2d198
movq %r15, %rdi
callq 0xa7b4
testb %al, %al
je 0x17222
movq (%r14), %rax
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x15f6c(%rip), %rsi     # 0x2d158
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0xa7b4
movl %eax, %ebp
movq %r15, %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
testb %bpl, %bpl
je 0x1722c
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1840a
jmp 0x172d9
leaq 0x8(%rsp), %rdi
callq 0x5388
movq (%rbx), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x15f95(%rip), %rsi     # 0x2d1d8
movq %r15, %rdi
callq 0xa7b4
testb %al, %al
je 0x17296
movq (%r14), %rax
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x15ef5(%rip), %rsi     # 0x2d158
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0xa7b4
movl %eax, %ebp
movq %r15, %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
testb %bpl, %bpl
je 0x172a0
movq %rbx, %rsi
movq %r14, %rdx
callq 0x18560
jmp 0x172d9
leaq 0x8(%rsp), %rdi
callq 0x5388
movq (%rbx), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x15f41(%rip), %rsi     # 0x2d1f8
movq %r15, %rdi
callq 0xa7b4
movl %eax, %ebp
movq %r15, %rdi
callq 0x5388
testb %bpl, %bpl
je 0x172de
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1867a
movq %rax, %r14
jmp 0x1732d
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %r14
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x58f1(%rip), %rsi      # 0x1cbee
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd257
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x12cc2
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0x1734d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0x1735c
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x51e0
jmp 0x17378
jmp 0x1736b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalHashMapLiteral(HashMapLiteral*, Environment*)
Object *Evaluator::evalHashMapLiteral(HashMapLiteral *hashMapLiteral, Environment *env)
{
	HashMap *hashMap = new HashMap();

	for (auto pair : hashMapLiteral->pairs)
	{
		Object *key = Eval(pair.key, env);

		if (key->type() == ERROR_OBJ)
			return key;

		Object *value = Eval(pair.value, env);

		if (value->type() == ERROR_OBJ)
		{
			delete hashMap;
			return value;
		}

		HashKey hashKey(key->type(), key->inspect());
		HashMapPairObj hashMapPairObj(key, value);

		hashMap->pairs[hashKey] = hashMapPairObj;
	}

	return hashMap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0x51d0
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
leaq 0x12868(%rip), %rcx     # 0x29c18
movq %rcx, (%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
leaq 0x38(%rax), %rcx
movq %rcx, 0x8(%rax)
movq $0x1, 0x10(%rax)
movups %xmm0, 0x18(%rax)
movl $0x3f800000, 0x28(%rax) # imm = 0x3F800000
movq %rax, 0x8(%rsp)
movups %xmm0, 0x30(%rax)
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x15f44(%rip), %r13     # 0x2d338
movq %r14, 0x18(%rsp)
movq %r12, 0x10(%rsp)
cmpq 0x28(%rsp), %rcx
je 0x17513
movq (%rcx), %rsi
movq %rcx, 0x30(%rsp)
movq 0x8(%rcx), %rbx
movq %r14, %rdi
movq %r12, %rdx
callq 0x15ad8
movq %rax, %rbp
movq (%rax), %rax
movq %r14, %r15
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq *(%rax)
movq %r14, %rdi
movq %r13, %rsi
callq 0xa7b4
movb %al, 0x7(%rsp)
movq %r14, %rdi
callq 0x5388
cmpb $0x0, 0x7(%rsp)
jne 0x1751a
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x15ad8
movq %rax, %rbx
movq (%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %r14, %rdi
movq %r13, %r15
movq %r13, %rsi
callq 0xa7b4
movl %eax, %r12d
movq %r14, %rdi
callq 0x5388
testb %r12b, %r12b
jne 0x1751f
movq (%rbp), %rax
leaq 0x58(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq *(%rax)
movq (%rbp), %rax
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq *0x8(%rax)
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x188ee
movq %r13, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
movq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x1bcae
movq %rbp, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, %rdi
callq 0x18942
movq 0x30(%rsp), %rcx
addq $0x10, %rcx
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %r14
movq %r15, %r13
jmp 0x173fe
movq 0x8(%rsp), %rbx
jmp 0x17537
movq %rbp, %rbx
jmp 0x17537
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x18b44
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x51e0
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5388
jmp 0x1755e
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5388
jmp 0x17577
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x18942
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalHashSetLiteral(HashSetLiteral*, Environment*)
Object *Evaluator::evalHashSetLiteral(HashSetLiteral *hashSetLiteral, Environment *env)
{
	HashSet *hashSet = new HashSet();

	for (auto pair : hashSetLiteral->pairs)
	{
		Object *key = Eval(pair, env);

		if (key->type() == ERROR_OBJ)
		{
			delete hashSet;
			return key;
		}

		HashKey hashKey(key->type(), key->inspect());
		hashSet->pairs[hashKey] = key;
	}

	return hashSet;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
pushq $0x40
popq %rdi
callq 0x51d0
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
leaq 0x1269c(%rip), %rcx     # 0x29c50
movq %rcx, (%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x38(%rax), %rcx
movq %rcx, 0x8(%rax)
movq $0x1, 0x10(%rax)
movups %xmm0, 0x18(%rax)
movl $0x3f800000, 0x28(%rax) # imm = 0x3F800000
movq %rax, (%rsp)
movups %xmm0, 0x30(%rax)
movq 0x48(%rbx), %r12
movq 0x50(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x28(%rsp), %rbx
cmpq 0x20(%rsp), %r12
je 0x176a0
movq (%r12), %rsi
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
callq 0x15ad8
movq %rax, %r14
movq (%rax), %rax
movq %r13, %rdi
movq %r14, %rsi
callq *(%rax)
movq %r13, %rdi
leaq 0x15d03(%rip), %rsi     # 0x2d338
callq 0xa7b4
movl %eax, %r15d
movq %r13, %rdi
callq 0x5388
testb %r15b, %r15b
jne 0x176a6
movq (%r14), %rax
movq %rbp, %rdi
movq %r14, %rsi
callq *(%rax)
movq (%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x8(%rax)
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x188ee
movq %rbx, %rdi
callq 0x5388
movq %rbp, %rdi
callq 0x5388
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x1bdc0
movq %r14, (%rax)
movq %r13, %rdi
callq 0x18942
addq $0x8, %r12
jmp 0x175ff
movq (%rsp), %r14
jmp 0x176bd
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x18b58
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0x176e4
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5388
jmp 0x176fd
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x18942
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalStackLiteral(StackLiteral*, Environment*)
Object *Evaluator::evalStackLiteral(StackLiteral *stackLiteral, Environment *env)
{
	Stack *stack = new Stack();

	for (auto elem : stackLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete stack;
			return obj;
		}

		stack->elements.push(obj);
	}

	return stack;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x58
popq %rdi
callq 0x51d0
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
andq $0x0, 0x50(%rax)
movq %rax, %rdi
callq 0x18b6c
movq 0x48(%rbx), %rbp
movq 0x50(%rbx), %r14
movq %r12, (%rsp)
addq $0x8, %r12
leaq 0x18(%rsp), %r13
cmpq %r14, %rbp
je 0x177b8
movq (%rbp), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x15ad8
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r13, %rdi
leaq 0x15ba6(%rip), %rsi     # 0x2d338
callq 0xa7b4
movl %eax, %ebx
movq %r13, %rdi
callq 0x5388
testb %bl, %bl
jne 0x177be
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x18be4
addq $0x8, %rbp
jmp 0x17762
movq (%rsp), %rax
jmp 0x177da
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x18b80
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x51e0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalQueueLiteral(QueueLiteral*, Environment*)
Object *Evaluator::evalQueueLiteral(QueueLiteral *queueLiteral, Environment *env)
{
	Queue *queue = new Queue();

	for (auto elem : queueLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete queue;
			return obj;
		}

		queue->elements.push(obj);
	}

	return queue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x58
popq %rdi
callq 0x51d0
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
andq $0x0, 0x50(%rax)
movq %rax, %rdi
callq 0x18b94
movq 0x48(%rbx), %rbp
movq 0x50(%rbx), %r14
movq %r12, (%rsp)
addq $0x8, %r12
leaq 0x18(%rsp), %r13
cmpq %r14, %rbp
je 0x178b2
movq (%rbp), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x15ad8
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r13, %rdi
leaq 0x15aac(%rip), %rsi     # 0x2d338
callq 0xa7b4
movl %eax, %ebx
movq %r13, %rdi
callq 0x5388
testb %bl, %bl
jne 0x178b8
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x18be4
addq $0x8, %rbp
jmp 0x1785c
movq (%rsp), %rax
jmp 0x178d4
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x18ba8
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x51e0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalDequeLiteral(DequeLiteral*, Environment*)
Object *Evaluator::evalDequeLiteral(DequeLiteral *queueLiteral, Environment *env)
{
	Deque *deque = new Deque();

	for (auto elem : queueLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete deque;
			return obj;
		}

		deque->elements.push_back(obj);
	}

	return deque;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x58
popq %rdi
callq 0x51d0
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
andq $0x0, 0x50(%rax)
movq %rax, %rdi
callq 0x18bbc
movq 0x48(%rbx), %rbp
movq 0x50(%rbx), %r14
movq %r12, (%rsp)
addq $0x8, %r12
leaq 0x18(%rsp), %r13
cmpq %r14, %rbp
je 0x179ac
movq (%rbp), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x15ad8
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r13, %rdi
leaq 0x159b2(%rip), %rsi     # 0x2d338
callq 0xa7b4
movl %eax, %ebx
movq %r13, %rdi
callq 0x5388
testb %bl, %bl
jne 0x179b2
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x18be4
addq $0x8, %rbp
jmp 0x17956
movq (%rsp), %rax
jmp 0x179ce
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x18bd0
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x51e0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalMaxHeapLiteral(MaxHeapLiteral*, Environment*)
Object *Evaluator::evalMaxHeapLiteral(MaxHeapLiteral *maxHeapLiteral, Environment *env)
{
	MaxHeap *maxHeap = new MaxHeap(maxHeapLiteral->type);

	for (auto elem : maxHeapLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete maxHeap;
			return obj;
		}

		maxHeap->elements.push(obj);
	}

	return maxHeap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x48
popq %rdi
callq 0x51d0
movq %rax, %r12
leaq 0x48(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x5260
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x18c06
leaq 0x18(%rsp), %rdi
callq 0x5388
movq 0x68(%rbx), %rbp
movq 0x70(%rbx), %r14
movq %r12, (%rsp)
addq $0x28, %r12
leaq 0x38(%rsp), %r13
cmpq %r14, %rbp
je 0x17aa8
movq (%rbp), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x15ad8
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r13, %rdi
leaq 0x158b6(%rip), %rsi     # 0x2d338
callq 0xa7b4
movl %eax, %ebx
movq %r13, %rdi
callq 0x5388
testb %bl, %bl
jne 0x17aae
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x18840
addq $0x8, %rbp
jmp 0x17a52
movq (%rsp), %rax
jmp 0x17aca
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x18c2c
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5388
jmp 0x17aeb
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r12, %rdi
callq 0x51e0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalMinHeapLiteral(MinHeapLiteral*, Environment*)
Object *Evaluator::evalMinHeapLiteral(MinHeapLiteral *minHeapLiteral, Environment *env)
{
	MinHeap *minHeap = new MinHeap(minHeapLiteral->type);

	for (auto elem : minHeapLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete minHeap;
			return obj;
		}

		minHeap->elements.push(obj);
	}

	return minHeap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x48
popq %rdi
callq 0x51d0
movq %rax, %r12
leaq 0x48(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x5260
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x18c50
leaq 0x18(%rsp), %rdi
callq 0x5388
movq 0x68(%rbx), %rbp
movq 0x70(%rbx), %r14
movq %r12, (%rsp)
addq $0x28, %r12
leaq 0x38(%rsp), %r13
cmpq %r14, %rbp
je 0x17bb2
movq (%rbp), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x15ad8
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r13, %rdi
leaq 0x157ac(%rip), %rsi     # 0x2d338
callq 0xa7b4
movl %eax, %ebx
movq %r13, %rdi
callq 0x5388
testb %bl, %bl
jne 0x17bb8
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x18856
addq $0x8, %rbp
jmp 0x17b5c
movq (%rsp), %rax
jmp 0x17bd4
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x18c76
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5388
jmp 0x17bf5
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r12, %rdi
callq 0x51e0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalBangPrefixExpression(Object*)
Object *Evaluator::evalBangPrefixExpression(Object *right)
{
	if (right == __TRUE)
		return __FALSE;

	else if (right == __FALSE)
		return __TRUE;
	else if (right == __NULL)
		return __TRUE;

	else if (right->type() == INTEGER_OBJ)
	{
		if (((Integer *)right)->value == 0)
			return __TRUE;
		else
			return __FALSE;
	}

	return __FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x148e5(%rip), %r15     # 0x2c500
movq (%r15), %rax
leaq 0x148e3(%rip), %r12     # 0x2c508
movq (%r12), %rcx
cmpq %rsi, %rax
je 0x17c7a
movq %rsi, %rbx
cmpq %rsi, %rcx
je 0x17c7d
leaq 0x148bb(%rip), %rcx     # 0x2c4f8
cmpq %rbx, (%rcx)
je 0x17c7d
movq (%rbx), %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x15501(%rip), %rsi     # 0x2d158
movq %r14, %rdi
callq 0xa7b4
movl %eax, %ebp
movq %r14, %rdi
callq 0x5388
testb %bpl, %bpl
je 0x17c74
cmpl $0x0, 0x8(%rbx)
je 0x17c8a
movq (%r12), %rax
jmp 0x17c7d
movq %rcx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rax
jmp 0x17c7d
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalMinusPrefixExpression(Object*)
Object *Evaluator::evalMinusPrefixExpression(Object *right)
{
	if (right->type() == INTEGER_OBJ)
	{
		Integer *intObj = new Integer(-((Integer *)right)->value);
		return intObj;
	}

	Object *error = new Error("error : unknown operator for " + right->type() + " -> -");
	return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq (%rsi), %rax
movq %rsp, %rbx
movq %rbx, %rdi
callq *(%rax)
leaq 0x154ab(%rip), %rsi     # 0x2d158
movq %rbx, %rdi
callq 0xa7b4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5388
testb %bpl, %bpl
je 0x17ce4
pushq $0x10
popq %rdi
callq 0x51d0
xorl %ecx, %ecx
subl 0x8(%r14), %ecx
movq %rax, %rbx
leaq 0x11dec(%rip), %rax     # 0x29ac8
movq %rax, (%rbx)
movl %ecx, 0x8(%rbx)
jmp 0x17d4d
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x4e56(%rip), %rsi      # 0x1cb59
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xd257
leaq 0x4e60(%rip), %rdx      # 0x1cb77
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0xd12a
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x12cc2
leaq 0x40(%rsp), %rdi
callq 0x5388
movq %rsp, %rdi
callq 0x5388
leaq 0x20(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x5388
jmp 0x17d6b
movq %rax, %r14
movq %rsp, %rdi
callq 0x5388
jmp 0x17d78
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5388
jmp 0x17d87
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalStringInfixExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Object*, Object*)
Object *Evaluator::evalStringInfixExpression(std::string operand, Object *left, Object *right)
{
	std::string leftVal = ((String *)left)->value;
	std::string rightVal = ((String *)right)->value;

	Object *res;

	if (operand == "+")
		res = new String(leftVal + rightVal);
	else
		return new Error("error: unknown operator -> " + left->type() + " " + operand + " " + right->type());

	return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
leaq 0x8(%rdx), %rsi
leaq 0x128(%rsp), %rdi
callq 0x5260
leaq 0x8(%r14), %rsi
leaq 0x108(%rsp), %rdi
callq 0x5260
leaq 0x3edb(%rip), %rsi      # 0x1c025
movq %r15, %rdi
callq 0x18aa7
testb %al, %al
je 0x1819b
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
leaq 0x128(%rsp), %rsi
leaq 0x108(%rsp), %rdx
callq 0x18b0b
leaq 0xe8(%rsp), %rsi
movq %rbx, %rdi
callq 0x18ab4
leaq 0xe8(%rsp), %rdi
jmp 0x18292
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
movq (%r12), %rax
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq *(%rax)
leaq 0x49db(%rip), %rsi      # 0x1cb96
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xd257
leaq 0x4021(%rip), %rdx      # 0x1c1f2
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd12a
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movq %r15, %rdx
callq 0xd238
leaq 0x3ff6(%rip), %rdx      # 0x1c1f2
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xd12a
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xd149
leaq 0xc8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12cc2
leaq 0xc8(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0xa8(%rsp), %rdi
callq 0x5388
leaq 0x88(%rsp), %rdi
callq 0x5388
leaq 0x68(%rsp), %rdi
callq 0x5388
leaq 0x48(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x108(%rsp), %rdi
callq 0x5388
leaq 0x128(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
callq 0x5388
jmp 0x182d8
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0x182e7
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x5388
jmp 0x182f9
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x5388
jmp 0x1830b
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x5388
leaq 0x48(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0x18347
movq %rax, %r14
jmp 0x18315
movq %rax, %r14
jmp 0x1831f
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
jmp 0x18324
jmp 0x18344
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x51e0
leaq 0x108(%rsp), %rdi
callq 0x5388
leaq 0x128(%rsp), %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
movq %rax, %r14
jmp 0x18352
movq %rax, %r14
jmp 0x1835f
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::extendFunctionEnv(Function*, std::vector<Object*, std::allocator<Object*>>&, Environment*)
Environment *Evaluator::extendFunctionEnv(Function *fn, std::vector<Object *> &args, Environment *outer)
{
	Environment *env = outer->NewEnclosed();

	for (int i = 0; i < args.size(); i++)
		env->Set(fn->parameters[i]->value, args[i]);

	return env;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
callq 0x12bb2
movq %rax, %r15
xorl %r13d, %r13d
movq %rsp, %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jbe 0x183e5
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rsi
addq $0x48, %rsi
movq %r12, %rdi
callq 0x5260
movq (%rbx), %rax
movq (%rax,%r13,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12cb0
movq %r12, %rdi
callq 0x5388
incq %r13
jmp 0x183a2
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalStringIndexExpression(String*, Integer*)
Object *Evaluator::evalStringIndexExpression(String *string, Integer *index)
{
	int i = index->value;
	auto arr = string->value;

	if (arr.size() <= i)
		return new Error("error: index " + index->inspect() + " out of range");

	return new String(std::string(1, arr[i]));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r14
movslq 0x8(%rdx), %r15
addq $0x8, %rsi
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
callq 0x5260
cmpq %r15, 0x8(%rbx)
jbe 0x18473
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
movq 0x80(%rsp), %rax
movsbl (%rax,%r15), %edx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x5200
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x18ab4
movq %rsp, %rdi
jmp 0x184de
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x478a(%rip), %rsi      # 0x1cc1d
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xd257
leaq 0x4132(%rip), %rdx      # 0x1c5db
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd12a
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x12cc2
leaq 0x60(%rsp), %rdi
callq 0x5388
leaq 0x40(%rsp), %rdi
callq 0x5388
leaq 0x20(%rsp), %rdi
callq 0x5388
leaq 0x80(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x5388
jmp 0x18512
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x5388
jmp 0x18521
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x1852e
movq %rax, %r14
movq %rsp, %rdi
callq 0x5388
jmp 0x1853a
jmp 0x18537
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x51e0
jmp 0x1854a
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalArrayIndexExpression(Array*, Integer*)
Object *Evaluator::evalArrayIndexExpression(Array *array, Integer *index)
{
	int i = index->value;
	auto arr = array->elements;

	if (arr.size() <= i)
		return new Error("error: index " + index->inspect() + " out of range");

	return arr[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movslq 0x8(%rdx), %r15
addq $0x8, %rsi
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x18958
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x1859d
movq (%rax,%r15,8), %rbx
jmp 0x1860d
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x4660(%rip), %rsi      # 0x1cc1d
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd257
leaq 0x4008(%rip), %rdx      # 0x1c5db
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd12a
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x12cc2
leaq 0x48(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x68(%rsp), %rdi
callq 0x1a46e
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5388
jmp 0x18639
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0x18648
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0x18657
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x51e0
jmp 0x18667
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x1a46e
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalHashMapIndexExpression(HashMap*, Object*)
Object *Evaluator::evalHashMapIndexExpression(HashMap *hashMap, Object *index)
{
	HashKey hashKey(index->type(), index->inspect());

	if (hashMap->pairs.find(hashKey) != hashMap->pairs.end())
		return hashMap->pairs[hashKey].value;

	return new Error("error: key not present -> " + index->inspect());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rax
leaq 0x68(%rsp), %rdi
movq %rdx, %rsi
callq *(%rax)
movq (%r14), %rax
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x188ee
leaq 0x48(%rsp), %rdi
callq 0x5388
leaq 0x68(%rsp), %rdi
callq 0x5388
addq $0x8, %rbx
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b540
testq %rax, %rax
je 0x186ff
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x1bcae
movq 0x8(%rax), %rbx
jmp 0x1874f
pushq $0x28
popq %rdi
callq 0x51d0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x450c(%rip), %rsi      # 0x1cc2b
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd257
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x12cc2
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x88(%rsp), %rdi
callq 0x18942
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0x1877c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0x1878b
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x51e0
jmp 0x1879d
jmp 0x1879a
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x18942
jmp 0x187c8
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5388
jmp 0x187be
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Function::inspect[abi:cxx11]()
std::string inspect()
	{
		std::string res = "def (";
		for (auto ident : parameters)
			res += ident->getStringRepr() + ", ";

		if (parameters.size() != 0)
		{
			res.pop_back();
			res.pop_back();
		}

		res += ")" + std::string("{\n") + body->getStringRepr() + std::string("\n}");

		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x36e3(%rip), %rsi      # 0x1cc57
leaq 0x38(%rsp), %r15
movq %r15, %rdx
callq 0x9da4
movq 0x8(%r14), %rbp
movq %r14, 0x10(%rsp)
movq 0x10(%r14), %r14
leaq 0x18(%rsp), %r12
leaq 0x2c57(%rip), %r13      # 0x1c1f1
cmpq %r14, %rbp
je 0x195db
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
addq $0x8, %rbp
jmp 0x1959a
movq 0x10(%rsp), %r14
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
je 0x195fa
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
leaq 0x365c(%rip), %rsi      # 0x1cc5d
leaq 0x98(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x9da4
leaq 0x34ec(%rip), %rsi      # 0x1cb06
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0xd257
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq 0x78(%rsp), %rdi
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0xd149
leaq 0x3604(%rip), %rsi      # 0x1cc60
leaq 0x58(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x9da4
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0xd149
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x5360
leaq 0x38(%rsp), %rdi
callq 0x5388
leaq 0x58(%rsp), %rdi
callq 0x5388
leaq 0x18(%rsp), %rdi
callq 0x5388
leaq 0x78(%rsp), %rdi
callq 0x5388
leaq 0xb8(%rsp), %rdi
callq 0x5388
leaq 0x98(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x5388
jmp 0x196f5
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x5388
jmp 0x19704
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x5388
jmp 0x19713
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x5388
jmp 0x19722
movq %rax, %r14
leaq 0xb8(%rsp), %rdi
callq 0x5388
leaq 0x98(%rsp), %rdi
jmp 0x1975c
movq %rax, %r14
jmp 0x1972f
jmp 0x19740
movq %rax, %r14
jmp 0x19761
movq %rax, %r14
jmp 0x19757
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x5388
leaq 0x18(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Array::inspect[abi:cxx11]()
std::string inspect()
	{
		std::string res = "[";

		for (auto elem : elements)
			res += elem->inspect() + ", ";

		if (elements.size() != 0)
		{
			res.pop_back();
			res.pop_back();
		}

		res.push_back(']');

		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x287a(%rip), %rsi      # 0x1c043
leaq 0x28(%rsp), %r15
movq %r15, %rdx
callq 0x9da4
movq 0x8(%r14), %rbp
movq %r14, (%rsp)
movq 0x10(%r14), %r14
leaq 0x8(%rsp), %r12
leaq 0x2a03(%rip), %r13      # 0x1c1f1
cmpq %r14, %rbp
je 0x1982f
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
addq $0x8, %rbp
jmp 0x197ee
movq (%rsp), %rcx
movq 0x10(%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0x1984d
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1986c
movq %rax, %r14
jmp 0x1988d
movq %rax, %r14
jmp 0x19883
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: HashMap::inspect[abi:cxx11]()
std::string inspect()
	{
		std::string res = "{";

		for (auto pair : pairs)
			res += pair.second.key->inspect() + " : " + pair.second.value->inspect() + ", ";

		if (pairs.size() != 0)
		{
			res.pop_back();
			res.pop_back();
		}

		res.push_back('}');

		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
leaq 0x2920(%rip), %rsi      # 0x1c1ef
leaq 0x18(%rsp), %rdx
movq %rdi, 0x8(%rsp)
callq 0x9da4
movq %rbx, 0x10(%rsp)
leaq 0x18(%rbx), %r15
leaq 0x88(%rsp), %r12
leaq 0xa8(%rsp), %rbp
leaq 0x68(%rsp), %r14
leaq 0xc8(%rsp), %r13
leaq 0xe8(%rsp), %rbx
movq (%r15), %r15
testq %r15, %r15
je 0x199b8
leaq 0x8(%r15), %rsi
leaq 0x18(%rsp), %rdi
callq 0x18fee
movq 0x58(%rsp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %rbp, %rdi
movq %r12, %rsi
leaq 0x28b3(%rip), %rdx      # 0x1c1f4
callq 0xd12a
movq 0x60(%rsp), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r13, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0xd149
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x2882(%rip), %rdx      # 0x1c1f1
callq 0xd12a
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x5360
movq %rbx, %rdi
callq 0x5388
movq %r13, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5388
movq %rbp, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
leaq 0x18(%rsp), %rdi
callq 0x18942
jmp 0x1990c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
movq 0x8(%rsp), %r14
je 0x199d9
movq %r14, %rdi
callq 0x5210
movq %r14, %rdi
callq 0x5210
pushq $0x7d
popq %rsi
movq %r14, %rdi
callq 0x5190
movq %r14, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x19a76
movq %rax, %rbx
jmp 0x19a34
movq %rax, %rbx
jmp 0x19a2a
movq %rax, %rbx
jmp 0x19a1d
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x5388
leaq 0xc8(%rsp), %rdi
callq 0x5388
leaq 0x68(%rsp), %rdi
callq 0x5388
leaq 0xa8(%rsp), %rdi
callq 0x5388
jmp 0x19a5a
movq %rax, %rbx
movq 0x8(%rsp), %r14
jmp 0x19a76
movq %rax, %rbx
movq 0x8(%rsp), %r14
jmp 0x19a6c
movq %rax, %rbx
movq 0x8(%rsp), %r14
leaq 0x88(%rsp), %rdi
callq 0x5388
leaq 0x18(%rsp), %rdi
callq 0x18942
movq %r14, %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: HashSet::inspect[abi:cxx11]()
std::string inspect()
	{
		std::string res = "hashset<> {";

		for (auto pair : pairs)
			res += pair.second->inspect() + ", ";

		if (pairs.size() != 0)
		{
			res.pop_back();
			res.pop_back();
		}

		res.push_back('}');

		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x273e(%rip), %rsi      # 0x1c1f8
leaq 0x50(%rsp), %r15
movq %r15, %rdx
callq 0x9da4
movq %r14, 0x8(%rsp)
addq $0x18, %r14
leaq 0x10(%rsp), %r12
leaq 0x2715(%rip), %r13      # 0x1c1f1
leaq 0x30(%rsp), %rbp
movq (%r14), %r14
testq %r14, %r14
je 0x19b39
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x192f6
movq 0x90(%rsp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5360
movq %rbp, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
movq %r15, %rdi
callq 0x18942
jmp 0x19ae1
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19b55
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19b77
movq %rax, %r14
jmp 0x19ba7
movq %rax, %r14
jmp 0x19b9d
movq %rax, %r14
jmp 0x19b93
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x5388
leaq 0x10(%rsp), %rdi
callq 0x5388
leaq 0x50(%rsp), %rdi
callq 0x18942
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop