LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/ast.cpp
// Function: HashSetLiteral::getStringRepr[abi:cxx11]()
std::string HashSetLiteral::getStringRepr()
{
	std::string res = "hashset<> {";

	for (auto pair : pairs)
		res += pair->getStringRepr() + ", ";

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

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x181df(%rip), %rsi     # 0x291bc
leaq 0x181e3(%rip), %rdx     # 0x291c7
callq 0xbe5c
movq 0x48(%r14), %r13
movq 0x50(%r14), %rbp
cmpq %rbp, %r13
je 0x110db
movq %r14, 0x30(%rsp)
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x181a5(%rip), %r12     # 0x291b5
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1104b
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x11052
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11093
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x110af
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x11010
movq 0x30(%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0x110db
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x110fc
movq %rax, %r15
jmp 0x1113c
movq %rax, %r15
jmp 0x11120
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11120
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1113c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x11156
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/ast.cpp
// Function: StackLiteral::getStringRepr[abi:cxx11]()
std::string StackLiteral::getStringRepr()
{
	std::string res = "stack<> {";

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

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

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x18043(%rip), %rsi     # 0x291c8
leaq 0x18045(%rip), %rdx     # 0x291d1
callq 0xbe5c
movq 0x48(%r14), %r13
movq 0x50(%r14), %rbp
cmpq %rbp, %r13
je 0x11283
movq %r14, 0x30(%rsp)
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x17ffd(%rip), %r12     # 0x291b5
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x111f3
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x111fa
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1123b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x11257
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x111b8
movq 0x30(%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0x11283
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x112a4
movq %rax, %r15
jmp 0x112e4
movq %rax, %r15
jmp 0x112c8
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x112c8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x112e4
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x112fe
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/ast.cpp
// Function: DequeLiteral::getStringRepr[abi:cxx11]()
std::string DequeLiteral::getStringRepr()
{
	std::string res = "deque<> {";

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

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

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x17d07(%rip), %rsi     # 0x291dc
leaq 0x17d09(%rip), %rdx     # 0x291e5
callq 0xbe5c
movq 0x48(%r14), %r13
movq 0x50(%r14), %rbp
cmpq %rbp, %r13
je 0x115d3
movq %r14, 0x30(%rsp)
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x17cad(%rip), %r12     # 0x291b5
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x11543
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x1154a
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1158b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x115a7
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x11508
movq 0x30(%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0x115d3
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x115f4
movq %rax, %r15
jmp 0x11634
movq %rax, %r15
jmp 0x11618
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11618
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x11634
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x1164e
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseStringLiteral()
Expression *Parser::parseStringLiteral()
{
	StringLiteral *s = new StringLiteral();
	s->token = curToken;
	s->value = curToken.literal;
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x68, %edi
callq 0x51b0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
leaq 0x206d8(%rip), %rax     # 0x349b8
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movb %al, 0x38(%r14)
leaq 0x48(%r14), %r12
leaq 0x58(%r14), %rcx
movq %rcx, 0x48(%r14)
movb %al, 0x58(%r14)
leaq 0x30(%rbx), %rsi
callq 0x5100
addq $0x50, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5100
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parsePrefixExpression()
Expression *Parser::parsePrefixExpression()
{
	PrefixExpression *exp = new PrefixExpression();
	exp->token = curToken;
	exp->operand = curToken.literal;

	nextToken();

	exp->right = parseExpression(PREFIX);
	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x70, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
leaq 0x1ff2d(%rip), %rax     # 0x342b0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
leaq 0x48(%rbx), %r12
leaq 0x58(%rbx), %rcx
movq %rcx, 0x48(%rbx)
movb %al, 0x58(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x5100
movq %r12, %rdi
movq %r13, %rsi
callq 0x5100
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
movl $0x5, %esi
callq 0x1626e
movq %rax, 0x68(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseBooleanLiteral()
Expression *Parser::parseBooleanLiteral()
{
	BooleanLiteral *ident = new BooleanLiteral();
	ident->token = curToken;
	ident->value = curToken.type == TRUE;
	return ident;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x50, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x20524(%rip), %rax     # 0x34958
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
movb %bpl, 0x18(%rbx)
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movb %bpl, 0x38(%rbx)
leaq 0x30(%r14), %r15
movq %r15, %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r12, %rdi
callq 0x5100
movq 0x38(%r14), %rdx
cmpq 0x2279c(%rip), %rdx     # 0x36c18
jne 0x1449d
testq %rdx, %rdx
je 0x1449a
movq 0x22786(%rip), %rsi     # 0x36c10
movq (%r15), %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x1449d
movb $0x1, %bpl
movb %bpl, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseIfExpression()
Expression *Parser::parseIfExpression()
{
	IfExpression *exp = new IfExpression();
	exp->token = curToken;

	// condition
	if (!expectPeek(LPAREN))
	{
		delete exp;
		return nullptr;
	}
	nextToken();
	exp->condition = parseExpression(LOWEST);
	if (!expectPeek(RPAREN))
	{
		delete exp;
		return nullptr;
	}

	// consequence
	if (!expectPeek(LBRACE))
	{
		delete exp;
		return nullptr;
	}
	exp->consequence = parseBlockStatement();

	// else
	if (peekToken.type == ELSE)
	{
		nextToken();
		if (!expectPeek(LBRACE))
		{
			delete exp;
			return nullptr;
		}
		exp->alternative = parseBlockStatement();
	}
	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
leaq 0x1fee7(%rip), %rax     # 0x343c8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x2262c(%rip), %rsi     # 0x36b50
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x145cb
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, 0x48(%rbx)
leaq 0x2261f(%rip), %rsi     # 0x36b70
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x145cb
leaq 0x2262c(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x145cb
movq %r14, %rdi
callq 0x16a46
movq %rax, 0x50(%rbx)
movq 0x78(%r14), %rdx
cmpq 0x22711(%rip), %rdx     # 0x36c98
jne 0x145d6
testq %rdx, %rdx
je 0x145a2
movq 0x226fb(%rip), %rsi     # 0x36c90
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x145d6
movq %r14, %rdi
callq 0x13d2e
leaq 0x225df(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x145cb
movq %r14, %rdi
callq 0x16a46
movq %rax, 0x58(%rbx)
jmp 0x145d6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq $0x0, 0x50(%rax)
leaq 0x1fe11(%rip), %rax     # 0x34428
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x224f6(%rip), %rsi     # 0x36b50
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x146b0
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, 0x48(%rbx)
leaq 0x224ed(%rip), %rsi     # 0x36b70
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x146b9
leaq 0x224fa(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x146b9
movq %r14, %rdi
callq 0x16a46
movq %rax, 0x50(%rbx)
jmp 0x146bb
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl $0x68, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
xorl %eax, %eax
movq %rax, 0x60(%rbx)
leaq 0x1fd87(%rip), %rcx     # 0x34488
addq $0x10, %rcx
movq %rcx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%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 0x22406(%rip), %rsi     # 0x36b50
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x147aa
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x16b76
movq 0x48(%rbx), %rdi
movq 0x58(%rbx), %rsi
movaps (%r15), %xmm0
movups %xmm0, 0x48(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x58(%rbx)
testq %rdi, %rdi
je 0x14789
subq %rdi, %rsi
callq 0x51c0
leaq 0x22400(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x147aa
movq %r14, %rdi
callq 0x16a46
movq %rax, 0x60(%rbx)
jmp 0x147b5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseHashSetLiteral()
Expression *Parser::parseHashSetLiteral()
{
	HashSetLiteral *exp = new HashSetLiteral();
	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->pairs.push_back(value);

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

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

	return exp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1fe11(%rip), %rax     # 0x34608
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x221ea(%rip), %rsi     # 0x36a30
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x1495d
leaq 0x221f3(%rip), %rsi     # 0x36a50
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x1495d
leaq 0x2231c(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x1495d
movq %rbx, %r15
addq $0x48, %r15
movq 0x22326(%rip), %rbp     # 0x36bb8
movq %rsp, %r12
leaq 0x22254(%rip), %r13     # 0x36af0
cmpq %rbp, 0x78(%r14)
jne 0x148c6
testq %rbp, %rbp
je 0x1494a
movq 0x222fe(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x1494a
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, (%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x148f0
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x148fb
movq %r15, %rdi
movq %r12, %rdx
callq 0x18f70
movq 0x78(%r14), %rbp
cmpq 0x222b2(%rip), %rbp     # 0x36bb8
jne 0x14928
testq %rbp, %rbp
je 0x14943
movq 0x2229c(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x1489c
movq %r14, %rdi
movq %r13, %rsi
callq 0x16224
testb %al, %al
je 0x14966
movq 0x2227a(%rip), %rbp     # 0x36bb8
jmp 0x1489c
xorl %ebp, %ebp
jmp 0x1489c
leaq 0x2225f(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x16224
testb %al, %al
jne 0x14968
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
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_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseStackLiteral()
Expression *Parser::parseStackLiteral()
{
	StackLiteral *exp = new StackLiteral();
	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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1fcb9(%rip), %rax     # 0x34668
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x22032(%rip), %rsi     # 0x36a30
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14b15
leaq 0x2203b(%rip), %rsi     # 0x36a50
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14b15
leaq 0x22164(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14b15
movq %rbx, %r15
addq $0x48, %r15
movq 0x2216e(%rip), %rbp     # 0x36bb8
movq %rsp, %r12
leaq 0x2209c(%rip), %r13     # 0x36af0
cmpq %rbp, 0x78(%r14)
jne 0x14a7e
testq %rbp, %rbp
je 0x14b02
movq 0x22146(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x14b02
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, (%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x14aa8
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x14ab3
movq %r15, %rdi
movq %r12, %rdx
callq 0x18f70
movq 0x78(%r14), %rbp
cmpq 0x220fa(%rip), %rbp     # 0x36bb8
jne 0x14ae0
testq %rbp, %rbp
je 0x14afb
movq 0x220e4(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x14a54
movq %r14, %rdi
movq %r13, %rsi
callq 0x16224
testb %al, %al
je 0x14b1e
movq 0x220c2(%rip), %rbp     # 0x36bb8
jmp 0x14a54
xorl %ebp, %ebp
jmp 0x14a54
leaq 0x220a7(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x16224
testb %al, %al
jne 0x14b20
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
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_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1fb61(%rip), %rax     # 0x346c8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x21e7a(%rip), %rsi     # 0x36a30
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14cb7
leaq 0x21e83(%rip), %rsi     # 0x36a50
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14cb7
leaq 0x21fac(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14cb7
leaq 0x48(%rbx), %r15
movq 0x21fb9(%rip), %rbp     # 0x36bb8
movq %rsp, %r12
leaq 0x21ee7(%rip), %r13     # 0x36af0
cmpq %rbp, 0x78(%r14)
jne 0x14c33
testq %rbp, %rbp
je 0x14cd1
movq 0x21f91(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x14cd1
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, (%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x14c5d
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x14c68
movq %r15, %rdi
movq %r12, %rdx
callq 0x18f70
movq 0x78(%r14), %rbp
cmpq 0x21f45(%rip), %rbp     # 0x36bb8
jne 0x14c95
testq %rbp, %rbp
je 0x14cb0
movq 0x21f2f(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x14c09
movq %r14, %rdi
movq %r13, %rsi
callq 0x16224
testb %al, %al
je 0x14cc0
movq 0x21f0d(%rip), %rbp     # 0x36bb8
jmp 0x14c09
xorl %ebp, %ebp
jmp 0x14c09
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21ed8(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x16224
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmovneq %rbx, %rax
jmp 0x14cc2
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1fa07(%rip), %rax     # 0x34728
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x21cc0(%rip), %rsi     # 0x36a30
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14e87
leaq 0x21cc9(%rip), %rsi     # 0x36a50
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14e87
leaq 0x21df2(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x14e87
movq %rbx, %r15
addq $0x48, %r15
movq 0x21dfc(%rip), %rbp     # 0x36bb8
movq %rsp, %r12
leaq 0x21d2a(%rip), %r13     # 0x36af0
cmpq %rbp, 0x78(%r14)
jne 0x14df0
testq %rbp, %rbp
je 0x14e74
movq 0x21dd4(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x14e74
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, (%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x14e1a
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x14e25
movq %r15, %rdi
movq %r12, %rdx
callq 0x18f70
movq 0x78(%r14), %rbp
cmpq 0x21d88(%rip), %rbp     # 0x36bb8
jne 0x14e52
testq %rbp, %rbp
je 0x14e6d
movq 0x21d72(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %rbp, %rdx
callq 0x51d0
testl %eax, %eax
je 0x14dc6
movq %r14, %rdi
movq %r13, %rsi
callq 0x16224
testb %al, %al
je 0x14e90
movq 0x21d50(%rip), %rbp     # 0x36bb8
jmp 0x14dc6
xorl %ebp, %ebp
jmp 0x14dc6
leaq 0x21d35(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x16224
testb %al, %al
jne 0x14e92
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
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_O3/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 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, %rbx
leaq 0x21688(%rip), %rsi     # 0x36b70
movq %r14, %rdi
callq 0x16224
testb %al, %al
jne 0x15504
testq %rbx, %rbx
je 0x15502
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_O3/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 %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1ebad(%rip), %rax     # 0x340f0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
movq 0x78(%r14), %rdx
cmpq 0x21662(%rip), %rdx     # 0x36bf8
jne 0x155b5
testq %rdx, %rdx
je 0x1562d
movq 0x21648(%rip), %rsi     # 0x36bf0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x1562d
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x16df8
movq 0x48(%rbx), %rdi
movq 0x58(%rbx), %rsi
movaps (%r15), %xmm0
movups %xmm0, 0x48(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x58(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0x1560d
subq %rdi, %rsi
callq 0x51c0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1560d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x51c0
leaq 0x215dc(%rip), %rsi     # 0x36bf0
movq %r14, %rdi
callq 0x16224
testb %al, %al
jne 0x15635
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
jmp 0x15635
movq %r14, %rdi
callq 0x13d2e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1ef2e(%rip), %rax     # 0x345a8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
movb %cl, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movb %cl, 0x38(%rbx)
leaq 0x48(%rbx), %r12
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
movq 0x214eb(%rip), %rdx     # 0x36bb8
leaq 0x2145c(%rip), %r13     # 0x36b30
leaq 0x21415(%rip), %rbp     # 0x36af0
cmpq %rdx, 0x78(%r14)
jne 0x15702
testq %rdx, %rdx
je 0x157c1
movq 0x214bf(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x157c1
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0x16224
testb %al, %al
je 0x157da
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %r15, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x1575f
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x50(%rbx)
jmp 0x1576c
movq %r12, %rdi
leaq 0x8(%rsp), %rdx
callq 0x18e30
movq 0x78(%r14), %r15
cmpq 0x21441(%rip), %r15     # 0x36bb8
jne 0x157a5
movl $0x0, %edx
testq %r15, %r15
je 0x156db
movq 0x21422(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
movq %r15, %rdx
callq 0x51d0
movq %r15, %rdx
testl %eax, %eax
je 0x156db
movq %r14, %rdi
movq %rbp, %rsi
callq 0x16224
movq 0x21401(%rip), %rdx     # 0x36bb8
testb %al, %al
jne 0x156db
jmp 0x157e3
leaq 0x213e8(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x16224
xorl %ecx, %ecx
testb %al, %al
cmovneq %rbx, %rcx
jmp 0x157e5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::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, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x40(%rax)
movq $0x0, 0x70(%rax)
leaq 0x1ead0(%rip), %rax     # 0x34310
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
leaq 0x50(%rbx), %r13
leaq 0x60(%rbx), %rcx
movq %rcx, 0x50(%rbx)
movb %al, 0x60(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5100
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5100
movq %r15, 0x48(%rbx)
movq %r14, %rdi
callq 0x16a0a
movl %eax, %ebp
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
movl %ebp, %esi
callq 0x1626e
movq %rax, 0x70(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x68, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1ebe0(%rip), %rax     # 0x344e8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
movups %xmm0, 0x50(%rbx)
movq $0x0, 0x60(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r12, %rdi
callq 0x5100
movq %r15, 0x48(%rbx)
movq 0x78(%r14), %rdx
cmpq 0x21219(%rip), %rdx     # 0x36b78
jne 0x15982
testq %rdx, %rdx
je 0x15a19
movq 0x211ff(%rip), %rsi     # 0x36b70
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x15a19
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x16df8
movq 0x50(%rbx), %rdi
movq 0x60(%rbx), %rsi
movaps (%r15), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x60(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0x159da
subq %rdi, %rsi
callq 0x51c0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x159da
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x51c0
leaq 0x2118f(%rip), %rsi     # 0x36b70
movq %r14, %rdi
callq 0x16224
testb %al, %al
jne 0x15a21
movq %rbx, %rax
addq $0x50, %rax
movq 0x50(%rbx), %rdi
movq 0x60(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
testq %rdi, %rdi
je 0x15a21
subq %rdi, %rsi
callq 0x51c0
jmp 0x15a21
movq %r14, %rdi
callq 0x13d2e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq $0x0, 0x50(%rax)
leaq 0x1eadb(%rip), %rax     # 0x34548
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%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 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, 0x50(%rbx)
leaq 0x21126(%rip), %rsi     # 0x36bf0
movq %r14, %rdi
callq 0x16224
testb %al, %al
jne 0x15ae1
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
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x1e591(%rip), %rax     # 0x340a0
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq %rsp, %r12
movq 0x38(%rbx), %rdx
cmpq 0x20da0(%rip), %rdx     # 0x368d8
jne 0x15b53
testq %rdx, %rdx
je 0x15b8d
movq 0x20d8a(%rip), %rsi     # 0x368d0
movq 0x30(%rbx), %rdi
callq 0x51d0
testl %eax, %eax
je 0x15b8d
movq %rbx, %rdi
callq 0x15b9c
movq %rax, (%rsp)
testq %rax, %rax
je 0x15b83
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x15b78
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x15b83
movq %r15, %rdi
movq %r12, %rdx
callq 0x18366
movq %rbx, %rdi
callq 0x13d2e
jmp 0x15b2d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbdc6
movq 0x8(%r14), %r14
cmpq 0x21086(%rip), %r14     # 0x36c58
jne 0x15bf0
testq %r14, %r14
je 0x15c44
movq 0x21070(%rip), %rsi     # 0x36c50
movq (%rsp), %rdi
movq %r14, %rdx
callq 0x51d0
testl %eax, %eax
je 0x15c44
cmpq 0x20d01(%rip), %r14     # 0x368f8
jne 0x15c15
testq %r14, %r14
je 0x15c4e
movq 0x20ceb(%rip), %rsi     # 0x368f0
movq (%rsp), %rdi
movq %r14, %rdx
callq 0x51d0
testl %eax, %eax
je 0x15c4e
cmpq 0x210dc(%rip), %r14     # 0x36cf8
jne 0x15c3a
testq %r14, %r14
je 0x15c68
movq 0x210c6(%rip), %rsi     # 0x36cf0
movq (%rsp), %rdi
movq %r14, %rdx
callq 0x51d0
testl %eax, %eax
je 0x15c68
movq %rbx, %rdi
callq 0x160b8
jmp 0x15c70
movq %rbx, %rdi
callq 0x15cba
jmp 0x15c70
movq %rbx, %rdi
callq 0x15e2e
movq %rax, %r14
testq %rax, %rax
jne 0x15c73
movq %rbx, %rdi
callq 0x160b8
jmp 0x15c70
movq %rbx, %rdi
callq 0x1616a
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x15c89
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x15c98
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x15cb1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xb8, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x10(%rax), %rdi
xorl %ebp, %ebp
movl $0xa8, %edx
xorl %esi, %esi
callq 0x5110
leaq 0x1e462(%rip), %rax     # 0x34150
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movb %bpl, 0x18(%rbx)
leaq 0x28(%rbx), %r13
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movb %bpl, 0x38(%rbx)
leaq 0x1eb7c(%rip), %rax     # 0x34898
movq %rax, 0x48(%rbx)
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movb %bpl, 0x60(%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x70(%rbx)
movb %bpl, 0x80(%rbx)
leaq 0xa0(%rbx), %rax
movq %rax, 0x90(%rbx)
movb %bpl, 0xa0(%rbx)
leaq 0x30(%r14), %r12
movq %r12, %rsi
callq 0x5100
leaq 0x50(%r14), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x5100
leaq 0x20b7b(%rip), %rsi     # 0x368f0
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x15e11
leaq 0x50(%rbx), %rdi
leaq 0x70(%rbx), %r13
movq %rbx, %rbp
addq $0x90, %rbp
movq %r12, %rsi
callq 0x5100
movq %r13, %rdi
movq %r15, %rsi
callq 0x5100
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5100
leaq 0x20b94(%rip), %rsi     # 0x36950
movq %r14, %rdi
callq 0x16224
testb %al, %al
je 0x15e1a
movq %r14, %rdi
callq 0x13d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, 0xb0(%rbx)
movq 0x78(%r14), %rdx
cmpq 0x20d2c(%rip), %rdx     # 0x36b18
jne 0x15e1c
testq %rdx, %rdx
je 0x15e07
movq 0x20d16(%rip), %rsi     # 0x36b10
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x15e1c
movq %r14, %rdi
callq 0x13d2e
jmp 0x15e1c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
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_O3/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, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1e171(%rip), %rax     # 0x34258
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%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 0x1626e
movq %rax, 0x48(%r14)
movq 0x78(%rbx), %rdx
cmpq 0x209da(%rip), %rdx     # 0x36b18
jne 0x16161
testq %rdx, %rdx
je 0x16159
movq 0x209c4(%rip), %rsi     # 0x36b10
movq 0x70(%rbx), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x16161
movq %rbx, %rdi
callq 0x13d2e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1e067(%rip), %rax     # 0x34200
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movb %al, 0x38(%r14)
leaq 0x30(%rbx), %rsi
callq 0x5100
leaq 0x50(%rbx), %rsi
movq %r15, %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x13d2e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1626e
movq %rax, 0x48(%r14)
movq 0x78(%rbx), %rdx
cmpq 0x20920(%rip), %rdx     # 0x36b18
jne 0x1621b
testq %rdx, %rdx
je 0x16213
movq 0x2090a(%rip), %rsi     # 0x36b10
movq 0x70(%rbx), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x1621b
movq %rbx, %rdi
callq 0x13d2e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x1624d
testq %rdx, %rdx
je 0x1625c
movq (%r14), %rsi
movq 0x70(%rbx), %rdi
callq 0x51d0
testl %eax, %eax
je 0x1625c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x163e4
xorl %eax, %eax
jmp 0x16266
movq %rbx, %rdi
callq 0x13d2e
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq