LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseExpression(Precedence)
Expression *Parser::parseExpression(Precedence precedence)
{
	if (prefixParseFns.find(curToken.type) == prefixParseFns.end())
	{
		noPrefixParseFnError(curToken.type);
		return nullptr;
	}

	PrefixParseFn prefix = prefixParseFns[curToken.type];

	Expression *leftExp = (this->*prefix)(); // ->* operator is used to invoke method pointer

	while (peekToken.type != SEMICOLON && precedence < peekPrecedence())
	{
		if (infixParseFns.find(peekToken.type) == infixParseFns.end())
			return leftExp;

		InfixParseFn infix = infixParseFns[peekToken.type];
		if (infix == nullptr)
			return leftExp;

		nextToken();

		leftExp = (this->*infix)(leftExp);
	}

	return leftExp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x100(%rdi), %r14
leaq 0x30(%rdi), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x18996
testq %rax, %rax
je 0x16369
movq %r14, %rdi
movq %r15, %rsi
callq 0x17b76
movq (%rax), %rcx
movq 0x8(%rax), %rdi
addq %rbx, %rdi
testb $0x1, %cl
je 0x162c4
movq (%rdi), %rax
movq -0x1(%rax,%rcx), %rcx
callq *%rcx
movq %rax, %r14
leaq 0x138(%rbx), %r15
leaq 0x70(%rbx), %r12
movq 0x78(%rbx), %rdx
cmpq 0x20839(%rip), %rdx     # 0x36b18
jne 0x16302
testq %rdx, %rdx
je 0x163af
movq 0x2081f(%rip), %rsi     # 0x36b10
movq (%r12), %rdi
callq 0x51d0
testl %eax, %eax
je 0x163af
movq %rbx, %rdi
callq 0x169ce
cmpl 0x4(%rsp), %eax
jle 0x163af
movq %r15, %rdi
movq %r12, %rsi
callq 0x189d0
testq %rax, %rax
je 0x163af
movq %r15, %rdi
movq %r12, %rsi
callq 0x17f6e
movq (%rax), %rbp
testq %rbp, %rbp
je 0x163af
movq 0x8(%rax), %r13
addq %rbx, %r13
movq %rbx, %rdi
callq 0x13d2e
testb $0x1, %bpl
je 0x16359
movq (%r13), %rax
movq -0x1(%rax,%rbp), %rbp
movq %r13, %rdi
movq %r14, %rsi
callq *%rbp
movq %rax, %r14
jmp 0x162d4
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xbdc6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16606
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x163ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x163db
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseBlockStatement()
BlockStatement *Parser::parseBlockStatement()
{
	BlockStatement *block = new BlockStatement();
	block->token = curToken;

	nextToken();

	while (curToken.type != RBRACE && curToken.type != END)
	{
		Statement *stmt = parseStatement();
		if (stmt != nullptr)
			block->statements.push_back(stmt);

		nextToken();
	}

	return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x60, %edi
callq 0x51b0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1d8f5(%rip), %rax     # 0x34370
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r13
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movb %al, 0x38(%r14)
leaq 0x48(%r14), %r15
movups %xmm0, 0x48(%r14)
movq $0x0, 0x58(%r14)
leaq 0x30(%rbx), %r12
movq %r12, %rsi
callq 0x5100
leaq 0x50(%rbx), %rsi
movq %r13, %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x13d2e
movq %rsp, %r13
movq 0x38(%rbx), %rbp
cmpq 0x200d5(%rip), %rbp     # 0x36bb8
jne 0x16b01
testq %rbp, %rbp
je 0x16b63
movq 0x200bf(%rip), %rsi     # 0x36bb0
movq (%r12), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x16b63
cmpq 0x1fdd0(%rip), %rbp     # 0x368d8
jne 0x16b26
testq %rbp, %rbp
je 0x16b63
movq 0x1fdba(%rip), %rsi     # 0x368d0
movq (%r12), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x16b63
movq %rbx, %rdi
callq 0x15b9c
movq %rax, (%rsp)
testq %rax, %rax
je 0x16b56
movq 0x50(%r14), %rsi
cmpq 0x58(%r14), %rsi
je 0x16b4b
movq %rax, (%rsi)
addq $0x8, 0x50(%r14)
jmp 0x16b56
movq %r15, %rdi
movq %r13, %rdx
callq 0x18366
movq %rbx, %rdi
callq 0x13d2e
jmp 0x16ad8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x18cbc
movq 0x78(%r14), %rdx
cmpq 0x1fcb6(%rip), %rdx     # 0x36af8
jne 0x16e99
leaq 0x8(%rsp), %r15
testq %rdx, %rdx
je 0x16e62
movq 0x1fc9b(%rip), %rsi     # 0x36af0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x16e99
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18cbc
movq 0x78(%r14), %rdx
cmpq 0x1fc61(%rip), %rdx     # 0x36af8
je 0x16e49
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x16eac
jmp 0x16eac
jmp 0x16eac
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x16ec3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1932e
testq %rax, %rax
je 0x19194
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1942a
movq (%rax), %rbx
jmp 0x19240
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
je 0x191dc
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xbdc6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19168
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x19240
movq 0x30(%rsp), %rsi
jmp 0x19238
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x10556(%rip), %rsi     # 0x29746
movq %rsp, %rdi
movq %r14, %rdx
callq 0x11ba9
leaq 0x1b896(%rip), %rax     # 0x34a98
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0xbdc6
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19240
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19270
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x19270
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
jmp 0x1928f
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x19294
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18866(%rip), %rcx     # 0x374f8
movb $0x1, %al
cmpq %rdi, (%rcx)
je 0x1ed42
movq %rdi, %rbx
leaq 0x18859(%rip), %rcx     # 0x37500
xorl %eax, %eax
cmpq %rdi, (%rcx)
je 0x1ed42
leaq 0x18837(%rip), %rcx     # 0x374f0
cmpq %rbx, (%rcx)
je 0x1ed42
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x8(%r14), %rdx
cmpq 0x1947b(%rip), %rdx     # 0x38158
jne 0x1ed21
movq 0x8(%rsp), %r14
testq %rdx, %rdx
je 0x1ecfc
movq 0x19460(%rip), %rsi     # 0x38150
movq %r14, %rdi
callq 0x51d0
testl %eax, %eax
jne 0x1ed26
movl 0x8(%rbx), %ebx
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x1ed19
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x51c0
testl %ebx, %ebx
jne 0x1ed40
xorl %eax, %eax
jmp 0x1ed42
movq 0x8(%rsp), %r14
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x1ed40
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x51c0
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rsp)
addq $0x8, %r12
movq -0x8(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1ed4a
movq %rax, %r13
movq (%rax), %rax
movq %rsp, %rdi
movq %r13, %rsi
callq *(%rax)
movq 0x8(%rsp), %rdx
cmpq 0x1844b(%rip), %rdx     # 0x382d8
jne 0x1feae
movb $0x1, %r15b
movq (%rsp), %rbp
testq %rdx, %rdx
je 0x1ff16
movq 0x1842e(%rip), %rsi     # 0x382d0
movq %rbp, %rdi
callq 0x51d0
testl %eax, %eax
je 0x1ff16
movq (%r13), %rax
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq *(%rax)
movq 0x30(%rsp), %rdx
cmpq 0x18470(%rip), %rdx     # 0x38338
jne 0x1feeb
movq 0x28(%rsp), %rbp
testq %rdx, %rdx
je 0x1fef5
movq 0x18455(%rip), %rsi     # 0x38330
movq %rbp, %rdi
callq 0x51d0
testl %eax, %eax
sete %r15b
jmp 0x1fef8
movq 0x28(%rsp), %rbp
xorl %r15d, %r15d
jmp 0x1fef8
movb $0x1, %r15b
leaq 0x38(%rsp), %rax
cmpq %rax, %rbp
je 0x1ff12
movq 0x38(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x51c0
movq (%rsp), %rbp
leaq 0x10(%rsp), %rax
cmpq %rax, %rbp
je 0x1ff30
movq 0x10(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x51c0
testb %r15b, %r15b
jne 0x1ffb0
movq (%r13), %rax
movq %rsp, %rdi
movq %r13, %rsi
callq *(%rax)
movq 0x8(%rsp), %rdx
cmpq 0x183eb(%rip), %rdx     # 0x38338
jne 0x1ff6f
movq (%rsp), %rbp
testq %rdx, %rdx
je 0x1ff78
movq 0x183d1(%rip), %rsi     # 0x38330
movq %rbp, %rdi
callq 0x51d0
testl %eax, %eax
sete %r15b
jmp 0x1ff7b
movq (%rsp), %rbp
xorl %r15d, %r15d
jmp 0x1ff7b
movb $0x1, %r15b
leaq 0x10(%rsp), %rax
cmpq %rax, %rbp
je 0x1ff95
movq 0x10(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x51c0
cmpq 0x20(%rsp), %r12
sete %al
orb %al, %r15b
addq $0x8, %r12
cmpb $0x1, %r15b
jne 0x1fe63
jmp 0x1ffb4
movq 0x8(%r13), %r13
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1ffe4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
movq %rdx, (%rsp)
movq %rdi, %r14
movq 0x48(%rsi), %r12
movq 0x50(%rsi), %r13
addq $0x8, %r12
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %rbx
movq -0x8(%r12), %rsi
movq %r14, %rdi
movq (%rsp), %rdx
callq 0x1ed4a
movq %rax, %rbp
movq (%rax), %rax
movq %r15, %rdi
movq %rbp, %rsi
callq *(%rax)
movq %r15, %rdi
leaq 0x903c(%rip), %rsi      # 0x2907c
callq 0x50a0
testl %eax, %eax
je 0x20087
movq (%rbp), %rax
movq %rbx, %rdi
movq %rbp, %rsi
callq *(%rax)
movq %rbx, %rdi
leaq 0x9032(%rip), %rsi      # 0x29091
callq 0x50a0
testl %eax, %eax
sete %bl
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x20089
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x20089
movb $0x1, %bl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x200a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
cmpq %r13, %r12
sete %al
orb %al, %bl
addq $0x8, %r12
testb %bl, %bl
leaq 0x28(%rsp), %rbx
je 0x20017
movq %rbp, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x200ef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ed4a
movq %rax, %rdi
callq 0x1ec84
testb %al, %al
je 0x20e87
movq 0x50(%r15), %rsi
jmp 0x20e90
movq 0x58(%r15), %rsi
testq %rsi, %rsi
je 0x20ea0
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1ed4a
leaq 0x16649(%rip), %rax     # 0x374f0
movq (%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x48(%rsi), %rsi
movq 0x50(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xbdc6
movq %r14, %rdi
movq %r15, %rsi
callq 0x19168
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x20f08
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%r14), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *(%rax)
movq 0x8(%r15), %rdx
cmpq 0x17415(%rip), %rdx     # 0x38338
jne 0x20f42
movq 0x8(%rsp), %r15
testq %rdx, %rdx
je 0x20f8c
movq 0x173fa(%rip), %rsi     # 0x38330
movq %r15, %rdi
callq 0x51d0
testl %eax, %eax
je 0x20f8c
addq $0x48, %rbx
leaq 0x17403(%rip), %rdi     # 0x38350
movq %rbx, %rsi
callq 0x2852a
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20f73
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
testq %r15, %r15
je 0x20fa6
leaq 0x173d1(%rip), %rdi     # 0x38350
movq %rbx, %rsi
callq 0x28564
movq (%rax), %r14
jmp 0x20fa6
leaq 0x18(%rsp), %rax
cmpq %rax, %r15
je 0x20fa6
movq 0x18(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x51c0
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20fe7
movq 0x18(%rsp), %rsi
jmp 0x20fdf
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x20fe7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movq %rdi, %r15
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x12bd3(%rip), %rax     # 0x34c90
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x25eda
movq 0x48(%r13), %r12
movq 0x50(%r13), %r13
cmpq %r13, %r12
je 0x221cf
movq (%r12), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x1ed4a
movq %rax, (%rsp)
movq (%rax), %rcx
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x20(%rsp), %rdx
cmpq 0x16212(%rip), %rdx     # 0x38338
jne 0x22149
movq 0x18(%rsp), %rbp
testq %rdx, %rdx
je 0x22153
movq 0x161f7(%rip), %rsi     # 0x38330
movq %rbp, %rdi
callq 0x51d0
testl %eax, %eax
sete %r14b
jmp 0x22156
movq 0x18(%rsp), %rbp
xorl %r14d, %r14d
jmp 0x22156
movb $0x1, %r14b
leaq 0x28(%rsp), %rax
cmpq %rax, %rbp
je 0x22170
movq 0x28(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x51c0
testb %r14b, %r14b
jne 0x221aa
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x22194
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x38(%rbx)
jmp 0x221a1
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x28a20
addq $0x8, %r12
jmp 0x220ef
leaq 0x12adf(%rip), %rax     # 0x34c90
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
callq 0x2606c
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movq %rdi, %r15
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x12aa1(%rip), %rax     # 0x34cc8
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x25eda
movq 0x48(%r13), %r12
movq 0x50(%r13), %r13
cmpq %r13, %r12
je 0x22339
movq (%r12), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x1ed4a
movq %rax, (%rsp)
movq (%rax), %rcx
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x20(%rsp), %rdx
cmpq 0x160a8(%rip), %rdx     # 0x38338
jne 0x222b3
movq 0x18(%rsp), %rbp
testq %rdx, %rdx
je 0x222bd
movq 0x1608d(%rip), %rsi     # 0x38330
movq %rbp, %rdi
callq 0x51d0
testl %eax, %eax
sete %r14b
jmp 0x222c0
movq 0x18(%rsp), %rbp
xorl %r14d, %r14d
jmp 0x222c0
movb $0x1, %r14b
leaq 0x28(%rsp), %rax
cmpq %rax, %rbp
je 0x222da
movq 0x28(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x51c0
testb %r14b, %r14b
jne 0x22314
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x222fe
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x38(%rbx)
jmp 0x2230b
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x28a20
addq $0x8, %r12
jmp 0x22259
leaq 0x129ad(%rip), %rax     # 0x34cc8
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
callq 0x2606c
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movq %rdi, %r15
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x1296f(%rip), %rax     # 0x34d00
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x25eda
movq 0x48(%r13), %r12
movq 0x50(%r13), %r13
cmpq %r13, %r12
je 0x224a3
movq (%r12), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x1ed4a
movq %rax, (%rsp)
movq (%rax), %rcx
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x20(%rsp), %rdx
cmpq 0x15f3e(%rip), %rdx     # 0x38338
jne 0x2241d
movq 0x18(%rsp), %rbp
testq %rdx, %rdx
je 0x22427
movq 0x15f23(%rip), %rsi     # 0x38330
movq %rbp, %rdi
callq 0x51d0
testl %eax, %eax
sete %r14b
jmp 0x2242a
movq 0x18(%rsp), %rbp
xorl %r14d, %r14d
jmp 0x2242a
movb $0x1, %r14b
leaq 0x28(%rsp), %rax
cmpq %rax, %rbp
je 0x22444
movq 0x28(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x51c0
testb %r14b, %r14b
jne 0x2247e
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x22468
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x38(%rbx)
jmp 0x22475
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x28a20
addq $0x8, %r12
jmp 0x223c3
leaq 0x1287b(%rip), %rax     # 0x34d00
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
callq 0x2606c
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x68, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %r12
movq %rdi, %r15
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x48(%r12), %rsi
movq 0x50(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xbdc6
leaq 0x1281d(%rip), %rax     # 0x34d38
movq %rax, (%rbx)
leaq 0x8(%rbx), %rbp
leaq 0x18(%rbx), %r14
movq %r14, 0x8(%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0xbdc6
movq %rbp, 0x10(%rsp)
movq %r14, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %rbx, (%rsp)
movq $0x0, 0x38(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x22573
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x68(%r12), %rbp
movq 0x70(%r12), %r12
cmpq %r12, %rbp
je 0x22626
movq (%rsp), %r13
addq $0x28, %r13
movq (%rbp), %rsi
movq %r15, %rdi
movq 0x20(%rsp), %rdx
callq 0x1ed4a
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x50(%rsp), %rdx
cmpq 0x15d7b(%rip), %rdx     # 0x38338
jne 0x225e0
movq 0x48(%rsp), %rbx
testq %rdx, %rdx
je 0x225ea
movq 0x15d60(%rip), %rsi     # 0x38330
movq %rbx, %rdi
callq 0x51d0
testl %eax, %eax
sete %r14b
jmp 0x225ed
movq 0x48(%rsp), %rbx
xorl %r14d, %r14d
jmp 0x225ed
movb $0x1, %r14b
leaq 0x58(%rsp), %rax
cmpq %rax, %rbx
je 0x22607
movq 0x58(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x51c0
testb %r14b, %r14b
jne 0x2262c
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
callq 0x240d2
addq $0x8, %rbp
cmpq %r12, %rbp
jne 0x2258e
movq (%rsp), %rax
jmp 0x2267e
movq (%rsp), %rbx
leaq 0x12701(%rip), %rax     # 0x34d38
movq %rax, (%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2264f
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x51c0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2266c
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movl $0x48, %esi
movq %rbx, %rdi
callq 0x51c0
movq 0x8(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x226b2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x226b2
movq %rbx, %r14
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x68, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %r12
movq %rdi, %r15
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x48(%r12), %rsi
movq 0x50(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xbdc6
leaq 0x1265b(%rip), %rax     # 0x34d70
movq %rax, (%rbx)
leaq 0x8(%rbx), %rbp
leaq 0x18(%rbx), %r14
movq %r14, 0x8(%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0xbdc6
movq %rbp, 0x10(%rsp)
movq %r14, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %rbx, (%rsp)
movq $0x0, 0x38(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2276d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x68(%r12), %rbp
movq 0x70(%r12), %r12
cmpq %r12, %rbp
je 0x22820
movq (%rsp), %r13
addq $0x28, %r13
movq (%rbp), %rsi
movq %r15, %rdi
movq 0x20(%rsp), %rdx
callq 0x1ed4a
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x50(%rsp), %rdx
cmpq 0x15b81(%rip), %rdx     # 0x38338
jne 0x227da
movq 0x48(%rsp), %rbx
testq %rdx, %rdx
je 0x227e4
movq 0x15b66(%rip), %rsi     # 0x38330
movq %rbx, %rdi
callq 0x51d0
testl %eax, %eax
sete %r14b
jmp 0x227e7
movq 0x48(%rsp), %rbx
xorl %r14d, %r14d
jmp 0x227e7
movb $0x1, %r14b
leaq 0x58(%rsp), %rax
cmpq %rax, %rbx
je 0x22801
movq 0x58(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x51c0
testb %r14b, %r14b
jne 0x22826
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
callq 0x24170
addq $0x8, %rbp
cmpq %r12, %rbp
jne 0x22788
movq (%rsp), %rax
jmp 0x22878
movq (%rsp), %rbx
leaq 0x1253f(%rip), %rax     # 0x34d70
movq %rax, (%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x22849
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x51c0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x22866
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movl $0x48, %esi
movq %rbx, %rdi
callq 0x51c0
movq 0x8(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x228ac
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x228ac
movq %rbx, %r14
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14c23(%rip), %r15     # 0x374f8
movq (%r15), %rax
leaq 0x14c21(%rip), %r12     # 0x37500
movq (%r12), %rcx
cmpq %rsi, %rax
je 0x2293b
movq %rsi, %rbx
cmpq %rsi, %rcx
je 0x22974
leaq 0x14bf5(%rip), %rcx     # 0x374f0
cmpq %rbx, (%rcx)
je 0x22974
movq (%rbx), %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x8(%r14), %rdx
cmpq 0x1583f(%rip), %rdx     # 0x38158
jne 0x22940
movq (%rsp), %r14
testq %rdx, %rdx
je 0x22948
movq 0x15825(%rip), %rsi     # 0x38150
movq %r14, %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x2294b
movq %rcx, %rax
jmp 0x22974
movq (%rsp), %r14
xorl %ebp, %ebp
jmp 0x2294b
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
cmpq %rax, %r14
je 0x22965
movq 0x10(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x51c0
testb %bpl, %bpl
je 0x22970
cmpl $0x0, 0x8(%rbx)
je 0x22981
movq (%r12), %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rax
jmp 0x22974
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq (%rsi), %rax
movq %rsp, %rbx
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rdx
cmpq 0x157ad(%rip), %rdx     # 0x38158
jne 0x229cd
movq (%rsp), %rbx
testq %rdx, %rdx
je 0x229d5
movq 0x15793(%rip), %rsi     # 0x38150
movq %rbx, %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x229d8
movq (%rsp), %rbx
xorl %ebp, %ebp
jmp 0x229d8
movb $0x1, %bpl
leaq 0x10(%rsp), %r15
cmpq %r15, %rbx
je 0x229f2
movq 0x10(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x51c0
testb %bpl, %bpl
je 0x22a1c
movl $0x10, %edi
callq 0x51b0
xorl %ecx, %ecx
subl 0x8(%r14), %ecx
movq %rax, %rbx
leaq 0x120bf(%rip), %rax     # 0x34ad0
movq %rax, (%rbx)
movl %ecx, 0x8(%rbx)
jmp 0x22b53
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x70e0(%rip), %rcx      # 0x29b1d
leaq 0x40(%rsp), %rdi
movl $0x1d, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x51f0
movq %r15, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x22a72
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x22a79
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70a1(%rip), %rsi      # 0x29b3b
callq 0x5360
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x22ac7
movq %rsi, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x22ad2
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x11fa7(%rip), %rax     # 0x34a98
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
addq %rsi, %rdx
callq 0xbdc6
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x22b22
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x22b38
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22b53
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x22b82
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x22b82
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x22b9d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x22b9d
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22bbd
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x22bbd
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
callq 0x1912e
movq %rax, %r15
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x237b4
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %rax
movq %r13, 0x8(%rsp)
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xbdc6
movq (%rbx), %rax
movq (%rax,%rbp,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1929c
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x237a1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
incq %rbp
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %rbp, %rax
ja 0x23758
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x237e0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movslq 0x8(%rdx), %r12
addq $0x8, %rsi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x2451e
movq (%rbx), %r15
movq 0x8(%rbx), %rax
subq %r15, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x23af7
movq (%r15,%r12,8), %rbx
jmp 0x23c3e
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x60c8(%rip), %rcx      # 0x29be1
leaq 0x58(%rsp), %rdi
movl $0xd, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x51f0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x23b53
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x23b5a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x5a30(%rip), %rsi      # 0x295ab
callq 0x5360
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x23ba8
movq %rsi, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x23bb3
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10ec6(%rip), %rax     # 0x34a98
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
addq %rsi, %rdx
callq 0xbdc6
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x23c03
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x23c19
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23c34
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x40(%rsp), %r15
testq %r15, %r15
je 0x23c4e
movq 0x50(%rsp), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x51c0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x23c7c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23c7c
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x23c97
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23c97
movq %rax, %r14
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23cb7
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23cb7
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x51c0
movq 0x40(%rsp), %r15
jmp 0x23cce
movq %rax, %r14
testq %r15, %r15
je 0x23ce3
movq 0x50(%rsp), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rax
leaq 0x60(%rsp), %rdi
movq %rdx, %rsi
callq *(%rax)
movq (%r14), %rax
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2432c
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23d4b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23d66
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %rbx
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x27ec0
testq %rax, %rax
je 0x23d98
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x286a0
movq 0x8(%rax), %rbx
jmp 0x23e68
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x5e35(%rip), %rcx      # 0x29bef
leaq 0x20(%rsp), %rdi
movl $0x1a, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x51f0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x23df4
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x23dfe
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10c7b(%rip), %rax     # 0x34a98
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
addq %rsi, %rdx
callq 0xbdc6
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x23e4d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23e68
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23e89
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23eaa
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x23ed8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23ed8
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23ef8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23ef8
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x51c0
jmp 0x23f0c
jmp 0x23f09
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x2443c
jmp 0x23f59
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23f3e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23f3e
movq %rax, %r14
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23f59
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x3c2b(%rip), %rsi      # 0x2918c
leaq 0x3c25(%rip), %rdx      # 0x2918d
callq 0xbe5c
movq 0x8(%r14), %r13
movq 0x10(%r14), %rbp
cmpq %rbp, %r13
je 0x2565f
movq %r14, 0x30(%rsp)
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x3c21(%rip), %r12      # 0x291b5
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x255cf
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x255d6
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x25617
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x25633
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x25594
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0x2565f
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25680
movq %rax, %r15
jmp 0x256c0
movq %rax, %r15
jmp 0x256a4
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x256a4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x256c0
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x256da
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x366d(%rip), %rsi      # 0x291bc
leaq 0x3671(%rip), %rdx      # 0x291c7
callq 0xbe5c
movq %r14, 0x28(%rsp)
movq 0x18(%r14), %rbp
testq %rbp, %rbp
je 0x25c7d
leaq 0x18(%rsp), %r14
leaq 0x50(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x3632(%rip), %r13      # 0x291b5
leaq 0x8(%rbp), %rsi
movq %r15, %rdi
callq 0x24cc8
movq 0x90(%rsp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5360
movq %r14, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x25bce
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x25bd5
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x25c16
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x25c32
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x25c54
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x25c70
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0x25b83
movq 0x28(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x25c99
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25cbd
movq %rax, %r15
jmp 0x25d0c
movq %rax, %r15
jmp 0x25d02
movq %rax, %r15
jmp 0x25ce6
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x25ce6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x25d02
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x50(%rsp), %rdi
callq 0x24406
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x25d24
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Stack::inspect[abi:cxx11]()
std::string inspect()
	{
		if (elements.empty())
			return "stack<> {top: empty}";

		std::string res = "stack<> {top: " + elements.top()->inspect() + "}";

		return res;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x38(%rsi), %rax
cmpq 0x18(%rsi), %rax
je 0x25dcb
cmpq 0x40(%rsi), %rax
jne 0x25d79
movq 0x50(%rsi), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x3eaa(%rip), %rcx      # 0x29c3c
movl $0xe, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x51f0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x25ded
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x25df4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3e4e(%rip), %rsi      # 0x29c27
leaq 0x3e5b(%rip), %rdx      # 0x29c3b
movq %rbx, %rdi
callq 0xbe5c
jmp 0x25e8d
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x3e0e(%rip), %rsi      # 0x29c25
callq 0x5360
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x25e3e
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x25e44
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x25e72
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25e8d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x25eb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x25eb7
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25ed2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330