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

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

	nextToken();

	exp->condition = parseExpression(LOWEST);

	if (!expectPeek(RPAREN))
		return nullptr;

	if (!expectPeek(LBRACE))
		return nullptr;

	exp->consequence = parseBlockStatement();

	return exp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x58, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x50(%rdi)
callq 0x236c0
jmp 0x1fcc1
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x40(%rbp), %rdi
leaq 0x45f37(%rip), %rsi     # 0x65c20
callq 0x21d00
testb $0x1, %al
jne 0x1fd36
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x1fd0a
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1fdad
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x52b0
jmp 0x1fdb7
movq -0x40(%rbp), %rdi
callq 0x1f390
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
leaq 0x45ee0(%rip), %rsi     # 0x65c40
callq 0x21d00
testb $0x1, %al
jne 0x1fd73
movq $0x0, -0x8(%rbp)
jmp 0x1fdad
movq -0x40(%rbp), %rdi
leaq 0x45ee2(%rip), %rsi     # 0x65c60
callq 0x21d00
testb $0x1, %al
jne 0x1fd91
movq $0x0, -0x8(%rbp)
jmp 0x1fdad
movq -0x40(%rbp), %rdi
callq 0x225c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
// File: pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseFunctionLiteral()
Expression *Parser::parseFunctionLiteral()
{
	FunctionLiteral *fn = new FunctionLiteral();
	fn->token = curToken;

	if (!expectPeek(LPAREN))
	{ // in this function, only deal with "("
		delete fn;
		return nullptr;
	}

	fn->parameters = parseFunctionParameters();

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

	fn->body = parseBlockStatement();
	return fn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x68, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x60(%rdi)
callq 0x23790
jmp 0x1fe15
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x58(%rbp), %rdi
leaq 0x45de3(%rip), %rsi     # 0x65c20
callq 0x21d00
testb $0x1, %al
jne 0x1fe8a
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x1fe5e
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1ff03
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x68, %esi
callq 0x52b0
jmp 0x1ff0d
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x226e0
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
leaq -0x40(%rbp), %rsi
callq 0x23800
leaq -0x40(%rbp), %rdi
callq 0x1e440
movq -0x58(%rbp), %rdi
leaq 0x45da4(%rip), %rsi     # 0x65c60
callq 0x21d00
testb $0x1, %al
jne 0x1fee7
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x1fedd
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1ff03
movq -0x58(%rbp), %rdi
callq 0x225c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseQueueLiteral()
Expression *Parser::parseQueueLiteral()
{
	QueueLiteral *exp = new QueueLiteral();
	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))
		return nullptr;

	return exp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x60, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x23d10
jmp 0x2038d
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x48(%rbp), %rdi
leaq 0x4574b(%rip), %rsi     # 0x65b00
callq 0x21d00
testb $0x1, %al
jne 0x20402
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x203d6
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x20519
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x52b0
jmp 0x20523
movq -0x48(%rbp), %rdi
leaq 0x45713(%rip), %rsi     # 0x65b20
callq 0x21d00
testb $0x1, %al
jne 0x2043b
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x2042e
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x20519
movq -0x48(%rbp), %rdi
leaq 0x4581a(%rip), %rsi     # 0x65c60
callq 0x21d00
testb $0x1, %al
jne 0x20474
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x20467
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x20519
jmp 0x20476
movq -0x48(%rbp), %rdi
addq $0x70, %rdi
leaq 0x457fb(%rip), %rsi     # 0x65c80
callq 0x22d80
testb $0x1, %al
jne 0x20490
jmp 0x204f3
movq -0x48(%rbp), %rdi
callq 0x1f390
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
leaq -0x30(%rbp), %rsi
callq 0x23c30
movq -0x48(%rbp), %rdi
addq $0x70, %rdi
leaq 0x457b8(%rip), %rsi     # 0x65c80
callq 0x22d80
testb $0x1, %al
jne 0x204d3
jmp 0x204f1
movq -0x48(%rbp), %rdi
leaq 0x456e2(%rip), %rsi     # 0x65bc0
callq 0x21d00
testb $0x1, %al
jne 0x204f1
movq $0x0, -0x8(%rbp)
jmp 0x20519
jmp 0x20476
movq -0x48(%rbp), %rdi
leaq 0x45782(%rip), %rsi     # 0x65c80
callq 0x21d00
testb $0x1, %al
jne 0x20511
movq $0x0, -0x8(%rbp)
jmp 0x20519
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1f390
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq 0x44dad(%rip), %rsi     # 0x65c40
callq 0x21d00
testb $0x1, %al
jne 0x20ebe
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x20eb4
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x20ec6
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x60, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x23a50
jmp 0x20f1d
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x58(%rbp), %rdi
addq $0x70, %rdi
leaq 0x44d77(%rip), %rsi     # 0x65cc0
callq 0x16920
testb $0x1, %al
jne 0x20f54
jmp 0x20f86
movq -0x58(%rbp), %rdi
callq 0x1f390
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x20feb
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x52b0
jmp 0x20ff5
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x22920
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
leaq -0x40(%rbp), %rsi
callq 0x239d0
leaq -0x40(%rbp), %rdi
callq 0x1e080
movq -0x58(%rbp), %rdi
leaq 0x44d08(%rip), %rsi     # 0x65cc0
callq 0x21d00
testb $0x1, %al
jne 0x20fe3
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x20fd9
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x20feb
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x60, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x23b20
jmp 0x2104d
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x60(%rbp), %rdi
addq $0x70, %rdi
leaq 0x44c07(%rip), %rsi     # 0x65c80
callq 0x22d80
testb $0x1, %al
jne 0x21087
jmp 0x2116d
movq -0x60(%rbp), %rdi
callq 0x1f390
movq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq 0x44b56(%rip), %rsi     # 0x65c00
callq 0x21d00
testb $0x1, %al
jne 0x210f7
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x210cb
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x21193
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x52b0
jmp 0x2119d
movq -0x60(%rbp), %rdi
callq 0x1f390
movq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x23b90
movq -0x60(%rbp), %rdi
addq $0x70, %rdi
leaq 0x44b41(%rip), %rsi     # 0x65c80
callq 0x22d80
testb $0x1, %al
jne 0x2114a
jmp 0x21168
movq -0x60(%rbp), %rdi
leaq 0x44a6b(%rip), %rsi     # 0x65bc0
callq 0x21d00
testb $0x1, %al
jne 0x21168
movq $0x0, -0x8(%rbp)
jmp 0x21193
jmp 0x2106a
movq -0x60(%rbp), %rdi
leaq 0x44b08(%rip), %rsi     # 0x65c80
callq 0x21d00
testb $0x1, %al
jne 0x2118b
movq $0x0, -0x8(%rbp)
jmp 0x21193
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x78, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x70(%rdi)
callq 0x23460
jmp 0x2120d
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x40(%rbp), %rsi
addq $0x30, %rsi
addq $0x20, %rsi
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x5050
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
callq 0x22540
movq -0x40(%rbp), %rdi
movl %eax, -0x28(%rbp)
callq 0x1f390
movq -0x40(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x21d60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x78, %esi
callq 0x52b0
movq -0x20(%rbp), %rdi
callq 0x5490
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x68, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x60(%rdi)
callq 0x23960
jmp 0x2130c
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rsi
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x70, %rdi
leaq 0x448fc(%rip), %rsi     # 0x65c40
callq 0x16920
testb $0x1, %al
jne 0x2134f
jmp 0x21384
movq -0x78(%rbp), %rdi
callq 0x1f390
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x213fa
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x68, %esi
callq 0x52b0
jmp 0x21407
movq -0x78(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x22920
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
leaq -0x48(%rbp), %rsi
callq 0x239d0
leaq -0x48(%rbp), %rdi
callq 0x1e080
movq -0x78(%rbp), %rdi
leaq 0x4488a(%rip), %rsi     # 0x65c40
callq 0x21d00
testb $0x1, %al
jne 0x213f2
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x5170
leaq -0x60(%rbp), %rdi
callq 0x23a00
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
leaq -0x60(%rbp), %rsi
callq 0x239d0
leaq -0x60(%rbp), %rdi
callq 0x1e080
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5490
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x58, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x50(%rdi)
callq 0x23ac0
jmp 0x21465
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rsi
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
callq 0x1f390
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
leaq 0x44808(%rip), %rsi     # 0x65cc0
callq 0x21d00
testb $0x1, %al
jne 0x214ff
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x214d9
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x21507
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x52b0
jmp 0x21511
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5490
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x20, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x5170
movq -0x20(%rbp), %rdi
callq 0x22d40
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
leaq 0x4442f(%rip), %rsi     # 0x659a0
callq 0x22d80
testb $0x1, %al
jne 0x2157c
jmp 0x215ac
movq -0x28(%rbp), %rdi
callq 0x215c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x215a1
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x22db0
movq -0x28(%rbp), %rdi
callq 0x1f390
jmp 0x21562
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0x30, %rsi
leaq -0x30(%rbp), %rdi
callq 0x5130
leaq -0x30(%rbp), %rdi
leaq 0x44731(%rip), %rsi     # 0x65d20
callq 0x16920
testb $0x1, %al
jne 0x215fa
jmp 0x21637
movq -0x50(%rbp), %rdi
callq 0x21710
movq %rax, -0x58(%rbp)
jmp 0x21609
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x216f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5518
jmp 0x21706
leaq -0x30(%rbp), %rdi
leaq 0x4437e(%rip), %rsi     # 0x659c0
callq 0x16920
testb $0x1, %al
jne 0x2164d
jmp 0x2169c
movq -0x50(%rbp), %rdi
callq 0x218c0
movq %rax, -0x60(%rbp)
jmp 0x2165c
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x2168b
movq -0x50(%rbp), %rdi
callq 0x21b50
movq %rax, -0x68(%rbp)
jmp 0x2167a
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x216f0
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x216f0
leaq -0x30(%rbp), %rdi
leaq 0x44719(%rip), %rsi     # 0x65dc0
callq 0x16920
testb $0x1, %al
jne 0x216b2
jmp 0x216d2
movq -0x50(%rbp), %rdi
callq 0x21c20
movq %rax, -0x70(%rbp)
jmp 0x216c1
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x216f0
movq -0x50(%rbp), %rdi
callq 0x21b50
movq %rax, -0x78(%rbp)
jmp 0x216e1
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5518
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5490
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0xb8, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, 0xa0(%rdi)
movaps %xmm0, 0x90(%rdi)
movaps %xmm0, 0x80(%rdi)
movaps %xmm0, 0x70(%rdi)
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0xb0(%rdi)
callq 0x22e20
jmp 0x21789
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x58(%rbp), %rdi
leaq 0x4420f(%rip), %rsi     # 0x659c0
callq 0x21d00
testb $0x1, %al
jne 0x217fe
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x217d2
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x2189f
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xb8, %esi
callq 0x52b0
jmp 0x218a9
movq -0x58(%rbp), %rsi
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x58(%rbp), %rsi
addq $0x30, %rsi
addq $0x20, %rsi
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
addq $0x48, %rdi
callq 0x5050
movq -0x58(%rbp), %rdi
leaq 0x441e1(%rip), %rsi     # 0x65a20
callq 0x21d00
testb $0x1, %al
jne 0x21852
movq $0x0, -0x8(%rbp)
jmp 0x2189f
movq -0x58(%rbp), %rdi
callq 0x1f390
movq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xb0(%rax)
addq $0x70, %rdi
leaq 0x4435d(%rip), %rsi     # 0x65be0
callq 0x16920
testb $0x1, %al
jne 0x2188e
jmp 0x21897
movq -0x58(%rbp), %rdi
callq 0x1f390
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseAssignStatement()
AssignStatement *Parser::parseAssignStatement()
{
	AssignStatement *stmt = new AssignStatement();

	if (peekToken.type != ASSIGN)
		return nullptr;

	stmt->token = Token(ASSIGN, "ASSIGN");

	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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl $0xb8, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xc0(%rbp)
movaps %xmm0, 0xa0(%rdi)
movaps %xmm0, 0x90(%rdi)
movaps %xmm0, 0x80(%rdi)
movaps %xmm0, 0x70(%rdi)
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0xb0(%rdi)
callq 0x22eb0
jmp 0x21948
movq -0xd8(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x70, %rdi
leaq 0x440bb(%rip), %rsi     # 0x65a20
callq 0x22d80
testb $0x1, %al
jne 0x21970
jmp 0x2199f
movq $0x0, -0x8(%rbp)
jmp 0x21b31
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xb8, %esi
callq 0x52b0
jmp 0x21b3e
leaq 0x4407a(%rip), %rsi     # 0x65a20
leaq -0x88(%rbp), %rdi
callq 0x5130
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x54a0
movq -0xe0(%rbp), %rdx
leaq 0x23ce5(%rip), %rsi     # 0x456b8
leaq -0xa8(%rbp), %rdi
callq 0x134c0
jmp 0x219e1
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x18d70
jmp 0x219fa
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x68(%rbp), %rsi
callq 0x18dd0
leaq -0x68(%rbp), %rdi
callq 0x139d0
leaq -0xa8(%rbp), %rdi
callq 0x5518
leaq -0xa9(%rbp), %rdi
callq 0x52f0
leaq -0x88(%rbp), %rdi
callq 0x5518
movq -0xd8(%rbp), %rsi
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0xd8(%rbp), %rsi
addq $0x30, %rsi
addq $0x20, %rsi
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
addq $0x48, %rdi
callq 0x5050
movq -0xd8(%rbp), %rdi
leaq 0x43f9e(%rip), %rsi     # 0x65a20
callq 0x21d00
testb $0x1, %al
jne 0x21ad8
movq $0x0, -0x8(%rbp)
jmp 0x21b31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x21abe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5518
leaq -0xa9(%rbp), %rdi
callq 0x52f0
leaq -0x88(%rbp), %rdi
callq 0x5518
jmp 0x21b3e
movq -0xd8(%rbp), %rdi
callq 0x1f390
movq -0xd8(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0xd8(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xb0(%rax)
addq $0x70, %rdi
leaq 0x440ce(%rip), %rsi     # 0x65be0
callq 0x16920
testb $0x1, %al
jne 0x21b1d
jmp 0x21b29
movq -0xd8(%rbp), %rdi
callq 0x1f390
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x50, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x23150
jmp 0x21b95
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x30, %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x70, %rdi
leaq 0x44009(%rip), %rsi     # 0x65be0
callq 0x16920
testb $0x1, %al
jne 0x21be2
jmp 0x21c09
movq -0x30(%rbp), %rdi
callq 0x1f390
jmp 0x21c09
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x50, %esi
callq 0x52b0
jmp 0x21c13
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5490
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x50, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x230f0
jmp 0x21c65
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x30, %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x30(%rbp), %rdi
callq 0x1f390
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x70, %rdi
leaq 0x43f30(%rip), %rsi     # 0x65be0
callq 0x16920
testb $0x1, %al
jne 0x21cbb
jmp 0x21ce2
movq -0x30(%rbp), %rdi
callq 0x1f390
jmp 0x21ce2
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x50, %esi
callq 0x52b0
jmp 0x21cec
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x70, %rdi
movq -0x18(%rbp), %rsi
callq 0x16920
testb $0x1, %al
jne 0x21d2b
jmp 0x21d3a
movq -0x20(%rbp), %rdi
callq 0x1f390
movb $0x1, -0x1(%rbp)
jmp 0x21d4b
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22080
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x60, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x23720
jmp 0x2260d
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x30, %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x40(%rbp), %rdi
callq 0x1f390
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
leaq 0x4363e(%rip), %rsi     # 0x65c80
callq 0x22d80
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x22655
jmp 0x2266c
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
leaq 0x4333c(%rip), %rsi     # 0x659a0
callq 0x22d80
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x22675
jmp 0x226c6
movq -0x40(%rbp), %rdi
callq 0x215c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x226b8
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
leaq -0x28(%rbp), %rsi
callq 0x22db0
jmp 0x226b8
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x60, %esi
callq 0x52b0
jmp 0x226d0
movq -0x40(%rbp), %rdi
callq 0x1f390
jmp 0x22633
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5490
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x23a00
movq -0x40(%rbp), %rdi
callq 0x1f390
jmp 0x22957
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq %rax, -0x58(%rbp)
jmp 0x22968
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x23a20
jmp 0x2297f
jmp 0x22981
movq -0x40(%rbp), %rdi
addq $0x70, %rdi
leaq 0x43230(%rip), %rsi     # 0x65bc0
callq 0x16920
testb $0x1, %al
jne 0x2299b
jmp 0x229f2
movq -0x40(%rbp), %rdi
callq 0x1f390
jmp 0x229a6
movq -0x40(%rbp), %rdi
callq 0x1f390
jmp 0x229b1
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq %rax, -0x60(%rbp)
jmp 0x229c2
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x23a20
jmp 0x229d9
jmp 0x22981
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1e080
jmp 0x22a0f
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x22a05
movq -0x50(%rbp), %rdi
callq 0x1e080
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2b920
movq -0x90(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x2b950
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2b8f0
testb $0x1, %al
jne 0x2b744
jmp 0x2b877
movq -0x90(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2b7d6
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5130
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x2b6f0
movq %rax, -0xa0(%rbp)
jmp 0x2b79b
leaq -0x50(%rbp), %rdi
callq 0x5518
movq -0xa0(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b891
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5518
jmp 0x2b89e
movl $0x28, %edi
callq 0x52a0
movq -0x98(%rbp), %rdx
movq %rax, -0xb8(%rbp)
movb $0x1, -0x81(%rbp)
leaq 0x1a0f5(%rip), %rsi     # 0x458f1
leaq -0x80(%rbp), %rdi
callq 0x1bc80
jmp 0x2b807
movq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2b980
jmp 0x2b819
movq -0xb8(%rbp), %rax
movb $0x0, -0x81(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5518
jmp 0x2b891
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2b859
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5518
testb $0x1, -0x81(%rbp)
jne 0x2b864
jmp 0x2b875
movq -0xb8(%rbp), %rdi
movl $0x28, %esi
callq 0x52b0
jmp 0x2b89e
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x2b9e0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5490
nopw (%rax,%rax)
// File: pranavmodx[P]modlang/src/../header/builtins.hpp
// Function: Print(std::vector<Object*, std::allocator<Object*>>&)
Object *Print(std::vector<Object *> &objs)
{
	for (auto obj : objs)
	{
		if (obj->type() == ERROR_OBJ)
			return obj;

		std::cout << obj->inspect() << " ";
	}

	std::cout << std::endl;

	return __NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x37310
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x37340
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x37370
testb $0x1, %al
jne 0x2cd37
jmp 0x2cdfd
leaq -0x20(%rbp), %rdi
callq 0x373b0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq (%rsi), %rax
leaq -0x50(%rbp), %rdi
callq *(%rax)
leaq -0x50(%rbp), %rdi
leaq 0x3a6a1(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0x7d(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5518
movb -0x7d(%rbp), %al
testb $0x1, %al
jne 0x2cd79
jmp 0x2cd86
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ce1e
movq -0x30(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq *%rax
movq -0x90(%rbp), %rsi
movq 0x37214(%rip), %rdi     # 0x63fc0
callq 0x5260
movq %rax, -0x88(%rbp)
jmp 0x2cdba
movq -0x88(%rbp), %rdi
leaq 0x185ae(%rip), %rsi     # 0x45376
callq 0x5290
jmp 0x2cdcf
leaq -0x70(%rbp), %rdi
callq 0x5518
leaq -0x20(%rbp), %rdi
callq 0x373d0
jmp 0x2cd21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5518
jmp 0x2ce2b
movq 0x371bc(%rip), %rdi     # 0x63fc0
movq 0x3718d(%rip), %rsi     # 0x63f98
callq 0x52d0
leaq 0x397a9(%rip), %rax     # 0x665c0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/../header/builtins.hpp
// Function: Type(std::vector<Object*, std::allocator<Object*>>&)
Object *Type(std::vector<Object *> &objs)
{
	if (objs.size() != 1)
		return new Error("error: argument length (" + std::to_string(objs.size()) + ") not equal to parameter length (1)");

	Object *obj = objs[0];
	ObjectType type = obj->type();

	if (type == ERROR_OBJ)
		return obj;

	std::cout << type << std::endl;

	return __NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x373f0
cmpq $0x1, %rax
je 0x31eda
movl $0x28, %edi
callq 0x52a0
movq %rax, -0xb8(%rbp)
movb $0x1, -0x7d(%rbp)
movq -0x10(%rbp), %rdi
callq 0x373f0
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x37410
jmp 0x31dfe
leaq 0x13b14(%rip), %rsi     # 0x45919
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x1bde0
jmp 0x31e14
leaq 0x13b17(%rip), %rdx     # 0x45932
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1bb10
jmp 0x31e2a
movq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2b980
jmp 0x31e3c
movq -0xb8(%rbp), %rax
movb $0x0, -0x7d(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5518
leaq -0x50(%rbp), %rdi
callq 0x5518
leaq -0x70(%rbp), %rdi
callq 0x5518
jmp 0x31fa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x31ebc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x31eb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x31eaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5518
leaq -0x50(%rbp), %rdi
callq 0x5518
leaq -0x70(%rbp), %rdi
callq 0x5518
testb $0x1, -0x7d(%rbp)
jne 0x31ec4
jmp 0x31ed5
movq -0xb8(%rbp), %rdi
movl $0x28, %esi
callq 0x52b0
jmp 0x31fb2
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x374f0
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rsi
movq (%rsi), %rax
leaq -0xa8(%rbp), %rdi
callq *(%rax)
leaq -0xa8(%rbp), %rdi
leaq 0x354ee(%rip), %rsi     # 0x67400
callq 0x16920
testb $0x1, %al
jne 0x31f1d
jmp 0x31f34
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xac(%rbp)
jmp 0x31f99
movq 0x32085(%rip), %rdi     # 0x63fc0
leaq -0xa8(%rbp), %rsi
callq 0x5260
movq %rax, -0xc0(%rbp)
jmp 0x31f50
movq -0xc0(%rbp), %rdi
movq 0x3203a(%rip), %rsi     # 0x63f98
callq 0x52d0
jmp 0x31f65
leaq 0x34654(%rip), %rax     # 0x665c0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xac(%rbp)
jmp 0x31f99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5518
jmp 0x31fb2
leaq -0xa8(%rbp), %rdi
callq 0x5518
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x5490
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x345f1(%rip), %rcx     # 0x665c8
cmpq (%rcx), %rax
jne 0x31fe5
movb $0x1, -0x1(%rbp)
jmp 0x3206c
movq -0x10(%rbp), %rax
leaq 0x345e0(%rip), %rcx     # 0x665d0
cmpq (%rcx), %rax
jne 0x31ffb
movb $0x0, -0x1(%rbp)
jmp 0x3206c
movq -0x10(%rbp), %rax
leaq 0x345ba(%rip), %rcx     # 0x665c0
cmpq (%rcx), %rax
jne 0x32011
movb $0x0, -0x1(%rbp)
jmp 0x3206c
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *(%rax)
leaq -0x30(%rbp), %rdi
leaq 0x351f7(%rip), %rsi     # 0x67220
callq 0x16920
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x3203c
jmp 0x3204a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x32(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5518
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x32062
jmp 0x32068
movb $0x0, -0x1(%rbp)
jmp 0x3206c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1ba50
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1ba80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bab0
testb $0x1, %al
jne 0x3371e
jmp 0x33871
leaq -0x38(%rbp), %rdi
callq 0x1baf0
movq -0xc0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
leaq -0x68(%rbp), %rdi
callq *(%rax)
leaq -0x68(%rbp), %rdi
leaq 0x33c42(%rip), %rsi     # 0x673a0
callq 0x16920
movb %al, %cl
movb $0x0, -0x95(%rbp)
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xc1(%rbp)
jne 0x337ae
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0x3378e
movb $0x1, -0x95(%rbp)
leaq -0x88(%rbp), %rdi
leaq 0x33c5d(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
movb %al, -0xc2(%rbp)
testb $0x1, -0x95(%rbp)
jne 0x337c5
jmp 0x337d1
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
movb -0xc2(%rbp), %al
testb $0x1, %al
jne 0x337e6
jmp 0x33814
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x33879
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5518
jmp 0x33886
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
leaq -0xb8(%rbp), %rdi
callq *(%rax)
leaq -0xb8(%rbp), %rdi
leaq 0x33bce(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0xc3(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x5518
movb -0xc3(%rbp), %al
testb $0x1, %al
jne 0x33855
jmp 0x3385f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33879
jmp 0x33861
jmp 0x33863
leaq -0x38(%rbp), %rdi
callq 0x1bb60
jmp 0x33708
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1ba50
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1ba80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bab0
testb $0x1, %al
jne 0x338fe
jmp 0x33a49
leaq -0x38(%rbp), %rdi
callq 0x1baf0
movq -0xa8(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq *%rax
movq -0xb8(%rbp), %rdi
movb $0x0, -0x99(%rbp)
leaq 0x11778(%rip), %rsi     # 0x450ca
callq 0x385c0
movb %al, -0xa9(%rbp)
jmp 0x3395f
movb -0xa9(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xb9(%rbp)
jne 0x339b9
jmp 0x33974
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x98(%rbp), %rdi
callq *%rax
jmp 0x33989
movb $0x1, -0x99(%rbp)
leaq 0x1174d(%rip), %rsi     # 0x450e4
leaq -0x98(%rbp), %rdi
callq 0x385c0
movb %al, -0xba(%rbp)
jmp 0x339ab
movb -0xba(%rbp), %al
movb %al, -0xb9(%rbp)
jmp 0x339b9
movb -0xb9(%rbp), %al
movb %al, -0xbb(%rbp)
testb $0x1, -0x99(%rbp)
jne 0x339d0
jmp 0x339dc
leaq -0x98(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
movb -0xbb(%rbp), %al
testb $0x1, %al
jne 0x339f1
jmp 0x33a39
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33a51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x33a2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
testb $0x1, -0x99(%rbp)
jne 0x33a20
jmp 0x33a2c
leaq -0x98(%rbp), %rdi
callq 0x5518
jmp 0x33a2e
leaq -0x68(%rbp), %rdi
callq 0x5518
jmp 0x33a5e
jmp 0x33a3b
leaq -0x38(%rbp), %rdi
callq 0x1bb60
jmp 0x338e8
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5490
nopw (%rax,%rax)