LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: MaxHeapLiteral::getStringRepr[abi:cxx11]()
std::string MaxHeapLiteral::getStringRepr()
{
	if (elements.empty())
		return "max_heap <" + type + "> {}";

	std::string res = "max_heap <" + type + "> {";

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

	res.pop_back();
	res.pop_back();

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x68(%rsi), %rax
leaq 0x48(%rsi), %rdx
cmpq 0x70(%rsi), %rax
je 0xcf5d
movq %rsi, %r15
leaq 0xf363(%rip), %rsi      # 0x1c222
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd1c2
leaq 0xf341(%rip), %rdx      # 0x1c214
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd12a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5388
movq 0x68(%r15), %r13
movq 0x70(%r15), %rbp
leaq 0x28(%rsp), %r15
leaq 0xf2f2(%rip), %r12      # 0x1c1f1
cmpq %rbp, %r13
je 0xcf40
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5360
movq %r14, %rdi
callq 0x5388
movq %r15, %rdi
callq 0x5388
addq $0x8, %r13
jmp 0xceff
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x5190
jmp 0xcf8d
leaq 0xf2be(%rip), %rsi      # 0x1c222
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd1c2
leaq 0xf2b5(%rip), %rdx      # 0x1c22d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd12a
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcfa3
jmp 0xcfad
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xcfd1
movq %rax, %r14
jmp 0xcfce
movq %rax, %r14
jmp 0xcfc4
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: MinHeapLiteral::getStringRepr[abi:cxx11]()
std::string MinHeapLiteral::getStringRepr()
{
	if (elements.empty())
		return "min_heap <" + type + "> {}";

	std::string res = "min_heap <" + type + "> {";

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

	res.pop_back();
	res.pop_back();

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x68(%rsi), %rax
leaq 0x48(%rsi), %rdx
cmpq 0x70(%rsi), %rax
je 0xd0a9
movq %rsi, %r15
leaq 0xf227(%rip), %rsi      # 0x1c232
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd1c2
leaq 0xf1f5(%rip), %rdx      # 0x1c214
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd12a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5388
movq 0x68(%r15), %r13
movq 0x70(%r15), %rbp
leaq 0x28(%rsp), %r15
leaq 0xf1a6(%rip), %r12      # 0x1c1f1
cmpq %rbp, %r13
je 0xd08c
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5360
movq %r14, %rdi
callq 0x5388
movq %r15, %rdi
callq 0x5388
addq $0x8, %r13
jmp 0xd04b
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x5190
jmp 0xd0d9
leaq 0xf182(%rip), %rsi      # 0x1c232
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd1c2
leaq 0xf169(%rip), %rdx      # 0x1c22d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd12a
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd0ef
jmp 0xd0f9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xd11d
movq %rax, %r14
jmp 0xd11a
movq %rax, %r14
jmp 0xd110
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseIntegerLiteral()
Expression *Parser::parseIntegerLiteral()
{
	IntegerLiteral *intLit = new IntegerLiteral();
	intLit->token = curToken;

	try
	{
		intLit->value = std::stoi(curToken.literal);
	}
	catch (const std::invalid_argument e)
	{
		errors.push_back("error: cannot parse " + curToken.literal + " to int");
		return nullptr;
	}
	catch (const std::out_of_range e)
	{
		errors.push_back("error: the integer " + curToken.literal + " is out of range");
		return nullptr;
	}

	return intLit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x51d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1b2af(%rip), %rax     # 0x298f0
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movb %al, 0x18(%r14)
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movb %al, 0x38(%r14)
leaq 0x30(%rbx), %rsi
callq 0x1073c
leaq 0x50(%rbx), %r15
pushq $0xa
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x108ce
movl %eax, 0x48(%r14)
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
cmpl $0x2, %edx
jne 0xe70c
movq %r14, %rdi
callq 0x5230
movq %rsp, %rdi
movq %rax, %rsi
callq 0x10904
movq %r14, %rdi
callq 0x50d0
leaq 0xdf32(%rip), %rsi      # 0x1c5e9
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0xd1c2
leaq 0xdf33(%rip), %rdx      # 0x1c5fe
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd12a
addq $0xb0, %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x11ff4
leaq 0x30(%rsp), %rdi
callq 0x5388
leaq 0x10(%rsp), %rdi
callq 0x5388
movq %rsp, %rdi
callq 0x5310
jmp 0xe78a
cmpl $0x1, %edx
jne 0xe7f5
movq %r14, %rdi
callq 0x5230
movq %rsp, %rdi
movq %rax, %rsi
callq 0x108ea
movq %r14, %rdi
callq 0x50d0
leaq 0xde8d(%rip), %rsi      # 0x1c5c4
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0xd1c2
leaq 0xde8d(%rip), %rdx      # 0x1c5d8
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd12a
addq $0xb0, %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x11ff4
leaq 0x30(%rsp), %rdi
callq 0x5388
leaq 0x10(%rsp), %rdi
callq 0x5388
movq %rsp, %rdi
callq 0x5270
callq 0x5300
xorl %r14d, %r14d
jmp 0xe680
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x5388
jmp 0xe7a9
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5388
jmp 0xe7b8
movq %rax, %r14
movq %rsp, %rdi
callq 0x5270
callq 0x5300
jmp 0xe7f5
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x5388
jmp 0xe7d9
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5388
jmp 0xe7e8
movq %rax, %r14
movq %rsp, %rdi
callq 0x5310
callq 0x5300
movq %r14, %rdi
callq 0x5330
movq %rax, %rdi
callq 0x9ece
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x68
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
andq $0x0, 0x60(%rax)
movq %rax, %rdi
callq 0x109a2
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
addq $0x50, %r14
movq %rbx, %rdi
addq $0x48, %rdi
movq %r14, %rsi
callq 0x5120
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x70
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movq %rax, %rdi
callq 0x1091e
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
addq $0x48, %rdi
callq 0x5120
movq %r14, %rdi
callq 0xe52e
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0xfea6
movq %rax, 0x68(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x70
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1b016(%rip), %rax     # 0x29950
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
addq $0x30, %r14
movq %r14, %rsi
callq 0x1073c
leaq 0x1d2ac(%rip), %rsi     # 0x2bc18
movq %r14, %rdi
callq 0xa7b4
movb %al, 0x48(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x51d0
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 0x1aa0e(%rip), %rax     # 0x293c0
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 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
leaq 0x30(%r14), %rsi
callq 0x1073c
leaq 0x1d173(%rip), %rsi     # 0x2bb58
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xea7a
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, 0x48(%rbx)
leaq 0x1d166(%rip), %rsi     # 0x2bb78
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xea7a
leaq 0x1d173(%rip), %rsi     # 0x2bb98
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xea7a
movq %r14, %rdi
callq 0x10314
movq %rax, 0x50(%rbx)
leaq 0x70(%r14), %rdi
leaq 0x1d250(%rip), %rsi     # 0x2bc98
callq 0xa7b4
testb %al, %al
je 0xea85
movq %r14, %rdi
callq 0xe52e
leaq 0x1d138(%rip), %rsi     # 0x2bb98
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xea7a
movq %r14, %rdi
callq 0x10314
movq %rax, 0x58(%rbx)
jmp 0xea85
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x58
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
andq $0x0, 0x50(%rax)
leaq 0x1a95f(%rip), %rax     # 0x29420
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 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
leaq 0x30(%r14), %rsi
callq 0x1073c
leaq 0x1d064(%rip), %rsi     # 0x2bb58
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xeb4a
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, 0x48(%rbx)
leaq 0x1d05b(%rip), %rsi     # 0x2bb78
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xeb53
leaq 0x1d068(%rip), %rsi     # 0x2bb98
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xeb53
movq %r14, %rdi
callq 0x10314
movq %rax, 0x50(%rbx)
jmp 0xeb55
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x68
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
andq $0x0, 0x60(%rax)
movq %rax, %rdi
callq 0x10a1e
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x1cfa6(%rip), %rsi     # 0x2bb58
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xec06
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x103e8
movq %rbx, %rdi
addq $0x48, %rdi
movq %r15, %rsi
callq 0x1254e
movq %r15, %rdi
callq 0xdd86
leaq 0x1cfac(%rip), %rsi     # 0x2bb98
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xec06
movq %r14, %rdi
callq 0x10314
movq %rax, 0x60(%rbx)
jmp 0xec11
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
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x60
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq %rax, %rdi
callq 0x10b72
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x1cdb5(%rip), %rsi     # 0x2ba38
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xed39
leaq 0x1cdbe(%rip), %rsi     # 0x2ba58
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xed39
leaq 0x1cee7(%rip), %rsi     # 0x2bb98
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xed39
leaq 0x70(%r14), %r15
movq %rbx, %r12
addq $0x48, %r12
leaq 0x1cee9(%rip), %r13     # 0x2bbb8
movq %rsp, %rbp
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xed26
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10bb0
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xecd2
movq %r14, %rdi
leaq 0x1cddd(%rip), %rsi     # 0x2baf8
callq 0xfe72
testb %al, %al
jne 0xecd2
jmp 0xed42
leaq 0x1ce8b(%rip), %rsi     # 0x2bbb8
movq %r14, %rdi
callq 0xfe72
testb %al, %al
jne 0xed44
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
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x60
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq %rax, %rdi
callq 0x10bce
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x1cc7d(%rip), %rsi     # 0x2ba38
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xee71
leaq 0x1cc86(%rip), %rsi     # 0x2ba58
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xee71
leaq 0x1cdaf(%rip), %rsi     # 0x2bb98
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xee71
leaq 0x70(%r14), %r15
movq %rbx, %r12
addq $0x48, %r12
leaq 0x1cdb1(%rip), %r13     # 0x2bbb8
movq %rsp, %rbp
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xee5e
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10bb0
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xee0a
movq %r14, %rdi
leaq 0x1cca5(%rip), %rsi     # 0x2baf8
callq 0xfe72
testb %al, %al
jne 0xee0a
jmp 0xee7a
leaq 0x1cd53(%rip), %rsi     # 0x2bbb8
movq %r14, %rdi
callq 0xfe72
testb %al, %al
jne 0xee7c
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
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x60
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq %rax, %rdi
callq 0x10c0c
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x1cb45(%rip), %rsi     # 0x2ba38
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xef8f
leaq 0x1cb4e(%rip), %rsi     # 0x2ba58
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xef8f
leaq 0x1cc7b(%rip), %rsi     # 0x2bb98
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xef8f
leaq 0x70(%r14), %r15
leaq 0x48(%rbx), %r12
leaq 0x1cc80(%rip), %r13     # 0x2bbb8
movq %rsp, %rbp
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xefa9
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10bb0
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xef3b
movq %r14, %rdi
leaq 0x1cb74(%rip), %rsi     # 0x2baf8
callq 0xfe72
testb %al, %al
jne 0xef3b
jmp 0xef98
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 0x1cc08(%rip), %rsi     # 0x2bbb8
movq %r14, %rdi
callq 0xfe72
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmovneq %rbx, %rax
jmp 0xef9a
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x60
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq %rax, %rdi
callq 0x10c4a
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x1ca0f(%rip), %rsi     # 0x2ba38
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xf0df
leaq 0x1ca18(%rip), %rsi     # 0x2ba58
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xf0df
leaq 0x1cb41(%rip), %rsi     # 0x2bb98
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xf0df
leaq 0x70(%r14), %r15
movq %rbx, %r12
addq $0x48, %r12
leaq 0x1cb43(%rip), %r13     # 0x2bbb8
movq %rsp, %rbp
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xf0cc
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10bb0
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xf078
movq %r14, %rdi
leaq 0x1ca37(%rip), %rsi     # 0x2baf8
callq 0xfe72
testb %al, %al
jne 0xf078
jmp 0xf0e8
leaq 0x1cae5(%rip), %rsi     # 0x2bbb8
movq %r14, %rdi
callq 0xfe72
testb %al, %al
jne 0xf0ea
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
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, %rbx
leaq 0x1c62a(%rip), %rsi     # 0x2bb78
movq %r14, %rdi
callq 0xfe72
testb %al, %al
jne 0xf56a
testq %rbx, %rbx
je 0xf568
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_O2/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
pushq $0x60
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq %rax, %rdi
callq 0x10af6
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x70(%r14), %rdi
leaq 0x1c631(%rip), %rsi     # 0x2bbf8
callq 0xa7b4
testb %al, %al
je 0xf5da
movq %r14, %rdi
callq 0xe52e
jmp 0xf61f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x105a2
movq %rbx, %rdi
addq $0x48, %rdi
movq %r15, %rsi
callq 0x126e4
movq %r15, %rdi
callq 0xdcd0
leaq 0x1c5f0(%rip), %rsi     # 0x2bbf8
movq %r14, %rdi
callq 0xfe72
testb %al, %al
jne 0xf61f
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
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x60
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq %rax, %rdi
callq 0x10b34
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x70(%r14), %r12
leaq 0x48(%rbx), %r13
leaq 0x1c51c(%rip), %rbp     # 0x2bbb8
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10766
testb %al, %al
je 0xf724
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, %r15
movq %r14, %rdi
leaq 0x1c46e(%rip), %rsi     # 0x2bb38
callq 0xfe72
testb %al, %al
je 0xf73d
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %r15, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
callq 0x128b2
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10766
testb %al, %al
je 0xf69c
movq %r14, %rdi
leaq 0x1c3e3(%rip), %rsi     # 0x2baf8
callq 0xfe72
testb %al, %al
jne 0xf69c
jmp 0xf746
leaq 0x1c48d(%rip), %rsi     # 0x2bbb8
movq %r14, %rdi
callq 0xfe72
xorl %ecx, %ecx
testb %al, %al
cmovneq %rbx, %rcx
jmp 0xf748
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
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
pushq $0x78
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
andq $0x0, 0x70(%rax)
movq %rax, %rdi
callq 0x10960
leaq 0x30(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1073c
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
addq $0x50, %rdi
callq 0x5120
movq %r15, 0x48(%rbx)
movq %r14, %rdi
callq 0x102d8
movl %eax, %ebp
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
movl %ebp, %esi
callq 0xfea6
movq %rax, 0x70(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x78
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdi, %r15
pushq $0x68
popq %rdi
callq 0x51d0
movq %rax, %r14
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
andq $0x0, 0x60(%rax)
movq %rax, %rdi
callq 0x10ab8
leaq 0x30(%r15), %rsi
leaq 0x8(%r14), %rdi
callq 0x1073c
movq %r12, 0x48(%rbx)
leaq 0x70(%r15), %rdi
leaq 0x1c2fe(%rip), %rsi     # 0x2bb78
callq 0xa7b4
testb %al, %al
je 0xf88d
movq %r15, %rdi
callq 0xe52e
jmp 0xf8e7
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x105a2
addq $0x50, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x126e4
movq %r12, %rdi
callq 0xdcd0
leaq 0x1c2bf(%rip), %rsi     # 0x2bb78
movq %r15, %rdi
callq 0xfe72
testb %al, %al
jne 0xf8e7
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x126e4
movq %r15, %rdi
callq 0xdcd0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x58
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
andq $0x0, 0x50(%rax)
leaq 0x19bff(%rip), %rax     # 0x29540
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 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movb %al, 0x38(%rbx)
leaq 0x30(%r14), %rsi
callq 0x1073c
movq %r15, 0x48(%rbx)
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, 0x50(%rbx)
leaq 0x1c26a(%rip), %rsi     # 0x2bbf8
movq %r14, %rdi
callq 0xfe72
testb %al, %al
jne 0xf9a5
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_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x51d0
movq %rax, %r14
leaq 0x196ca(%rip), %rax     # 0x29098
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%r14), %r15
xorps %xmm0, %xmm0
andq $0x0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
leaq 0x30(%rbx), %r12
leaq 0x1bee7(%rip), %r13     # 0x2b8d8
movq %rsp, %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0xfa29
movq %rbx, %rdi
callq 0xfa3c
movq %rax, (%rsp)
testq %rax, %rax
je 0xfa1f
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10770
movq %rbx, %rdi
callq 0xe52e
jmp 0xf9f4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5260
leaq 0x1c1fa(%rip), %rsi     # 0x2bc58
movq %r14, %rdi
callq 0xa7b4
testb %al, %al
je 0xfa8a
movq %rbx, %rdi
callq 0xfafa
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1be67(%rip), %rsi     # 0x2b8f8
leaq 0x8(%rsp), %rdi
callq 0xa7b4
testb %al, %al
je 0xfab9
movq %rbx, %rdi
callq 0xfbde
movq %rax, %r14
testq %rax, %rax
jne 0xfa75
movq %rbx, %rdi
callq 0xfd4a
jmp 0xfa72
leaq 0x1c238(%rip), %rsi     # 0x2bcf8
leaq 0x8(%rsp), %rdi
callq 0xa7b4
testb %al, %al
je 0xfad8
movq %rbx, %rdi
callq 0xfdda
jmp 0xfa72
movq %rbx, %rdi
callq 0xfd4a
jmp 0xfa72
jmp 0xfae4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseLetStatement()
LetStatement *Parser::parseLetStatement()
{
	LetStatement *stmt = new LetStatement();
	stmt->token = curToken;

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

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

	if (!expectPeek(ASSIGN))
		return nullptr;

	nextToken();

	stmt->value = parseExpression(LOWEST);

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

	return stmt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0xb8, %edi
callq 0x51d0
movq %rax, %rbx
movl $0xb8, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x5130
movq %rbx, %rdi
callq 0x1078e
leaq 0x30(%r14), %r15
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x1073c
leaq 0x1bdbb(%rip), %rsi     # 0x2b8f8
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xfbb2
leaq 0x50(%rbx), %rdi
movq %r15, %rsi
callq 0x1073c
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
addq $0x90, %rdi
callq 0x5120
leaq 0x1bde9(%rip), %rsi     # 0x2b958
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xfbbb
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, 0xb0(%rbx)
leaq 0x70(%r14), %rdi
leaq 0x1bf79(%rip), %rsi     # 0x2bb18
callq 0xa7b4
testb %al, %al
je 0xfbbd
movq %r14, %rdi
callq 0xe52e
jmp 0xfbbd
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xb8, %esi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movl $0xb8, %edi
callq 0x51d0
movq %rax, %rbx
movl $0xb8, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x5130
movq %rbx, %rdi
callq 0x107ea
leaq 0x70(%r14), %r15
leaq 0x1bd3a(%rip), %rsi     # 0x2b958
movq %r15, %rdi
callq 0x10766
testb %al, %al
jne 0xfcff
leaq 0x1bd23(%rip), %rsi     # 0x2b958
leaq 0x28(%rsp), %rdi
callq 0x5260
leaq 0xc8f2(%rip), %rsi      # 0x1c538
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9da4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xb9aa
leaq 0x8(%rbx), %rdi
leaq 0x48(%rsp), %r12
movq %r12, %rsi
callq 0xb9e0
movq %r12, %rdi
callq 0x9e52
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x30(%r14), %rsi
leaq 0x50(%rbx), %rdi
callq 0x1073c
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
addq $0x90, %rdi
callq 0x5120
leaq 0x1bc9b(%rip), %rsi     # 0x2b958
movq %r14, %rdi
callq 0xfe72
testb %al, %al
je 0xfcff
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, 0xb0(%rbx)
leaq 0x1be2f(%rip), %rsi     # 0x2bb18
movq %r15, %rdi
callq 0xa7b4
testb %al, %al
je 0xfd01
movq %r14, %rdi
callq 0xe52e
jmp 0xfd01
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0xfd25
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0xfd41
movq %rax, %r14
movl $0xb8, %esi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x51d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x194da(%rip), %rax     # 0x29250
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 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movb %al, 0x38(%r14)
leaq 0x30(%rbx), %rsi
callq 0x1073c
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, 0x48(%r14)
leaq 0x70(%rbx), %rdi
leaq 0x1bd5b(%rip), %rsi     # 0x2bb18
callq 0xa7b4
testb %al, %al
je 0xfdce
movq %rbx, %rdi
callq 0xe52e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x51d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x193f2(%rip), %rax     # 0x291f8
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 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movb %al, 0x38(%r14)
leaq 0x30(%rbx), %rsi
callq 0x1073c
movq %rbx, %rdi
callq 0xe52e
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfea6
movq %rax, 0x48(%r14)
leaq 0x70(%rbx), %rdi
leaq 0x1bcc3(%rip), %rsi     # 0x2bb18
callq 0xa7b4
testb %al, %al
je 0xfe66
movq %rbx, %rdi
callq 0xe52e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x70, %rdi
callq 0xa7b4
movl %eax, %ebx
movq %r14, %rdi
testb %al, %al
je 0xfe96
callq 0xe52e
jmp 0xfe9e
movq %r15, %rsi
callq 0xffce
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseExpression(Precedence)
Expression *Parser::parseExpression(Precedence precedence)
{
	if (prefixParseFns.find(curToken.type) == prefixParseFns.end())
	{
		noPrefixParseFnError(curToken.type);
		return nullptr;
	}

	PrefixParseFn prefix = prefixParseFns[curToken.type];

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

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

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

		nextToken();

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

	return leftExp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x100(%rdi), %r15
leaq 0x30(%rdi), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1238c
testq %rax, %rax
je 0xff7f
movq %r15, %rdi
movq %r14, %rsi
callq 0x116c0
movq (%rax), %rcx
movq 0x8(%rax), %rdi
addq %rbx, %rdi
testb $0x1, %cl
je 0xfefc
movq (%rdi), %rax
movq -0x1(%rax,%rcx), %rcx
callq *%rcx
movq %rax, %r14
leaq 0x138(%rbx), %r15
leaq 0x70(%rbx), %r12
movq %r12, %rdi
leaq 0x1bc02(%rip), %rsi     # 0x2bb18
callq 0x10766
testb %al, %al
je 0xffa7
movq %rbx, %rdi
callq 0x1029c
cmpl 0x4(%rsp), %eax
jle 0xffa7
movq %r15, %rdi
movq %r12, %rsi
callq 0x123ba
testq %rax, %rax
je 0xffa7
movq %r15, %rdi
movq %r12, %rsi
callq 0x11ab8
movq (%rax), %rbp
testq %rbp, %rbp
je 0xffa7
movq 0x8(%rax), %r13
addq %rbx, %r13
movq %rbx, %rdi
callq 0xe52e
testb $0x1, %bpl
je 0xff72
movq (%r13), %rax
movq -0x1(%rax,%rbp), %rbp
movq %r13, %rdi
movq %r14, %rsi
callq *%rbp
movq %rax, %r14
jmp 0xff0c
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5260
movq %rbx, %rdi
movq %r15, %rsi
callq 0x100b4
leaq 0x8(%rsp), %rdi
callq 0x5388
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseBlockStatement()
BlockStatement *Parser::parseBlockStatement()
{
	BlockStatement *block = new BlockStatement();
	block->token = curToken;

	nextToken();

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

		nextToken();
	}

	return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x51d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq %rax, %rdi
callq 0x109e0
leaq 0x30(%r14), %r15
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x1073c
movq %r14, %rdi
callq 0xe52e
movq %rbx, %r12
addq $0x48, %r12
leaq 0x1b843(%rip), %r13     # 0x2bbb8
leaq 0x1b55c(%rip), %rbp     # 0x2b8d8
movq %r15, %rdi
movq %r13, %rsi
callq 0x10766
testb %al, %al
je 0x103c0
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10766
testb %al, %al
je 0x103c0
movq %r14, %rdi
callq 0xfa3c
movq %rax, (%rsp)
testq %rax, %rax
je 0x103b6
movq %r12, %rdi
movq %rsp, %rsi
callq 0x10770
movq %r14, %rdi
callq 0xe52e
jmp 0x1037c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x51e0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseFunctionParameters()
std::vector<Identifier *> Parser::parseFunctionParameters()
{
	std::vector<Identifier *> parameters;

	if (peekToken.type == RPAREN)
	{ // no parameters
		nextToken();
		return parameters;
	}

	nextToken(); // pass "," or "("

	Identifier *ident = new Identifier();
	ident->token = curToken;
	ident->value = curToken.literal;
	parameters.push_back(ident);

	while (peekToken.type == COMMA)
	{
		nextToken();
		nextToken();
		Identifier *ident = new Identifier();
		ident->token = curToken;
		ident->value = curToken.literal;
		parameters.push_back(ident);
	}

	if (!expectPeek(RPAREN))
		return std::vector<Identifier *>();

	return parameters;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x70(%rsi), %r15
leaq 0x1b761(%rip), %rsi     # 0x2bb78
movq %r15, %rdi
callq 0xa7b4
testb %al, %al
je 0x10454
movq %r14, %rdi
callq 0xe52e
movaps 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rbx
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
jmp 0x10558
movq %r14, %rdi
callq 0xe52e
pushq $0x68
popq %rdi
callq 0x51d0
movq %rax, %rbp
movq %rax, %rdi
callq 0x10a5c
movq %rbp, 0x30(%rsp)
leaq 0x30(%r14), %r12
leaq 0x8(%rbp), %rdi
movq %r12, %rsi
callq 0x1073c
leaq 0x50(%r14), %r13
addq $0x48, %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5120
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x10a9a
leaq 0x1b64b(%rip), %rbx     # 0x2baf8
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa7b4
testb %al, %al
je 0x10515
movq %r14, %rdi
callq 0xe52e
movq %r14, %rdi
callq 0xe52e
pushq $0x68
popq %rdi
callq 0x51d0
movq %rax, %rbp
movq %rax, %rdi
callq 0x10a5c
movq %rbp, 0x28(%rsp)
addq $0x8, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x1073c
movq 0x28(%rsp), %rdi
addq $0x48, %rdi
movq %r13, %rsi
callq 0x5120
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x10a9a
jmp 0x104ad
leaq 0x1b65c(%rip), %rsi     # 0x2bb78
movq %r14, %rdi
callq 0xfe72
movq 0x8(%rsp), %rcx
testb %al, %al
je 0x10548
movaps 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rcx
movups %xmm0, (%rcx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rcx)
leaq 0x10(%rsp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd86
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1057a
jmp 0x1058c
jmp 0x1058c
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %rbp, %rdi
callq 0x51e0
jmp 0x1058f
jmp 0x1058c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd86
movq %rbx, %rdi
callq 0x5330
nop