LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalPrefixExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Object*)
Object *Evaluator::evalPrefixExpression(std::string operand, Object *right)
{
	if (operand == "!")
		return evalBangPrefixExpression(right);
	else if (operand == "-")
		return evalMinusPrefixExpression(right);

	Object *error = new Error("error : unknown operator for " + right->type() + " -> " + operand);
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, %rax
movq -0xd0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq 0x1157a(%rip), %rsi     # 0x4502b
callq 0x385c0
testb $0x1, %al
jne 0x33abc
jmp 0x33ad5
movq -0xc0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x35d70
movq %rax, -0x8(%rbp)
jmp 0x33c86
movq -0xc8(%rbp), %rdi
leaq 0x12218(%rip), %rsi     # 0x45cfb
callq 0x385c0
testb $0x1, %al
jne 0x33aee
jmp 0x33b07
movq -0xc0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x35e60
movq %rax, -0x8(%rbp)
jmp 0x33c86
jmp 0x33b09
movl $0x28, %edi
callq 0x52a0
movq %rax, -0xd8(%rbp)
movb $0x1, -0xb5(%rbp)
movq -0x20(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0xa8(%rbp), %rdi
callq *%rax
jmp 0x33b36
leaq 0x1219c(%rip), %rsi     # 0x45cd9
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x1bde0
jmp 0x33b52
leaq 0x11db4(%rip), %rdx     # 0x4590d
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1bb10
jmp 0x33b6b
movq -0xc8(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1bd90
jmp 0x33b81
movq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2b980
jmp 0x33b93
movb $0x0, -0xb5(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0xa8(%rbp), %rdi
callq 0x5518
movq -0xd8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33c86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x33c68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x33c5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x33c50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x33c47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0xa8(%rbp), %rdi
callq 0x5518
testb $0x1, -0xb5(%rbp)
jne 0x33c73
jmp 0x33c84
movq -0xd8(%rbp), %rdi
movl $0x28, %esi
callq 0x52b0
jmp 0x33c93
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x5490
nop
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalIfExpression(IfExpression*, Environment*)
Object *Evaluator::evalIfExpression(IfExpression *ifExpr, Environment *env)
{
	Object *condition = Eval(ifExpr->condition, env);

	if (isTruthy(condition))
		return Eval(ifExpr->consequence, env);

	else if (ifExpr->alternative != nullptr)
		return Eval(ifExpr->alternative, env);

	return __NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x31fc0
testb $0x1, %al
jne 0x34570
jmp 0x3458b
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x8(%rbp)
jmp 0x345c1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x345b1
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x8(%rbp)
jmp 0x345c1
jmp 0x345b3
leaq 0x32006(%rip), %rax     # 0x665c0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalIdentifier(Identifier*, Environment*)
Object *Evaluator::evalIdentifier(Identifier *ident, Environment *env)
{
	Object *obj = env->Get(ident->value);

	if (obj->type() != ERROR_OBJ &&
		builtin.find(ident->value) != builtin.end())
		return builtin[ident->value];

	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x5130
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x2b6f0
movq %rax, -0x90(%rbp)
jmp 0x34626
leaq -0x48(%rbp), %rdi
callq 0x5518
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
leaq -0x78(%rbp), %rdi
callq *(%rax)
leaq -0x78(%rbp), %rdi
leaq 0x32dae(%rip), %rsi     # 0x67400
callq 0x22d80
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa1(%rbp)
jne 0x34668
jmp 0x346b9
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
leaq 0x32da9(%rip), %rdi     # 0x67420
callq 0x38840
movq %rax, -0xb0(%rbp)
jmp 0x34685
movq -0xb0(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x32d89(%rip), %rdi     # 0x67420
callq 0x38870
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x38810
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
movb %al, -0xb1(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5518
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x346da
jmp 0x34725
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
leaq 0x32d37(%rip), %rdi     # 0x67420
callq 0x388a0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3472d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
jmp 0x3473a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5518
jmp 0x3473a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalHashSetLiteral(HashSetLiteral*, Environment*)
Object *Evaluator::evalHashSetLiteral(HashSetLiteral *hashSetLiteral, Environment *env)
{
	HashSet *hashSet = new HashSet();

	for (auto pair : hashSetLiteral->pairs)
	{
		Object *key = Eval(pair, env);

		if (key->type() == ERROR_OBJ)
		{
			delete hashSet;
			return key;
		}

		HashKey hashKey(key->type(), key->inspect());
		hashSet->pairs[hashKey] = key;
	}

	return hashSet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
movl $0x40, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x108(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x5170
movq -0x108(%rbp), %rdi
callq 0x38990
movq -0x108(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x35315
jmp 0x354c0
leaq -0x38(%rbp), %rdi
callq 0x1bfd0
movq -0x110(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
movq (%rsi), %rax
leaq -0x70(%rbp), %rdi
callq *(%rax)
leaq -0x70(%rbp), %rdi
leaq 0x320ab(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0x111(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5518
movb -0x111(%rbp), %al
testb $0x1, %al
jne 0x35375
jmp 0x353b0
movq -0x28(%rbp), %rax
movq %rax, -0x120(%rbp)
cmpq $0x0, %rax
je 0x353a3
movq -0x120(%rbp), %rdi
callq 0x389d0
movq -0x120(%rbp), %rdi
movl $0x40, %esi
callq 0x52b0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x354c8
movq -0x50(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0xd0(%rbp), %rdi
callq *%rax
movq -0x50(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xf0(%rbp), %rdi
callq *%rax
jmp 0x353d9
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
callq 0x37af0
jmp 0x353f5
leaq -0xf0(%rbp), %rdi
callq 0x5518
leaq -0xd0(%rbp), %rdi
callq 0x5518
movq -0x50(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x38a00
movq %rax, -0x128(%rbp)
jmp 0x35435
movq -0x128(%rbp), %rax
movq -0x130(%rbp), %rcx
movq %rcx, (%rax)
leaq -0xb0(%rbp), %rdi
callq 0x37bf0
leaq -0x38(%rbp), %rdi
callq 0x1bff0
jmp 0x352ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x35492
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x5518
leaq -0xd0(%rbp), %rdi
callq 0x5518
jmp 0x354d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x37bf0
jmp 0x354d5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalStackLiteral(StackLiteral*, Environment*)
Object *Evaluator::evalStackLiteral(StackLiteral *stackLiteral, Environment *env)
{
	Stack *stack = new Stack();

	for (auto elem : stackLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete stack;
			return obj;
		}

		stack->elements.push(obj);
	}

	return stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x58, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x50(%rdi)
callq 0x38a30
jmp 0x35555
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x3559c
jmp 0x35672
leaq -0x48(%rbp), %rdi
callq 0x1bfd0
movq -0x98(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
movq (%rsi), %rax
leaq -0x80(%rbp), %rdi
callq *(%rax)
leaq -0x80(%rbp), %rdi
leaq 0x31e24(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0x99(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5518
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x355fc
jmp 0x35653
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x3562a
movq -0xa8(%rbp), %rdi
callq 0x38a70
movq -0xa8(%rbp), %rdi
movl $0x58, %esi
callq 0x52b0
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3567a
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x52b0
jmp 0x35687
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0x376c0
leaq -0x48(%rbp), %rdi
callq 0x1bff0
jmp 0x35586
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5490
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalQueueLiteral(QueueLiteral*, Environment*)
Object *Evaluator::evalQueueLiteral(QueueLiteral *queueLiteral, Environment *env)
{
	Queue *queue = new Queue();

	for (auto elem : queueLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete queue;
			return obj;
		}

		queue->elements.push(obj);
	}

	return queue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x58, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x50(%rdi)
callq 0x38aa0
jmp 0x356f5
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x3573c
jmp 0x35812
leaq -0x48(%rbp), %rdi
callq 0x1bfd0
movq -0x98(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
movq (%rsi), %rax
leaq -0x80(%rbp), %rdi
callq *(%rax)
leaq -0x80(%rbp), %rdi
leaq 0x31c84(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0x99(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5518
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x3579c
jmp 0x357f3
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x357ca
movq -0xa8(%rbp), %rdi
callq 0x38ae0
movq -0xa8(%rbp), %rdi
movl $0x58, %esi
callq 0x52b0
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3581a
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x52b0
jmp 0x35827
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0x376f0
leaq -0x48(%rbp), %rdi
callq 0x1bff0
jmp 0x35726
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5490
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalDequeLiteral(DequeLiteral*, Environment*)
Object *Evaluator::evalDequeLiteral(DequeLiteral *queueLiteral, Environment *env)
{
	Deque *deque = new Deque();

	for (auto elem : queueLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete deque;
			return obj;
		}

		deque->elements.push_back(obj);
	}

	return deque;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x58, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x50(%rdi)
callq 0x38b10
jmp 0x35895
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x358dc
jmp 0x359b2
leaq -0x48(%rbp), %rdi
callq 0x1bfd0
movq -0x98(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
movq (%rsi), %rax
leaq -0x80(%rbp), %rdi
callq *(%rax)
leaq -0x80(%rbp), %rdi
leaq 0x31ae4(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0x99(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5518
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x3593c
jmp 0x35993
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x3596a
movq -0xa8(%rbp), %rdi
callq 0x38b50
movq -0xa8(%rbp), %rdi
movl $0x58, %esi
callq 0x52b0
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x359ba
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x52b0
jmp 0x359c7
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0x38b80
leaq -0x48(%rbp), %rdi
callq 0x1bff0
jmp 0x358c6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5490
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalMaxHeapLiteral(MaxHeapLiteral*, Environment*)
Object *Evaluator::evalMaxHeapLiteral(MaxHeapLiteral *maxHeapLiteral, Environment *env)
{
	MaxHeap *maxHeap = new MaxHeap(maxHeapLiteral->type);

	for (auto elem : maxHeapLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete maxHeap;
			return obj;
		}

		maxHeap->elements.push(obj);
	}

	return maxHeap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x48, %edi
callq 0x52a0
movq %rax, -0xa8(%rbp)
movb $0x1, -0x55(%rbp)
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
leaq -0x48(%rbp), %rdi
callq 0x5130
jmp 0x35a1a
movq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x38be0
jmp 0x35a2c
movb $0x0, -0x55(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
movq -0xa8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x35a80
jmp 0x35b7e
leaq -0x68(%rbp), %rdi
callq 0x1bfd0
movq -0xb0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
movq (%rsi), %rax
leaq -0xa0(%rbp), %rdi
callq *(%rax)
leaq -0xa0(%rbp), %rdi
leaq 0x3193a(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0xb1(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x5518
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x35ae9
jmp 0x35b5f
movq -0x28(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, %rax
je 0x35b17
movq -0xc0(%rbp), %rdi
callq 0x38c60
movq -0xc0(%rbp), %rdi
movl $0x48, %esi
callq 0x52b0
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x35b86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x35b44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
testb $0x1, -0x55(%rbp)
jne 0x35b4c
jmp 0x35b5d
movq -0xa8(%rbp), %rdi
movl $0x48, %esi
callq 0x52b0
jmp 0x35b93
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
leaq -0x80(%rbp), %rsi
callq 0x37720
leaq -0x68(%rbp), %rdi
callq 0x1bff0
jmp 0x35a6a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5490
nopl (%rax)
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalMinHeapLiteral(MinHeapLiteral*, Environment*)
Object *Evaluator::evalMinHeapLiteral(MinHeapLiteral *minHeapLiteral, Environment *env)
{
	MinHeap *minHeap = new MinHeap(minHeapLiteral->type);

	for (auto elem : minHeapLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete minHeap;
			return obj;
		}

		minHeap->elements.push(obj);
	}

	return minHeap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x48, %edi
callq 0x52a0
movq %rax, -0xa8(%rbp)
movb $0x1, -0x55(%rbp)
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
leaq -0x48(%rbp), %rdi
callq 0x5130
jmp 0x35bea
movq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x38ca0
jmp 0x35bfc
movb $0x0, -0x55(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
movq -0xa8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x35c50
jmp 0x35d4e
leaq -0x68(%rbp), %rdi
callq 0x1bfd0
movq -0xb0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32080
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
movq (%rsi), %rax
leaq -0xa0(%rbp), %rdi
callq *(%rax)
leaq -0xa0(%rbp), %rdi
leaq 0x3176a(%rip), %rsi     # 0x67400
callq 0x16920
movb %al, -0xb1(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x5518
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x35cb9
jmp 0x35d2f
movq -0x28(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, %rax
je 0x35ce7
movq -0xc0(%rbp), %rdi
callq 0x38d20
movq -0xc0(%rbp), %rdi
movl $0x48, %esi
callq 0x52b0
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x35d56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x35d14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
testb $0x1, -0x55(%rbp)
jne 0x35d1c
jmp 0x35d2d
movq -0xa8(%rbp), %rdi
movl $0x48, %esi
callq 0x52b0
jmp 0x35d63
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
leaq -0x80(%rbp), %rsi
callq 0x37770
leaq -0x68(%rbp), %rdi
callq 0x1bff0
jmp 0x35c3a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5490
nopl (%rax)
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalBangPrefixExpression(Object*)
Object *Evaluator::evalBangPrefixExpression(Object *right)
{
	if (right == __TRUE)
		return __FALSE;

	else if (right == __FALSE)
		return __TRUE;
	else if (right == __NULL)
		return __TRUE;

	else if (right->type() == INTEGER_OBJ)
	{
		if (((Integer *)right)->value == 0)
			return __TRUE;
		else
			return __FALSE;
	}

	return __FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3083d(%rip), %rcx     # 0x665c8
cmpq (%rcx), %rax
jne 0x35da3
leaq 0x30839(%rip), %rax     # 0x665d0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x35e56
movq -0x18(%rbp), %rax
leaq 0x30822(%rip), %rcx     # 0x665d0
cmpq (%rcx), %rax
jne 0x35dc6
leaq 0x3080e(%rip), %rax     # 0x665c8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x35e56
movq -0x18(%rbp), %rax
leaq 0x307ef(%rip), %rcx     # 0x665c0
cmpq (%rcx), %rax
jne 0x35de6
leaq 0x307eb(%rip), %rax     # 0x665c8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x35e56
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rdi
leaq 0x31422(%rip), %rsi     # 0x67220
callq 0x16920
movb %al, -0x39(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5518
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x35e18
jmp 0x35e42
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x35e32
leaq 0x3079f(%rip), %rax     # 0x665c8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x35e56
leaq 0x30797(%rip), %rax     # 0x665d0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x35e56
jmp 0x35e44
jmp 0x35e46
jmp 0x35e48
leaq 0x30781(%rip), %rax     # 0x665d0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalMinusPrefixExpression(Object*)
Object *Evaluator::evalMinusPrefixExpression(Object *right)
{
	if (right->type() == INTEGER_OBJ)
	{
		Integer *intObj = new Integer(-((Integer *)right)->value);
		return intObj;
	}

	Object *error = new Error("error : unknown operator for " + right->type() + " -> -");
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rdi
leaq 0x31395(%rip), %rsi     # 0x67220
callq 0x16920
movb %al, -0xba(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5518
movb -0xba(%rbp), %al
testb $0x1, %al
jne 0x35eab
jmp 0x35f0c
movl $0x10, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
negl %esi
callq 0x37510
jmp 0x35ed2
movq -0xc8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x36032
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x10, %esi
callq 0x52b0
jmp 0x3603f
movl $0x28, %edi
callq 0x52a0
movq %rax, -0xd0(%rbp)
movb $0x1, -0xb9(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0xb8(%rbp), %rdi
callq *%rax
jmp 0x35f39
leaq 0xfd99(%rip), %rsi      # 0x45cd9
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x1bde0
jmp 0x35f55
leaq 0xfd9b(%rip), %rdx      # 0x45cf7
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1bb10
jmp 0x35f6e
movq -0xd0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2b980
jmp 0x35f80
movb $0x0, -0xb9(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5518
leaq -0x98(%rbp), %rdi
callq 0x5518
leaq -0xb8(%rbp), %rdi
callq 0x5518
movq -0xd0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x36032
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x36014
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x36008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x35ffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5518
leaq -0x98(%rbp), %rdi
callq 0x5518
leaq -0xb8(%rbp), %rdi
callq 0x5518
testb $0x1, -0xb9(%rbp)
jne 0x3601f
jmp 0x36030
movq -0xd0(%rbp), %rdi
movl $0x28, %esi
callq 0x52b0
jmp 0x3603f
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5490
nopl (%rax,%rax)
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::extendFunctionEnv(Function*, std::vector<Object*, std::allocator<Object*>>&, Environment*)
Environment *Evaluator::extendFunctionEnv(Function *fn, std::vector<Object *> &args, Environment *outer)
{
	Environment *env = outer->NewEnclosed();

	for (int i = 0; i < args.size(); i++)
		env->Set(fn->parameters[i]->value, args[i]);

	return env;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2b690
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x373f0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x36bc3
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x388d0
movq (%rax), %rsi
addq $0x48, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5130
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x374f0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rax), %rdx
callq 0x2b8b0
jmp 0x36b98
leaq -0x50(%rbp), %rdi
callq 0x5518
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x36b2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5518
jmp 0x36bd0
movq -0x28(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5490
nopl (%rax)
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalArrayIndexExpression(Array*, Integer*)
Object *Evaluator::evalArrayIndexExpression(Array *array, Integer *index)
{
	int i = index->value;
	auto arr = array->elements;

	if (arr.size() <= i)
		return new Error("error: index " + index->inspect() + " out of range");

	return arr[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x40(%rbp), %rdi
callq 0x37ec0
leaq -0x40(%rbp), %rdi
callq 0x373f0
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
ja 0x37037
movl $0x28, %edi
callq 0x52a0
movq %rax, -0xc0(%rbp)
jmp 0x36f0b
movb $0x1, -0xb1(%rbp)
movq -0x20(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xb0(%rbp), %rdi
callq *%rax
jmp 0x36f28
leaq 0xee6e(%rip), %rsi      # 0x45d9d
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x1bde0
jmp 0x36f44
leaq 0xe810(%rip), %rdx      # 0x4575b
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1bb10
jmp 0x36f5d
movq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2b980
jmp 0x36f6f
movq -0xc0(%rbp), %rax
movb $0x0, -0xb1(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5518
leaq -0x90(%rbp), %rdi
callq 0x5518
leaq -0xb0(%rbp), %rdi
callq 0x5518
movl $0x1, -0xb8(%rbp)
jmp 0x37055
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3706b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x37019
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3700d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x37001
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5518
leaq -0x90(%rbp), %rdi
callq 0x5518
leaq -0xb0(%rbp), %rdi
callq 0x5518
testb $0x1, -0xb1(%rbp)
jne 0x37024
jmp 0x37035
movq -0xc0(%rbp), %rdi
movl $0x28, %esi
callq 0x52b0
jmp 0x3706b
movslq -0x24(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x374f0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xb8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x37fb0
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x37fb0
movq -0x48(%rbp), %rdi
callq 0x5490
nopl (%rax)
// File: pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalHashMapIndexExpression(HashMap*, Object*)
Object *Evaluator::evalHashMapIndexExpression(HashMap *hashMap, Object *index)
{
	HashKey hashKey(index->type(), index->inspect());

	if (hashMap->pairs.find(hashKey) != hashMap->pairs.end())
		return hashMap->pairs[hashKey].value;

	return new Error("error: key not present -> " + index->inspect());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xa0(%rbp), %rdi
callq *%rax
jmp 0x370bd
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x37af0
jmp 0x370d3
leaq -0xa0(%rbp), %rdi
callq 0x5518
leaq -0x80(%rbp), %rdi
callq 0x5518
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0x37e30
movq %rax, -0x118(%rbp)
jmp 0x37102
movq -0x118(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x37e60
movq %rax, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x38040
testb $0x1, %al
jne 0x37140
jmp 0x371cf
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0x38960
movq %rax, -0x120(%rbp)
jmp 0x3715a
movq -0x120(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xc4(%rbp)
jmp 0x372d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x371aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x5518
leaq -0x80(%rbp), %rdi
callq 0x5518
jmp 0x372f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x372ec
movl $0x28, %edi
callq 0x52a0
movq %rax, -0x128(%rbp)
jmp 0x371e2
movb $0x1, -0x109(%rbp)
movq -0x20(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x108(%rbp), %rdi
callq *%rax
jmp 0x371ff
leaq 0xeba5(%rip), %rsi      # 0x45dab
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rdx
callq 0x1bde0
jmp 0x3721b
movq -0x128(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x2b980
jmp 0x37230
movq -0x128(%rbp), %rax
movb $0x0, -0x109(%rbp)
movq %rax, -0x8(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x5518
leaq -0x108(%rbp), %rdi
callq 0x5518
movl $0x1, -0xc4(%rbp)
jmp 0x372d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x372b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x372ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x5518
leaq -0x108(%rbp), %rdi
callq 0x5518
testb $0x1, -0x109(%rbp)
jne 0x372c3
jmp 0x372d4
movq -0x128(%rbp), %rdi
movl $0x28, %esi
callq 0x52b0
jmp 0x372ec
leaq -0x60(%rbp), %rdi
callq 0x37bf0
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x37bf0
movq -0xa8(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Array::inspect[abi:cxx11]()
std::string inspect()
	{
		std::string res = "[";

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

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

		res.push_back(']');

		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x54a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x93bf(%rip), %rsi      # 0x45047
callq 0x134c0
jmp 0x3bc8f
leaq -0x12(%rbp), %rdi
callq 0x52f0
movq -0xa0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x37310
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x37340
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x37370
testb $0x1, %al
jne 0x3bcd7
jmp 0x3bda7
leaq -0x38(%rbp), %rdi
callq 0x373b0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0x3bcfd
leaq 0x9671(%rip), %rdx      # 0x45375
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1bb10
jmp 0x3bd16
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5370
jmp 0x3bd28
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0x38(%rbp), %rdi
callq 0x373d0
jmp 0x3bcc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x52f0
jmp 0x3be1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3be0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3bd99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
jmp 0x3be0e
movq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0x373f0
cmpq $0x0, %rax
je 0x3bdd5
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
movl $0x5d, %esi
callq 0x5230
jmp 0x3bde8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3bdfe
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pranavmodx[P]modlang/src/../header/./object.hpp
// Function: HashSet::inspect[abi:cxx11]()
std::string inspect()
	{
		std::string res = "hashset<> {";

		for (auto pair : pairs)
			res += pair.second->inspect() + ", ";

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

		res.push_back('}');

		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x54a0
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rdx
leaq 0x8ec4(%rip), %rsi      # 0x4537c
callq 0x134c0
jmp 0x3c4bf
leaq -0x12(%rbp), %rdi
callq 0x52f0
movq -0xe0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3c7c0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x37d80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x380c0
testb $0x1, %al
jne 0x3c507
jmp 0x3c613
leaq -0x38(%rbp), %rdi
callq 0x3c7f0
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
callq 0x3a7c0
jmp 0x3c521
movq -0x48(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xc8(%rbp), %rdi
callq *%rax
jmp 0x3c537
leaq 0x8e37(%rip), %rdx      # 0x45375
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1bb10
jmp 0x3c553
movq -0xd8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x5370
jmp 0x3c568
leaq -0xa8(%rbp), %rdi
callq 0x5518
leaq -0xc8(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x37bd0
leaq -0x38(%rbp), %rdi
callq 0x3c820
jmp 0x3c4f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x52f0
jmp 0x3c686
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3c67a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3c605
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3c5f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5518
leaq -0xc8(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x37bd0
jmp 0x3c67a
movq -0xe0(%rbp), %rdi
addq $0x8, %rdi
callq 0x37580
cmpq $0x0, %rax
je 0x3c641
movq -0xd8(%rbp), %rdi
callq 0x5330
movq -0xd8(%rbp), %rdi
callq 0x5330
movq -0xd8(%rbp), %rdi
movl $0x7d, %esi
callq 0x5230
jmp 0x3c654
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3c66a
movq -0xd8(%rbp), %rdi
callq 0x5518
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x5518
movq -0x20(%rbp), %rdi
callq 0x5490
nop
// File: pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Stack::inspect[abi:cxx11]()
std::string inspect()
	{
		if (elements.empty())
			return "stack<> {top: empty}";

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

		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x8, %rdi
callq 0x37890
testb $0x1, %al
jne 0x3c995
jmp 0x3c9e6
leaq -0x11(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x54a0
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0x942c(%rip), %rsi      # 0x45de3
callq 0x134c0
jmp 0x3c9be
leaq -0x11(%rbp), %rdi
callq 0x52f0
jmp 0x3ca94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x52f0
jmp 0x3caa1
movq -0x70(%rbp), %rdi
movb $0x0, -0x25(%rbp)
addq $0x8, %rdi
callq 0x3d360
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq *%rax
movq -0x90(%rbp), %rdx
leaq 0x93dc(%rip), %rsi      # 0x45df8
leaq -0x48(%rbp), %rdi
callq 0x1bde0
jmp 0x3ca27
movq -0x80(%rbp), %rdi
leaq 0x93af(%rip), %rdx      # 0x45de1
leaq -0x48(%rbp), %rsi
callq 0x1bb10
jmp 0x3ca3d
leaq -0x48(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x3ca92
jmp 0x3ca89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3ca7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
jmp 0x3caa1
movq -0x80(%rbp), %rdi
callq 0x5518
jmp 0x3ca94
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopw (%rax,%rax)
// File: pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Queue::inspect[abi:cxx11]()
std::string inspect()
	{
		if (elements.empty())
			return "queue<> {front: empty}";

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

		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x8, %rdi
callq 0x378d0
testb $0x1, %al
jne 0x3d675
jmp 0x3d6c6
leaq -0x11(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x54a0
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0x8770(%rip), %rsi      # 0x45e07
callq 0x134c0
jmp 0x3d69e
leaq -0x11(%rbp), %rdi
callq 0x52f0
jmp 0x3d774
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x52f0
jmp 0x3d781
movq -0x70(%rbp), %rdi
movb $0x0, -0x25(%rbp)
addq $0x8, %rdi
callq 0x3d790
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq *%rax
movq -0x90(%rbp), %rdx
leaq 0x8722(%rip), %rsi      # 0x45e1e
leaq -0x48(%rbp), %rdi
callq 0x1bde0
jmp 0x3d707
movq -0x80(%rbp), %rdi
leaq 0x86cf(%rip), %rdx      # 0x45de1
leaq -0x48(%rbp), %rsi
callq 0x1bb10
jmp 0x3d71d
leaq -0x48(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x3d772
jmp 0x3d769
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3d75e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
jmp 0x3d781
movq -0x80(%rbp), %rdi
callq 0x5518
jmp 0x3d774
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopw (%rax,%rax)
// File: pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Deque::inspect[abi:cxx11]()
std::string inspect()
	{
		if (elements.empty())
			return "deque<> {front: empty, back: empty}";

		std::string res = "deque<> {front: " + elements.front()->inspect() + ", back: " + elements.back()->inspect() + "}";

		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
addq $0x8, %rdi
callq 0x379f0
testb $0x1, %al
jne 0x3d86e
jmp 0x3d8c2
leaq -0x11(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x54a0
movq -0xe0(%rbp), %rdi
movq -0xe8(%rbp), %rdx
leaq 0x859c(%rip), %rsi      # 0x45e2f
callq 0x134c0
jmp 0x3d89a
leaq -0x11(%rbp), %rdi
callq 0x52f0
jmp 0x3da49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x52f0
jmp 0x3da59
movq -0xd0(%rbp), %rdi
movb $0x0, -0x25(%rbp)
addq $0x8, %rdi
callq 0x3d7b0
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq *%rax
movq -0xf0(%rbp), %rdx
leaq 0x8555(%rip), %rsi      # 0x45e53
leaq -0x88(%rbp), %rdi
callq 0x1bde0
jmp 0x3d90c
leaq 0x8551(%rip), %rdx      # 0x45e64
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1bb10
jmp 0x3d925
movq -0xd0(%rbp), %rdi
addq $0x8, %rdi
callq 0x3d380
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xc8(%rbp), %rdi
callq *%rax
jmp 0x3d94a
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x1bb80
jmp 0x3d960
movq -0xe0(%rbp), %rdi
leaq 0x8473(%rip), %rdx      # 0x45de1
leaq -0x48(%rbp), %rsi
callq 0x1bb10
jmp 0x3d979
leaq -0x48(%rbp), %rdi
callq 0x5518
leaq -0xc8(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0xa8(%rbp), %rdi
callq 0x5518
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x3da47
jmp 0x3da3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3da2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3da21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3da18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3da0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
leaq -0xc8(%rbp), %rdi
callq 0x5518
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0xa8(%rbp), %rdi
callq 0x5518
jmp 0x3da59
movq -0xe0(%rbp), %rdi
callq 0x5518
jmp 0x3da49
movq -0xd8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pranavmodx[P]modlang/src/../header/./object.hpp
// Function: MaxHeapCompareFn::operator()(Object*, Object*)
bool operator()(Object *obj1, Object *obj2)
	{
		if (obj1->type() == INTEGER_OBJ)
			return ((Integer *)obj1)->value < ((Integer *)obj2)->value;
		else if (obj1->type() == STRING_OBJ)
			return ((String *)obj1)->value < ((String *)obj2)->value;
		
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *(%rax)
leaq -0x40(%rbp), %rdi
leaq 0x27ff4(%rip), %rsi     # 0x67220
callq 0x16920
movb %al, -0x61(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5518
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3f246
jmp 0x3f25e
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3f2b2
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
leaq -0x60(%rbp), %rdi
callq *(%rax)
leaq -0x60(%rbp), %rdi
leaq 0x27fea(%rip), %rsi     # 0x67260
callq 0x16920
movb %al, -0x62(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5518
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x3f290
jmp 0x3f2ac
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x3f2c0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3f2b2
jmp 0x3f2ae
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: fabianp[P]ProxASAGA/proxasaga_atomic.cpp
// Function: partial_gradient(double, double)
double inline partial_gradient(double p, double b) {
    // partial gradient of logistic loss
    double phi, exp_t;
    p = p * b;
    if (p > 0)
        phi = 1. / (1. + exp(-p));
    else {
        exp_t = exp(p);
        phi = exp_t / (1. + exp_t);
    }
    return (phi - 1) * b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xc45f
movsd -0x8(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0xaf30
movsd 0x4bc8(%rip), %xmm1     # 0x11010
addsd %xmm0, %xmm1
movsd 0x4bbc(%rip), %xmm0     # 0x11010
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xc489
movsd -0x8(%rbp), %xmm0
callq 0xaf30
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x4b95(%rip), %xmm1     # 0x11010
addsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x4b7a(%rip), %xmm1     # 0x11010
subsd %xmm1, %xmm0
mulsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop