LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseDequeLiteral()
Expression *Parser::parseDequeLiteral()
{
	DequeLiteral *exp = new DequeLiteral();
	exp->token = curToken;

	if (!expectPeek(LT))
	{
		delete exp;
		return nullptr;
	}

	if (!expectPeek(GT))
	{
		delete exp;
		return nullptr;
	}

	if (!expectPeek(LBRACE))
	{
		delete exp;
		return nullptr;
	}

	while (peekToken.type != RBRACE)
	{
		nextToken();

		Expression *value = parseExpression(LOWEST);

		exp->elements.push_back(value);

		if (peekToken.type != RBRACE && !expectPeek(COMMA))
			return nullptr;
	}

	if (!expectPeek(RBRACE))
	{
		delete exp;
		return nullptr;
	}

	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1f99c(%rip), %rax     # 0x34728
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movq %rax, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x21c51(%rip), %rsi     # 0x36a30
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14ee2
leaq 0x21c5a(%rip), %rsi     # 0x36a50
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14ee2
leaq 0x21d83(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14ee2
movq %rbx, %r15
addq $0x48, %r15
leaq 0x8(%rsp), %r12
leaq 0x21cc0(%rip), %r13     # 0x36af0
movq 0x78(%r14), %rdx
cmpq 0x21d7d(%rip), %rdx     # 0x36bb8
jne 0x14e5a
testq %rdx, %rdx
je 0x14ecf
movq 0x21d63(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x14ecf
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x8(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x14e85
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x14e90
movq %r15, %rdi
movq %r12, %rdx
callq 0x19120
movq 0x78(%r14), %rdx
cmpq 0x21d1d(%rip), %rdx     # 0x36bb8
jne 0x14eba
testq %rdx, %rdx
je 0x14e30
movq 0x21d07(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x14e30
movq %r14, %rdi
movq %r13, %rsi
callq 0x1629e
testb %al, %al
jne 0x14e30
jmp 0x14eeb
leaq 0x21cda(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x1629e
testb %al, %al
jne 0x14eed
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseGroupedExpression()
Expression *Parser::parseGroupedExpression()
{
	nextToken(); // pass "("

	Expression *exp = parseExpression(LOWEST);

	if (!expectPeek(RPAREN))
	{
		delete exp;
		return nullptr;
	}

	return exp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, %rbx
leaq 0x2162e(%rip), %rsi     # 0x36b70
movq %r14, %rdi
callq 0x1629e
testb %al, %al
jne 0x1555e
testq %rbx, %rbx
je 0x1555c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseArrayLiteral()
Expression *Parser::parseArrayLiteral()
{
	ArrayLiteral *exp = new ArrayLiteral();
	exp->token = curToken;

	if (peekToken.type == RBRACKET)
	{
		nextToken();
		return exp;
	}

	exp->elements = parseExpressionList();

	if (!expectPeek(RBRACKET))
	{
		delete exp;
		return nullptr;
	}

	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1eb4a(%rip), %rax     # 0x340f0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movq %rax, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
movq 0x78(%r14), %rdx
cmpq 0x215fb(%rip), %rdx     # 0x36bf8
jne 0x15618
testq %rdx, %rdx
je 0x1566e
movq 0x215e5(%rip), %rsi     # 0x36bf0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x1566e
movq %rbx, %r15
addq $0x48, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x16ed8
movq %r15, %rdi
movq %r12, %rsi
callq 0x18e34
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1564e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x51c0
leaq 0x2159b(%rip), %rsi     # 0x36bf0
movq %r14, %rdi
callq 0x1629e
testb %al, %al
jne 0x15676
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
jmp 0x15676
movq %r14, %rdi
callq 0x13d4c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseHashMapLiteral()
Expression *Parser::parseHashMapLiteral()
{
	HashMapLiteral *exp = new HashMapLiteral();
	exp->token = curToken;

	while (peekToken.type != RBRACE)
	{
		nextToken();

		Expression *key = parseExpression(LOWEST);

		if (!expectPeek(COLON))
		{
			delete exp;
			return nullptr;
		}

		nextToken();

		Expression *value = parseExpression(LOWEST);

		exp->pairs.push_back({key, value});

		if (peekToken.type != RBRACE && !expectPeek(COMMA))
			return nullptr;
	}

	if (!expectPeek(RBRACE))
		return nullptr;

	return exp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1eee3(%rip), %rax     # 0x345a8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
movb %r15b, 0x18(%rbx)
leaq 0x28(%rbx), %r13
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq %r15, 0x30(%rbx)
movb %r15b, 0x38(%rbx)
leaq 0x48(%rbx), %r12
movq %r15, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r13, %rdi
callq 0x5100
leaq 0x21411(%rip), %r13     # 0x36b30
movq 0x78(%r14), %rdx
cmpq 0x2148e(%rip), %rdx     # 0x36bb8
jne 0x1574d
testq %rdx, %rdx
je 0x157fe
movq 0x21474(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x157fe
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0x1629e
testb %al, %al
je 0x15818
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rbp, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x157aa
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x50(%rbx)
jmp 0x157b7
movq %r12, %rdi
leaq 0x8(%rsp), %rdx
callq 0x18fe0
movq 0x78(%r14), %rdx
cmpq 0x213f6(%rip), %rdx     # 0x36bb8
jne 0x157e5
testq %rdx, %rdx
je 0x1571f
movq 0x213dc(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x1571f
movq %r14, %rdi
leaq 0x21301(%rip), %rsi     # 0x36af0
callq 0x1629e
testb %al, %al
jne 0x1571f
jmp 0x15824
leaq 0x213ab(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x1629e
xorl %r15d, %r15d
testb %al, %al
cmovneq %rbx, %r15
jmp 0x15824
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseInfixExpression(Expression*)
Expression *Parser::parseInfixExpression(Expression *left)
{
	InfixExpression *exp = new InfixExpression();
	exp->token = curToken;
	exp->operand = curToken.literal;
	exp->left = left;

	Precedence precedence = curPrecedence();

	nextToken();

	exp->right = parseExpression(precedence);

	return exp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x78, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x40(%rax)
xorl %eax, %eax
movq %rax, 0x70(%rbx)
leaq 0x50(%rbx), %r12
leaq 0x60(%rbx), %rcx
leaq 0x1ea89(%rip), %rdx     # 0x34310
addq $0x10, %rdx
movq %rdx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rdx
movq %rdx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r13
leaq 0x38(%rbx), %rdx
movq %rdx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movq %rcx, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movb %al, 0x60(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5100
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5100
movq %r15, 0x48(%rbx)
movq %r14, %rdi
callq 0x16aa0
movl %eax, %ebp
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
movl %ebp, %esi
callq 0x162f0
movq %rax, 0x70(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseCallExpression(Expression*)
Expression *Parser::parseCallExpression(Expression *function)
{
	CallExpression *exp = new CallExpression();
	exp->token = curToken;
	exp->function = function;

	if (peekToken.type == RPAREN)
	{
		nextToken();
		return exp;
	}

	exp->arguments = parseExpressionList();

	if (!expectPeek(RPAREN))
		exp->arguments = std::vector<Expression *>();

	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %r15
movl $0x68, %edi
callq 0x51b0
movq %rax, %r14
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
xorl %eax, %eax
movq %rax, 0x60(%r14)
leaq 0x1eb86(%rip), %rcx     # 0x344e8
addq $0x10, %rcx
movq %rcx, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x10(%r14)
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r13
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movq %rax, 0x30(%r14)
movb %al, 0x38(%r14)
leaq 0x30(%r15), %rsi
callq 0x5100
leaq 0x50(%r15), %rsi
movq %r13, %rdi
callq 0x5100
movq %r12, 0x48(%r14)
movq 0x78(%r15), %rdx
cmpq 0x211c3(%rip), %rdx     # 0x36b78
jne 0x159d4
testq %rdx, %rdx
je 0x15a4e
movq 0x211a9(%rip), %rsi     # 0x36b70
movq 0x70(%r15), %rdi
callq 0x51d0
testl %eax, %eax
je 0x15a4e
addq $0x50, %r14
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x16ed8
movq %r14, %rdi
movq %r12, %rsi
callq 0x18e34
movq (%r12), %rdi
testq %rdi, %rdi
je 0x15a07
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x51c0
leaq 0x21162(%rip), %rsi     # 0x36b70
movq %r15, %rdi
callq 0x1629e
testb %al, %al
jne 0x15a56
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x18e34
movq (%r15), %rdi
testq %rdi, %rdi
je 0x15a56
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x51c0
jmp 0x15a56
movq %r15, %rdi
callq 0x13d4c
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseIndexExpression(Expression*)
Expression *Parser::parseIndexExpression(Expression *array)
{
	IndexExpression *exp = new IndexExpression();
	exp->token = curToken;
	exp->array = array;

	nextToken();

	exp->index = parseExpression(LOWEST);

	if (!expectPeek(RBRACKET))
	{
		delete exp;
		return nullptr;
	}

	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
xorl %eax, %eax
movq %rax, 0x50(%rbx)
leaq 0x1eaa2(%rip), %rcx     # 0x34548
addq $0x10, %rcx
movq %rcx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r12, %rdi
callq 0x5100
movq %r15, 0x48(%rbx)
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x50(%rbx)
leaq 0x210e7(%rip), %rsi     # 0x36bf0
movq %r14, %rdi
callq 0x1629e
testb %al, %al
jne 0x15b20
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::ParseProgram()
Program *Parser::ParseProgram()
{
	Program *program = new Program();

	while (curToken.type != END)
	{
		Statement *stmt = parseStatement();

		if (stmt != nullptr)
			program->statements.push_back(stmt);

		nextToken();
	}

	return program;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %edi
callq 0x51b0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
leaq 0x1e547(%rip), %rax     # 0x340a0
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %r15
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq %rsp, %r12
movq 0x38(%rbx), %rdx
cmpq 0x20d59(%rip), %rdx     # 0x368d8
jne 0x15b9a
testq %rdx, %rdx
je 0x15bd4
movq 0x20d43(%rip), %rsi     # 0x368d0
movq 0x30(%rbx), %rdi
callq 0x51d0
testl %eax, %eax
je 0x15bd4
movq %rbx, %rdi
callq 0x15be4
movq %rax, (%rsp)
testq %rax, %rax
je 0x15bca
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x15bbf
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x15bca
movq %r15, %rdi
movq %r12, %rdx
callq 0x18464
movq %rbx, %rdi
callq 0x13d4c
jmp 0x15b74
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseStatement()
Statement *Parser::parseStatement()
{
	TokenType curTokenType = curToken.type;

	// switch takes only int or enum val, so used if
	if (curTokenType == LET)
		return parseLetStatement();

	else if (curTokenType == IDENT)
	{
		Statement *stmt = parseAssignStatement();

		if (stmt == nullptr)
			return parseExpressionStatement();

		return stmt;
	}

	else if (curTokenType == RETURN)
		return parseReturnStatement();

	else
		return parseExpressionStatement();

	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x30(%rdi), %rsi
movq 0x38(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0xbde8
movq 0x8(%r14), %r14
cmpq 0x2103e(%rip), %r14     # 0x36c58
jne 0x15c38
testq %r14, %r14
je 0x15c8c
movq 0x21028(%rip), %rsi     # 0x36c50
movq (%rsp), %rdi
movq %r14, %rdx
callq 0x51d0
testl %eax, %eax
je 0x15c8c
cmpq 0x20cb9(%rip), %r14     # 0x368f8
jne 0x15c5d
testq %r14, %r14
je 0x15c96
movq 0x20ca3(%rip), %rsi     # 0x368f0
movq (%rsp), %rdi
movq %r14, %rdx
callq 0x51d0
testl %eax, %eax
je 0x15c96
cmpq 0x21094(%rip), %r14     # 0x36cf8
jne 0x15c82
testq %r14, %r14
je 0x15cb0
movq 0x2107e(%rip), %rsi     # 0x36cf0
movq (%rsp), %rdi
movq %r14, %rdx
callq 0x51d0
testl %eax, %eax
je 0x15cb0
movq %rbx, %rdi
callq 0x1611a
jmp 0x15cb8
movq %rbx, %rdi
callq 0x15d02
jmp 0x15cb8
movq %rbx, %rdi
callq 0x15e84
movq %rax, %r14
testq %rax, %rax
jne 0x15cbb
movq %rbx, %rdi
callq 0x1611a
jmp 0x15cb8
movq %rbx, %rdi
callq 0x161d8
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x15cd1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x15ce0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x15cf9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseLetStatement()
LetStatement *Parser::parseLetStatement()
{
	LetStatement *stmt = new LetStatement();
	stmt->token = curToken;

	if (!expectPeek(IDENT))
	{
		delete stmt;
		return nullptr;
	}

	stmt->name.token = curToken;
	stmt->name.value = curToken.literal;

	if (!expectPeek(ASSIGN))
		return nullptr;

	nextToken();

	stmt->value = parseExpression(LOWEST);

	if (peekToken.type == SEMICOLON)
		nextToken();

	return stmt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0xb8, %edi
callq 0x51b0
movq %rax, %rbx
xorl %r15d, %r15d
movl $0xb8, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x5110
leaq 0x1e41c(%rip), %rax     # 0x34150
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movb %r15b, 0x18(%rbx)
leaq 0x28(%rbx), %r13
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq %r15, 0x30(%rbx)
movb %r15b, 0x38(%rbx)
leaq 0x1eb2e(%rip), %rax     # 0x34898
movq %rax, 0x48(%rbx)
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq %r15, 0x58(%rbx)
movb %r15b, 0x60(%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x70(%rbx)
movq %r15, 0x78(%rbx)
movb %r15b, 0x80(%rbx)
leaq 0xa0(%rbx), %rax
movq %rax, 0x90(%rbx)
movq %r15, 0x98(%rbx)
movb %r15b, 0xa0(%rbx)
leaq 0x30(%r14), %r12
movq %r12, %rsi
callq 0x5100
leaq 0x50(%r14), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x5100
leaq 0x20b1e(%rip), %rsi     # 0x368f0
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x15e6b
leaq 0x50(%rbx), %rdi
leaq 0x90(%rbx), %r13
movq %r12, %rsi
callq 0x5100
movq %rbx, %rdi
addq $0x70, %rdi
movq %r15, %rsi
callq 0x5100
movq %r13, %rdi
movq %r15, %rsi
callq 0x5100
leaq 0x20b3a(%rip), %rsi     # 0x36950
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x15e74
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0xb0(%rbx)
movq 0x78(%r14), %rdx
cmpq 0x20cd2(%rip), %rdx     # 0x36b18
jne 0x15e76
testq %rdx, %rdx
je 0x15e61
movq 0x20cbc(%rip), %rsi     # 0x36b10
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x15e76
movq %r14, %rdi
callq 0x13d4c
jmp 0x15e76
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseExpressionStatement()
ExpressionStatement *Parser::parseExpressionStatement()
{
	ExpressionStatement *stmt = new ExpressionStatement();
	stmt->token = curToken;
	stmt->expression = parseExpression(LOWEST);

	if (peekToken.type == SEMICOLON)
		nextToken();

	return stmt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x50, %edi
callq 0x51b0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1e10c(%rip), %rax     # 0x34258
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movq %rax, 0x30(%r14)
movb %al, 0x38(%r14)
leaq 0x30(%rbx), %rsi
callq 0x5100
leaq 0x50(%rbx), %rsi
movq %r15, %rdi
callq 0x5100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x48(%r14)
movq 0x78(%rbx), %rdx
cmpq 0x2096d(%rip), %rdx     # 0x36b18
jne 0x161ce
testq %rdx, %rdx
je 0x161c6
movq 0x20957(%rip), %rsi     # 0x36b10
movq 0x70(%rbx), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x161ce
movq %rbx, %rdi
callq 0x13d4c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseReturnStatement()
ReturnStatement *Parser::parseReturnStatement()
{
	ReturnStatement *stmt = new ReturnStatement();
	stmt->token = curToken;

	nextToken();

	stmt->returnValue = parseExpression(LOWEST);

	if (peekToken.type == SEMICOLON)
		nextToken();

	return stmt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x50, %edi
callq 0x51b0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1dff6(%rip), %rax     # 0x34200
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movq %rax, 0x30(%r14)
movb %al, 0x38(%r14)
leaq 0x30(%rbx), %rsi
callq 0x5100
leaq 0x50(%rbx), %rsi
movq %r15, %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x13d4c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x48(%r14)
movq 0x78(%rbx), %rdx
cmpq 0x208a7(%rip), %rdx     # 0x36b18
jne 0x16294
testq %rdx, %rdx
je 0x1628c
movq 0x20891(%rip), %rsi     # 0x36b10
movq 0x70(%rbx), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x16294
movq %rbx, %rdi
callq 0x13d4c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::expectPeek(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Parser::expectPeek(const TokenType &tokenType)
{
	if (peekToken.type == tokenType)
	{
		nextToken();
		return true;
	}
	else
	{
		peekError(tokenType);
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x162cb
testq %rdx, %rdx
je 0x162cf
movq (%r14), %rsi
movq 0x70(%rbx), %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x162d2
xorl %ebp, %ebp
jmp 0x162d2
movb $0x1, %bpl
movq %rbx, %rdi
testb %bpl, %bpl
je 0x162e1
callq 0x13d4c
jmp 0x162e9
movq %r14, %rsi
callq 0x1647a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movl %esi, 0x14(%rsp)
movq %rdi, %rbx
leaq 0x100(%rdi), %r14
leaq 0x30(%rdi), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x18ac4
testq %rax, %rax
je 0x163f7
movq %r14, %rdi
movq %r15, %rsi
callq 0x17c60
movq (%rax), %rcx
movq 0x8(%rax), %rdi
addq %rbx, %rdi
testb $0x1, %cl
je 0x16346
movq (%rdi), %rax
movq -0x1(%rax,%rcx), %rcx
callq *%rcx
movq %rax, %r15
leaq 0x138(%rbx), %r12
leaq 0x70(%rbx), %r13
movq 0x78(%rbx), %rdx
cmpq 0x207b7(%rip), %rdx     # 0x36b18
jne 0x16380
testq %rdx, %rdx
je 0x163f0
movq 0x2079d(%rip), %rsi     # 0x36b10
movq (%r13), %rdi
callq 0x51d0
testl %eax, %eax
je 0x163f0
movq %rbx, %rdi
callq 0x16a64
cmpl 0x14(%rsp), %eax
jle 0x163f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x18afe
testq %rax, %rax
je 0x163f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x18062
movq (%rax), %rbp
testq %rbp, %rbp
je 0x163cb
movq 0x8(%rax), %r14
addq %rbx, %r14
movq %rbx, %rdi
callq 0x13d4c
testb $0x1, %bpl
jne 0x163d2
movq %rbp, %rax
jmp 0x163da
movq %r15, 0x8(%rsp)
jmp 0x163e5
movq (%r14), %rax
movq -0x1(%rax,%rbp), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *%rax
movq %rax, %r15
testq %rbp, %rbp
jne 0x16356
jmp 0x16443
movq %r15, 0x8(%rsp)
jmp 0x16443
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xbde8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1669c
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1643a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x51c0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x16471
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1d858(%rip), %rax     # 0x34370
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r13
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movq %rax, 0x30(%r14)
movb %al, 0x38(%r14)
leaq 0x48(%r14), %r15
movq %rax, 0x58(%r14)
movups %xmm0, 0x48(%r14)
leaq 0x30(%rbx), %r12
movq %r12, %rsi
callq 0x5100
leaq 0x50(%rbx), %rsi
movq %r13, %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x13d4c
movq %rsp, %r13
movq 0x38(%rbx), %rbp
cmpq 0x20034(%rip), %rbp     # 0x36bb8
jne 0x16ba2
testq %rbp, %rbp
je 0x16c04
movq 0x2001e(%rip), %rsi     # 0x36bb0
movq (%r12), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x16c04
cmpq 0x1fd2f(%rip), %rbp     # 0x368d8
jne 0x16bc7
testq %rbp, %rbp
je 0x16c04
movq 0x1fd19(%rip), %rsi     # 0x368d0
movq (%r12), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x16c04
movq %rbx, %rdi
callq 0x15be4
movq %rax, (%rsp)
testq %rax, %rax
je 0x16bf7
movq 0x50(%r14), %rsi
cmpq 0x58(%r14), %rsi
je 0x16bec
movq %rax, (%rsi)
addq $0x8, 0x50(%r14)
jmp 0x16bf7
movq %r15, %rdi
movq %r13, %rdx
callq 0x18464
movq %rbx, %rdi
callq 0x13d4c
jmp 0x16b79
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x18e74
movq 0x78(%r14), %rdx
cmpq 0x1fbd6(%rip), %rdx     # 0x36af8
jne 0x16f79
leaq 0x8(%rsp), %r15
testq %rdx, %rdx
je 0x16f42
movq 0x1fbbb(%rip), %rsi     # 0x36af0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x16f79
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18e74
movq 0x78(%r14), %rdx
cmpq 0x1fb81(%rip), %rdx     # 0x36af8
je 0x16f29
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x16f8c
jmp 0x16f8c
jmp 0x16f8c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x16fa3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x194ec
testq %rax, %rax
je 0x19352
movq %rbx, %rdi
movq %r14, %rsi
callq 0x195e8
movq (%rax), %rbx
jmp 0x193fe
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
je 0x1939a
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 0xbde8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19326
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x193fe
movq 0x30(%rsp), %rsi
jmp 0x193f6
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x10388(%rip), %rsi     # 0x29736
movq %rsp, %rdi
movq %r14, %rdx
callq 0x11b9f
leaq 0x1b6d8(%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 0xbde8
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x193fe
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 0x1942e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x1942e
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
jmp 0x1944d
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x19452
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18659(%rip), %rcx     # 0x374f8
movb $0x1, %al
cmpq %rdi, (%rcx)
je 0x1ef43
movq %rdi, %rbx
leaq 0x1864c(%rip), %rcx     # 0x37500
xorl %eax, %eax
cmpq %rdi, (%rcx)
je 0x1ef43
leaq 0x1862a(%rip), %rcx     # 0x374f0
cmpq %rbx, (%rcx)
je 0x1ef43
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x8(%r14), %rdx
cmpq 0x19272(%rip), %rdx     # 0x38158
jne 0x1ef02
testq %rdx, %rdx
je 0x1ef1f
movq 0x1925c(%rip), %rsi     # 0x38150
movq 0x8(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
je 0x1ef1f
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ef41
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x1ef41
movl 0x8(%rbx), %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ef3d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
testl %ebx, %ebx
je 0x1ef4b
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x1ef43
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x30(%rsp)
movq %rdi, %r14
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %rax
movq %rax, 0x28(%rsp)
movq (%r12), %rsi
movq %r14, %rdi
movq 0x30(%rsp), %rdx
callq 0x1ef50
movq %rax, %r13
movq (%rax), %rax
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq *(%rax)
movq 0x10(%rsp), %rdx
cmpq 0x18258(%rip), %rdx     # 0x382d8
jne 0x2009f
testq %rdx, %rdx
je 0x200a3
movq 0x18242(%rip), %rsi     # 0x382d0
movq 0x8(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %bl
jmp 0x200a5
xorl %ebx, %ebx
jmp 0x200a5
movb $0x1, %bl
movb $0x1, %bpl
testb %bl, %bl
jne 0x200e8
movq (%r13), %rax
leaq 0x38(%rsp), %rdi
movq %r13, %rsi
callq *(%rax)
movq 0x40(%rsp), %rdx
cmpq 0x18272(%rip), %rdx     # 0x38338
jne 0x200e6
testq %rdx, %rdx
je 0x200e8
movq 0x1825c(%rip), %rsi     # 0x38330
movq 0x38(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x200e8
xorl %ebp, %ebp
testb %bl, %bl
jne 0x20108
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x20108
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x20124
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %bpl, %bpl
je 0x20131
movq 0x8(%r13), %r15
xorl %eax, %eax
jmp 0x20196
movq (%r13), %rax
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq *(%rax)
movq 0x10(%rsp), %rdx
cmpq 0x181ed(%rip), %rdx     # 0x38338
jne 0x2016a
testq %rdx, %rdx
je 0x2016e
movq 0x181d7(%rip), %rsi     # 0x38330
movq 0x8(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %bl
jmp 0x20170
xorl %ebx, %ebx
jmp 0x20170
movb $0x1, %bl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2018c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movl %ebx, %eax
xorb $0x1, %al
testb %bl, %bl
cmovneq %r13, %r15
testb %al, %al
je 0x201ab
addq $0x8, %r12
cmpq 0x28(%rsp), %r12
jne 0x20053
jmp 0x201ae
movq %r15, %r13
movq %r13, %rax
addq $0x58, %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 0x201df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r13
movq 0x50(%rsi), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %r15
leaq 0x38(%rsp), %r14
movq (%r13), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x1ef50
movq %rax, %rbx
movq (%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
leaq 0x8e3b(%rip), %rsi      # 0x2907c
callq 0x50a0
movl %eax, %r12d
testl %eax, %eax
je 0x2026f
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %r14, %rdi
leaq 0x8e2f(%rip), %rsi      # 0x29091
callq 0x50a0
testl %eax, %eax
sete %r14b
jmp 0x20272
movb $0x1, %r14b
testl %r12d, %r12d
je 0x20293
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x20293
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x202af
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %r14b, %r14b
cmovneq %rbx, %rbp
jne 0x202cd
addq $0x8, %r13
cmpq (%rsp), %r13
leaq 0x38(%rsp), %r14
jne 0x20216
jmp 0x202d0
movq %rbp, %rbx
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x20301
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ef50
movq %rax, %rdi
callq 0x1ee91
testb %al, %al
je 0x210c3
movq 0x50(%r15), %rsi
jmp 0x210cc
movq 0x58(%r15), %rsi
testq %rsi, %rsi
je 0x210dc
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1ef50
leaq 0x1640d(%rip), %rax     # 0x374f0
movq (%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0x19326
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x21144
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 0x171d9(%rip), %rdx     # 0x38338
jne 0x2117b
testq %rdx, %rdx
je 0x211c5
movq 0x171c3(%rip), %rsi     # 0x38330
movq 0x8(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
je 0x211c5
addq $0x48, %rbx
leaq 0x171ca(%rip), %rdi     # 0x38350
movq %rbx, %rsi
callq 0x28848
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x211ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
testq %r15, %r15
je 0x211e0
leaq 0x17198(%rip), %rdi     # 0x38350
movq %rbx, %rsi
callq 0x28882
movq (%rax), %r14
jmp 0x211e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x211e0
movq 0x18(%rsp), %rsi
incq %rsi
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 0x21221
movq 0x18(%rsp), %rsi
jmp 0x21219
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x21221
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rsi, %r13
movq %rdi, %r15
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x50(%rax)
leaq 0x1290f(%rip), %rax     # 0x34c90
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x261f0
movq 0x48(%r13), %rbp
movq 0x50(%r13), %r13
cmpq %r13, %rbp
je 0x2249f
movq (%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x1ef50
movq %rax, (%rsp)
movq (%rax), %rcx
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x20(%rsp), %rdx
cmpq 0x15f53(%rip), %rdx     # 0x38338
jne 0x22405
testq %rdx, %rdx
je 0x2240a
movq 0x15f3d(%rip), %rsi     # 0x38330
movq 0x18(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %r12b
jmp 0x2240d
xorl %r12d, %r12d
jmp 0x2240d
movb $0x1, %r12b
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x22429
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %r12b, %r12b
je 0x2245a
leaq 0x1285b(%rip), %rax     # 0x34c90
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
callq 0x26382
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x22486
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x22479
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x38(%rbx)
jmp 0x22486
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x28d5c
testb %r12b, %r12b
jne 0x2249a
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0x223b9
jmp 0x2249f
movq 0x10(%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_O1/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, %r14
movq %rsi, %r13
movq %rdi, %r15
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x50(%rax)
leaq 0x127b5(%rip), %rax     # 0x34cc8
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x261f0
movq 0x48(%r13), %rbp
movq 0x50(%r13), %r13
cmpq %r13, %rbp
je 0x22631
movq (%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x1ef50
movq %rax, (%rsp)
movq (%rax), %rcx
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x20(%rsp), %rdx
cmpq 0x15dc1(%rip), %rdx     # 0x38338
jne 0x22597
testq %rdx, %rdx
je 0x2259c
movq 0x15dab(%rip), %rsi     # 0x38330
movq 0x18(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %r12b
jmp 0x2259f
xorl %r12d, %r12d
jmp 0x2259f
movb $0x1, %r12b
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x225bb
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %r12b, %r12b
je 0x225ec
leaq 0x12701(%rip), %rax     # 0x34cc8
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
callq 0x26382
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x22618
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x2260b
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x38(%rbx)
jmp 0x22618
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x28d5c
testb %r12b, %r12b
jne 0x2262c
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0x2254b
jmp 0x22631
movq 0x10(%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_O1/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, %r14
movq %rsi, %r13
movq %rdi, %r15
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x50(%rax)
leaq 0x1265b(%rip), %rax     # 0x34d00
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x261f0
movq 0x48(%r13), %rbp
movq 0x50(%r13), %r13
cmpq %r13, %rbp
je 0x227c3
movq (%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x1ef50
movq %rax, (%rsp)
movq (%rax), %rcx
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x20(%rsp), %rdx
cmpq 0x15c2f(%rip), %rdx     # 0x38338
jne 0x22729
testq %rdx, %rdx
je 0x2272e
movq 0x15c19(%rip), %rsi     # 0x38330
movq 0x18(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %r12b
jmp 0x22731
xorl %r12d, %r12d
jmp 0x22731
movb $0x1, %r12b
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2274d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %r12b, %r12b
je 0x2277e
leaq 0x125a7(%rip), %rax     # 0x34d00
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
callq 0x26382
movl $0x58, %esi
movq %rbx, %rdi
callq 0x51c0
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x227aa
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x2279d
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x38(%rbx)
jmp 0x227aa
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x28d5c
testb %r12b, %r12b
jne 0x227be
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0x226dd
jmp 0x227c3
movq 0x10(%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