LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::getFunctionOverloads(token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const std::map<const size_t, std::map<const signature_t, ptr_function_t>> &symbol_t::getFunctionOverloads(const token_t *token, trace_t &stack_trace) const
{
	switch (d->type)
	{
	case value_type_enum::FUNCTION:
		return std::get<wrapper_t>(d->value).map;
	case value_type_enum::OBJECT:
		return std::get<object_t>(d->value).getVariable(parser_t::HASH_CALL, token, stack_trace).getFunctionOverloads(token, stack_trace);
	default:
		throw rossa_error_t(_NOT_FUNCTION_, *token, stack_trace);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
subl $-0x8, %eax
je 0x886b1
jmp 0x8868e
movl -0x5c(%rbp), %eax
subl $-0x6, %eax
jne 0x886f1
jmp 0x88698
movq -0x68(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, -0x8(%rbp)
jmp 0x88799
movq -0x68(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bd70
movq %rax, %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x15d4a5(%rip), %rsi    # 0x1e5b78
callq 0x7ddd0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x88660
movq %rax, -0x8(%rbp)
jmp 0x88799
movb $0x1, -0x55(%rbp)
movl $0xa8, %edi
callq 0x112b0
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x119d0
movq -0x70(%rbp), %rdx
leaq 0xc99bf(%rip), %rsi     # 0x1520da
leaq -0x40(%rbp), %rdi
callq 0x24740
jmp 0x88726
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rsi
callq 0x9c360
jmp 0x8873d
movq -0x78(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x158534(%rip), %rsi    # 0x1e0c80
leaq -0x2ddb3(%rip), %rdx    # 0x5a9a0
callq 0x11970
jmp 0x887af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8877d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x11360
leaq -0x41(%rbp), %rdi
callq 0x11600
testb $0x1, -0x55(%rbp)
jne 0x8878e
jmp 0x88797
movq -0x78(%rbp), %rdi
callq 0x11420
jmp 0x887a6
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x119c0
nop
// File: Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::hasVarg(token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const bool symbol_t::hasVarg(const token_t *token, trace_t &stack_trace) const
{
	switch (d->type)
	{
	case value_type_enum::FUNCTION:
		return std::get<wrapper_t>(d->value).varg != nullptr;
	case value_type_enum::OBJECT:
		return std::get<object_t>(d->value).getVariable(parser_t::HASH_CALL, token, stack_trace).hasVarg(token, stack_trace);
	default:
		throw rossa_error_t(_NOT_FUNCTION_, *token, stack_trace);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
subl $-0x8, %eax
je 0x88812
jmp 0x887de
movl -0x5c(%rbp), %eax
subl $-0x6, %eax
jne 0x88853
jmp 0x887e8
movq -0x68(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8bdd0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x888fb
movq -0x68(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bd70
movq %rax, %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x15d344(%rip), %rsi    # 0x1e5b78
callq 0x7ddd0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x887b0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x888fb
movb $0x1, -0x55(%rbp)
movl $0xa8, %edi
callq 0x112b0
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x119d0
movq -0x70(%rbp), %rdx
leaq 0xc985d(%rip), %rsi     # 0x1520da
leaq -0x40(%rbp), %rdi
callq 0x24740
jmp 0x88888
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rsi
callq 0x9c360
jmp 0x8889f
movq -0x78(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x1583d2(%rip), %rsi    # 0x1e0c80
leaq -0x2df15(%rip), %rdx    # 0x5a9a0
callq 0x11970
jmp 0x88912
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x888df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x11360
leaq -0x41(%rbp), %rdi
callq 0x11600
testb $0x1, -0x55(%rbp)
jne 0x888f0
jmp 0x888f9
movq -0x78(%rbp), %rdi
callq 0x11420
jmp 0x88909
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::addFunctions(symbol_t const*, token_t const*) const
void symbol_t::addFunctions(const symbol_t *b, const token_t *token) const
{
	auto fs = std::get<wrapper_t>(b->d->value).map;
	for (auto &f : fs)
	{
		for (auto &t : f.second)
		{
			std::get<wrapper_t>(d->value).map[f.first][t.first] = t.second;
		}
	}
	if (std::get<wrapper_t>(b->d->value).varg != nullptr)
		std::get<wrapper_t>(d->value).varg = std::get<wrapper_t>(b->d->value).varg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x84480
leaq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x8c040
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x84510
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8c070
testb $0x1, %al
jne 0x8a996
jmp 0x8aaa6
leaq -0x58(%rbp), %rdi
callq 0x8c0a0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x84560
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x84590
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x845c0
testb $0x1, %al
jne 0x8a9df
jmp 0x8aa96
leaq -0x78(%rbp), %rdi
callq 0x845f0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movq %rcx, -0x88(%rbp)
movq -0x88(%rbp), %rcx
addq $0x18, %rcx
movq %rcx, -0xb0(%rbp)
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, -0xa8(%rbp)
jmp 0x8aa20
movq -0xa8(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x8c170
movq %rax, -0xb8(%rbp)
jmp 0x8aa39
movq -0xb8(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x8c250
movq %rax, -0xc0(%rbp)
jmp 0x8aa55
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x8be20
leaq -0x78(%rbp), %rdi
callq 0x846a0
jmp 0x8a9c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x846d0
jmp 0x8ab49
jmp 0x8aa98
leaq -0x58(%rbp), %rdi
callq 0x8c0c0
jmp 0x8a980
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, -0xc8(%rbp)
jmp 0x8aabf
movq -0xc8(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8bdd0
testb $0x1, %al
jne 0x8aad9
jmp 0x8ab37
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, -0xd0(%rbp)
jmp 0x8aaf2
movq -0xa0(%rbp), %rax
movq -0xd0(%rbp), %rcx
addq $0x30, %rcx
movq %rcx, -0xe0(%rbp)
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, -0xd8(%rbp)
jmp 0x8ab20
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdi
addq $0x30, %rdi
callq 0x8be20
leaq -0x48(%rbp), %rdi
callq 0x846d0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::getVARGFunction(token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const ptr_function_t &symbol_t::getVARGFunction(const token_t *token, trace_t &stack_trace) const
{
	if (d->type == value_type_enum::FUNCTION)
	{
		return std::get<wrapper_t>(d->value).varg;
	}
	if (d->type == value_type_enum::OBJECT)
	{
		return std::get<object_t>(d->value).getVariable(parser_t::HASH_CALL, token, stack_trace).getVARGFunction(token, stack_trace);
	}
	throw rossa_error_t(_NOT_FUNCTION_, *token, stack_trace);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rax
cmpl $-0x6, (%rax)
jne 0x8aba1
movq -0x60(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0x8ac95
movq -0x60(%rbp), %rax
movq (%rax), %rax
cmpl $-0x8, (%rax)
jne 0x8abed
movq -0x60(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bd70
movq %rax, %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x15afa9(%rip), %rsi    # 0x1e5b78
callq 0x7ddd0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8ab60
movq %rax, -0x8(%rbp)
jmp 0x8ac95
movb $0x1, -0x55(%rbp)
movl $0xa8, %edi
callq 0x112b0
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x119d0
movq -0x68(%rbp), %rdx
leaq 0xc74c3(%rip), %rsi     # 0x1520da
leaq -0x40(%rbp), %rdi
callq 0x24740
jmp 0x8ac22
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rsi
callq 0x9c360
jmp 0x8ac39
movq -0x70(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x156038(%rip), %rsi    # 0x1e0c80
leaq -0x302af(%rip), %rdx    # 0x5a9a0
callq 0x11970
jmp 0x8aca8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8ac79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x11360
leaq -0x41(%rbp), %rdi
callq 0x11600
testb $0x1, -0x55(%rbp)
jne 0x8ac8a
jmp 0x8ac93
movq -0x70(%rbp), %rdi
callq 0x11420
jmp 0x8ac9f
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x119c0
nopl (%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::pureEquals(symbol_t const*, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const bool symbol_t::pureEquals(const symbol_t *b, const token_t *token, trace_t &stack_trace) const
{
	if (d->type != b->d->type)
	{
		return false;
	}
	switch (d->type)
	{
	case value_type_enum::OBJECT:
		return std::get<object_t>(d->value) == std::get<object_t>(b->d->value);
	default:
		return this->equals(b, token, stack_trace);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x8b7a6
movb $0x0, -0x1(%rbp)
jmp 0x8b807
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
subl $-0x8, %eax
jne 0x8b7ed
jmp 0x8b7b6
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bd70
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bd70
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7dd60
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8b807
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x8ace0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::shift() const
void symbol_t::shift() const
{
	if (d->type != value_type_enum::FUNCTION)
	{
		return;
	}
	for (auto &e : std::get<wrapper_t>(d->value).map)
	{
		for (auto &f : e.second)
		{
			f.second->shift();
		}
	}
	if (std::get<wrapper_t>(d->value).varg != nullptr)
	{
		std::get<wrapper_t>(d->value).varg->shift();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rax
cmpl $-0x6, (%rax)
je 0x8ba01
jmp 0x8bb12
movq -0x50(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8c040
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x84510
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8c070
testb $0x1, %al
jne 0x8ba45
jmp 0x8bac8
leaq -0x18(%rbp), %rdi
callq 0x8c0a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x84560
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x84590
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x845c0
testb $0x1, %al
jne 0x8ba8b
jmp 0x8bab8
leaq -0x38(%rbp), %rdi
callq 0x845f0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x38430
movq %rax, %rdi
callq 0x382b0
leaq -0x38(%rbp), %rdi
callq 0x846a0
jmp 0x8ba78
jmp 0x8baba
leaq -0x18(%rbp), %rdi
callq 0x8c0c0
jmp 0x8ba2f
movq -0x50(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8bdd0
testb $0x1, %al
jne 0x8baee
jmp 0x8bb12
movq -0x50(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8bdb0
movq %rax, %rdi
addq $0x30, %rdi
callq 0x38430
movq %rax, %rdi
callq 0x382b0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/wrapper/wrapper.cpp
// Function: wrapper_t::hash() const
const unsigned int wrapper_t::hash() const
{
	int h = 0;
	int i = 0;
	for (auto &e : map)
	{
		for (auto &f : e.second)
		{
			h = (h + (f.second->key << i++)) % 0xFFFFFFFF;
		}
	}
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9c2a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9c2d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x99110
testb $0x1, %al
jne 0x9c1e2
jmp 0x9c295
leaq -0x20(%rbp), %rdi
callq 0x99190
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x9c300
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x9c330
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x994a0
testb $0x1, %al
jne 0x9c228
jmp 0x9c285
leaq -0x40(%rbp), %rdi
callq 0x99520
movq %rax, -0x50(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x38430
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq 0x10(%rcx), %rdx
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x99540
jmp 0x9c215
jmp 0x9c287
leaq -0x20(%rbp), %rdi
callq 0x991b0
jmp 0x9c1cc
movl -0xc(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator=(number_t const&)
void number_t::operator=(const number_t &n) noexcept
{
	type = n.type;
	switch (type)
	{
	case DOUBLE_NUM:
		valueDouble = n.valueDouble;
		break;
	case LONG_NUM:
		valueLong = n.valueLong;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x9c5a4
jmp 0x9c59a
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x9c5b6
jmp 0x9c5c4
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
jmp 0x9c5c4
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator+=(number_t const&)
void number_t::operator+=(const number_t &n) noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		valueDouble += n.getDouble();
		validate();
		break;
	case LONG_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			valueDouble = static_cast<long_double_t>(valueLong) + n.valueDouble;
			type = DOUBLE_NUM;
			validate();
			break;
		case LONG_NUM:
			valueLong += n.valueLong;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x9c5fe
jmp 0x9c5f4
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x9c61a
jmp 0x9c66a
movq -0x10(%rbp), %rdi
callq 0x9c670
movq -0x20(%rbp), %rdi
addsd (%rdi), %xmm0
movsd %xmm0, (%rdi)
callq 0x9c440
jmp 0x9c66a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x9c634
jmp 0x9c62a
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x9c657
jmp 0x9c668
movq -0x20(%rbp), %rdi
cvtsi2sdq (%rdi), %xmm0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rdi)
movl $0x0, 0x8(%rdi)
callq 0x9c440
jmp 0x9c668
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x9c66a
addq $0x30, %rsp
popq %rbp
retq
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::getDouble() const
const long_double_t number_t::getDouble() const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		return valueDouble;
	case LONG_NUM:
		return static_cast<long_double_t>(valueLong);
	default:
		return NAN;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x9c696
jmp 0x9c68c
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x9c6a5
jmp 0x9c6b5
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9c6c2
movq -0x20(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9c6c2
movsd 0xb5bfb(%rip), %xmm0    # 0x1522b8
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::getLong() const
const long_int_t number_t::getLong() const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		return static_cast<long_int_t>(valueDouble);
	case LONG_NUM:
		return valueLong;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x9c7a6
jmp 0x9c79c
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x9c7b5
jmp 0x9c7c2
movq -0x20(%rbp), %rax
cvttsd2si (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9c7ca
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9c7ca
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator+() const
const number_t number_t::operator+() const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		return number_t::Double(valueDouble);
	case LONG_NUM:
		return number_t::Long(valueLong);
	}
	return number_t();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x9c7fa
jmp 0x9c7f0
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x9c81a
jmp 0x9c83a
movq -0x48(%rbp), %rdi
callq 0x9c510
movl %edx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9c843
movq -0x48(%rbp), %rdi
callq 0x9c540
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9c843
leaq -0x10(%rbp), %rdi
callq 0x9c4f0
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x50, %rsp
popq %rbp
retq
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator-() const
const number_t number_t::operator-() const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		return number_t::Double(-valueDouble);
	case LONG_NUM:
		return number_t::Long(-valueLong);
	}
	return number_t();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
testl %eax, %eax
je 0x9c87a
jmp 0x9c870
movl -0x4c(%rbp), %eax
subl $0x1, %eax
je 0x9c8b2
jmp 0x9c8e0
movq -0x58(%rbp), %rax
movsd (%rax), %xmm0
movaps 0xb5a37(%rip), %xmm1    # 0x1522c0
pxor %xmm1, %xmm0
movlpd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9c510
movl %edx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9c8e9
movq -0x58(%rbp), %rax
movq (%rax), %rax
negq %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9c540
movl %edx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9c8e9
leaq -0x10(%rbp), %rdi
callq 0x9c4f0
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator+(number_t const&) const
const number_t number_t::operator+(const number_t &n) const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return number_t::Double(valueDouble + n.valueDouble);
		case LONG_NUM:
			return number_t::Double(valueDouble + static_cast<long_double_t>(n.valueLong));
		}
		break;
	case LONG_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return number_t::Double(static_cast<long_double_t>(valueLong) + n.valueDouble);
		case LONG_NUM:
			return number_t::Long(valueLong + n.valueLong);
		}
	}
	return number_t();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x84(%rbp)
testl %eax, %eax
je 0x9c941
jmp 0x9c92d
movl -0x84(%rbp), %eax
subl $0x1, %eax
je 0x9c9e5
jmp 0x9ca7c
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x94(%rbp)
testl %eax, %eax
je 0x9c961
jmp 0x9c954
movl -0x94(%rbp), %eax
subl $0x1, %eax
je 0x9c9a0
jmp 0x9c9e0
movq -0x90(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9c510
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9ca85
movq -0x90(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
cvtsi2sdq (%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9c510
movl %edx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9ca85
jmp 0x9ca7c
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x98(%rbp)
testl %eax, %eax
je 0x9ca05
jmp 0x9c9f8
movl -0x98(%rbp), %eax
subl $0x1, %eax
je 0x9ca42
jmp 0x9ca7a
movq -0x90(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9c510
movl %edx, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9ca85
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9c540
movl %edx, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9ca85
jmp 0x9ca7c
leaq -0x10(%rbp), %rdi
callq 0x9c4f0
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::pow(number_t const&) const
const number_t number_t::pow(const number_t &n) const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return number_t::Double(std::pow(valueDouble, n.valueDouble));
		case LONG_NUM:
			return number_t::Double(std::pow(valueDouble, static_cast<long_double_t>(n.valueLong)));
		}
		break;
	case LONG_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return number_t::Double(std::pow(static_cast<long_double_t>(valueLong), n.valueDouble));
		case LONG_NUM:
			return number_t::Double(std::pow(valueLong, n.valueLong));
		}
	}
	return number_t();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x84(%rbp)
testl %eax, %eax
je 0x9d091
jmp 0x9d07d
movl -0x84(%rbp), %eax
subl $0x1, %eax
je 0x9d13a
jmp 0x9d1ea
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x94(%rbp)
testl %eax, %eax
je 0x9d0b4
jmp 0x9d0a4
movl -0x94(%rbp), %eax
subl $0x1, %eax
je 0x9d0f4
jmp 0x9d135
movq -0x90(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
callq 0x119a0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9c510
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9d1f3
movq -0x90(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
cvtsi2sdq (%rax), %xmm1
callq 0x119a0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9c510
movl %edx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9d1f3
jmp 0x9d1ea
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x98(%rbp)
testl %eax, %eax
je 0x9d15d
jmp 0x9d14d
movl -0x98(%rbp), %eax
subl $0x1, %eax
je 0x9d19b
jmp 0x9d1e8
movq -0x90(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
callq 0x119a0
movsd %xmm0, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9c510
movl %edx, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9d1f3
movq -0x90(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x9db70
movsd %xmm0, -0xa0(%rbp)
jmp 0x9d1bb
movsd -0xa0(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9c510
movl %edx, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9d1f3
jmp 0x9d1ea
leaq -0x10(%rbp), %rdi
callq 0x9c4f0
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x24b70
nopl (%rax,%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator%(number_t const&) const
const number_t number_t::operator%(const number_t &n) const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return number_t::Double(std::fmod(valueDouble, n.valueDouble));
		case LONG_NUM:
			return number_t::Double(std::fmod(valueDouble, static_cast<long_double_t>(n.valueLong)));
		}
		break;
	case LONG_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return number_t::Double(std::fmod(static_cast<long_double_t>(valueLong), n.valueDouble));
		case LONG_NUM:
			return number_t::Long(valueLong % n.valueLong);
		}
	}
	return number_t();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x84(%rbp)
testl %eax, %eax
je 0x9d251
jmp 0x9d23d
movl -0x84(%rbp), %eax
subl $0x1, %eax
je 0x9d2fa
jmp 0x9d394
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x94(%rbp)
testl %eax, %eax
je 0x9d274
jmp 0x9d264
movl -0x94(%rbp), %eax
subl $0x1, %eax
je 0x9d2b4
jmp 0x9d2f5
movq -0x90(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
callq 0x117a0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9c510
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9d39d
movq -0x90(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
cvtsi2sdq (%rax), %xmm1
callq 0x117a0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9c510
movl %edx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9d39d
jmp 0x9d394
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x98(%rbp)
testl %eax, %eax
je 0x9d31a
jmp 0x9d30d
movl -0x98(%rbp), %eax
subl $0x1, %eax
je 0x9d358
jmp 0x9d392
movq -0x90(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
callq 0x117a0
movsd %xmm0, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9c510
movl %edx, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9d39d
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
cqto
idivq %rcx
movq %rdx, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9c540
movl %edx, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x9d39d
jmp 0x9d394
leaq -0x10(%rbp), %rdi
callq 0x9c4f0
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator==(number_t const&) const
const bool number_t::operator==(const number_t &n) const noexcept
{
	if (type != n.type)
		return false;
	switch (type)
	{
	case DOUBLE_NUM:
		return valueDouble == n.valueDouble;
	case LONG_NUM:
		return valueLong == n.valueLong;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x9d3d6
movb $0x0, -0x1(%rbp)
jmp 0x9d42b
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x9d3f0
jmp 0x9d3e6
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x9d40f
jmp 0x9d427
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9d42b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9d42b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator<(number_t const&) const
const bool number_t::operator<(const number_t &n) const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return valueDouble < n.valueDouble;
		case LONG_NUM:
			return valueDouble < n.valueLong;
		}
		break;
	case LONG_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return valueLong < n.valueDouble;
		case LONG_NUM:
			return valueLong < n.valueLong;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x9d49d
jmp 0x9d490
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x9d4f6
jmp 0x9d549
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x9d4b7
jmp 0x9d4ad
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x9d4d5
jmp 0x9d4f4
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9d54d
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9d54d
jmp 0x9d549
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x9d510
jmp 0x9d506
movl -0x30(%rbp), %eax
subl $0x1, %eax
je 0x9d52f
jmp 0x9d547
movq -0x28(%rbp), %rax
cvtsi2sdq (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9d54d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9d54d
jmp 0x9d549
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::toString[abi:cxx11]() const
const std::string number_t::toString() const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
	{
		std::stringstream ss;
		ss.precision(std::numeric_limits<long_double_t>::digits10);
		ss << std::fixed << valueDouble;
		std::string ret = ss.str();
		while (ret.back() == '0')
			ret.pop_back();
		if (ret.back() == '.')
			ret.pop_back();
		return ret;
	}
	case LONG_NUM:
		return std::to_string(valueLong);
	default:
		return "<undefined>";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x1a0(%rbp)
testl %eax, %eax
je 0x9d922
jmp 0x9d90e
movl -0x1a0(%rbp), %eax
subl $0x1, %eax
je 0x9da0e
jmp 0x9da28
leaq -0x198(%rbp), %rdi
callq 0x113f0
jmp 0x9d930
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
movl $0xf, %esi
callq 0x9dba0
jmp 0x9d94f
leaq -0x188(%rbp), %rdi
leaq 0x273(%rip), %rsi       # 0x9dbd0
callq 0x111b0
movq %rax, -0x1c0(%rbp)
jmp 0x9d96b
movq -0x1c0(%rbp), %rdi
movq -0x1a8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x11a60
jmp 0x9d984
movq -0x1b8(%rbp), %rdi
movb $0x0, -0x199(%rbp)
leaq -0x198(%rbp), %rsi
callq 0x11550
jmp 0x9d9a0
jmp 0x9d9a2
movq -0x1b8(%rbp), %rdi
callq 0x11410
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x9d9c4
movq -0x1b8(%rbp), %rdi
callq 0x116f0
jmp 0x9d9a2
movq -0x1b8(%rbp), %rdi
callq 0x11410
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x9d9e4
movq -0x1b8(%rbp), %rdi
callq 0x116f0
movb $0x1, -0x199(%rbp)
testb $0x1, -0x199(%rbp)
jne 0x9da00
movq -0x1b8(%rbp), %rdi
callq 0x11360
leaq -0x198(%rbp), %rdi
callq 0x11430
jmp 0x9da63
movq -0x1b8(%rbp), %rdi
movq -0x1a8(%rbp), %rax
movq (%rax), %rsi
callq 0x9dc00
jmp 0x9da26
jmp 0x9da63
leaq -0x19a(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x119d0
movq -0x1b8(%rbp), %rdi
movq -0x1c8(%rbp), %rdx
leaq 0xb4880(%rip), %rsi     # 0x1522d0
callq 0x24740
jmp 0x9da57
leaq -0x19a(%rbp), %rdi
callq 0x11600
movq -0x1b0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rdi
callq 0x24b70
nopl (%rax,%rax)
// File: Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::toCodeString[abi:cxx11]() const
const std::string number_t::toCodeString() const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		return "Double@" + std::to_string(valueDouble);
	case LONG_NUM:
		return "Long@" + std::to_string(valueLong);
	default:
		return "<undefined>";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x58(%rbp)
testl %eax, %eax
je 0x9dabc
jmp 0x9dab2
movl -0x58(%rbp), %eax
subl $0x1, %eax
je 0x9daf0
jmp 0x9db23
movq -0x60(%rbp), %rax
movsd (%rax), %xmm0
leaq -0x30(%rbp), %rdi
callq 0x9dd30
jmp 0x9dacf
movq -0x70(%rbp), %rdi
leaq 0xb4802(%rip), %rsi     # 0x1522dc
leaq -0x30(%rbp), %rdx
callq 0x24cb0
jmp 0x9dae5
leaq -0x30(%rbp), %rdi
callq 0x11360
jmp 0x9db4f
movq -0x60(%rbp), %rax
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x9dc00
jmp 0x9db02
movq -0x70(%rbp), %rdi
leaq 0xb47d7(%rip), %rsi     # 0x1522e4
leaq -0x50(%rbp), %rdx
callq 0x24cb0
jmp 0x9db18
leaq -0x50(%rbp), %rdi
callq 0x11360
jmp 0x9db4f
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x119d0
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0xb4791(%rip), %rsi     # 0x1522d0
callq 0x24740
jmp 0x9db46
leaq -0x51(%rbp), %rdi
callq 0x11600
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x24b70
nopw %cs:(%rax,%rax)
nop
// File: Nallantli[P]Rossa/main/rossa/util/util.cpp
// Function: util::getRuntimePath[abi:cxx11]()
const std::filesystem::path util::getRuntimePath()
{
#ifndef _WIN32
    char result[PATH_MAX];
    ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);
    return std::string(result, (count > 0) ? count : 0);
#else
    wchar_t path[MAX_PATH] = {0};
    GetModuleFileNameW(NULL, path, MAX_PATH);
    return path;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1080, %rsp           # imm = 0x1080
movq %rdi, -0x1068(%rbp)
movq %rdi, %rax
movq %rax, -0x1060(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rsi
leaq 0xb3dbe(%rip), %rdi     # 0x15247c
movl $0x1000, %edx           # imm = 0x1000
callq 0x115e0
movq %rax, -0x1018(%rbp)
leaq -0x1010(%rbp), %rax
movq %rax, -0x1058(%rbp)
cmpq $0x0, -0x1018(%rbp)
jle 0x9e6f7
movq -0x1018(%rbp), %rax
movq %rax, -0x1070(%rbp)
jmp 0x9e702
xorl %eax, %eax
movq %rax, -0x1070(%rbp)
jmp 0x9e702
movq -0x1070(%rbp), %rax
movq %rax, -0x1080(%rbp)
leaq -0x1039(%rbp), %rdi
movq %rdi, -0x1078(%rbp)
callq 0x119d0
movq -0x1058(%rbp), %rsi
movq -0x1080(%rbp), %rdx
movq -0x1078(%rbp), %rcx
leaq -0x1038(%rbp), %rdi
callq 0x11670
jmp 0x9e746
movq -0x1068(%rbp), %rdi
leaq -0x1038(%rbp), %rsi
movl $0x2, %edx
callq 0x5a220
jmp 0x9e760
leaq -0x1038(%rbp), %rdi
callq 0x11360
leaq -0x1039(%rbp), %rdi
callq 0x11600
movq -0x1060(%rbp), %rax
addq $0x1080, %rsp           # imm = 0x1080
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
jmp 0x9e7ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
leaq -0x1038(%rbp), %rdi
callq 0x11360
leaq -0x1039(%rbp), %rdi
callq 0x11600
movq -0x1048(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: ContainerNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ContainerNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "CONTAINER : " << s.toCodeString() << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x98(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x11230d(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd2cc6
movq 0x1122fb(%rip), %rdi    # 0x1e4fa0
leaq 0x80abc(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x80ab0(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd2cec
movq 0x1122d3(%rip), %rdi    # 0x1e4fa0
leaq 0x80a9e(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x80a92(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x90(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd27b0
movq -0xa0(%rbp), %rsi
leaq 0x80a5b(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd2d20
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd2d36
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x112251(%rip), %rdi    # 0x1e4fa0
leaq 0x80a28(%rip), %rsi     # 0x15377e
callq 0x11560
movq -0x90(%rbp), %rsi
movq %rax, -0xb8(%rbp)
addq $0xa8, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x89eb0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x114e0
movq %rax, -0xa8(%rbp)
jmp 0xd2d9f
movq -0xa8(%rbp), %rdi
leaq 0x7f728(%rip), %rsi     # 0x1524d5
callq 0x11560
jmp 0xd2db4
leaq -0x88(%rbp), %rdi
callq 0x11360
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd2dec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xd2e0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopl (%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: VectorNode::genParser() const
ptr_instruction_t VectorNode::genParser() const
{
	std::vector<ptr_instruction_t> ins;
	for (auto &n : args)
		if (n != nullptr)
			ins.push_back(n->genParser());
	if (scoped)
		return std::make_shared<ScopeI>(ins, token);
	return std::make_shared<SequenceI>(ins, token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe52f0
movq -0x98(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe5310
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe5340
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xd2fa9
jmp 0xd3038
leaq -0x38(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe53d0
testb $0x1, %al
jne 0xd2fc9
jmp 0xd3028
movq -0x48(%rbp), %rdi
callq 0x2d030
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0xd2fe3
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe5400
jmp 0xd2ff2
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
jmp 0xd3028
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd30e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
jmp 0xd30e0
jmp 0xd302a
leaq -0x38(%rbp), %rdi
callq 0xe5430
jmp 0xd2f93
movq -0x98(%rbp), %rax
testb $0x1, 0xc0(%rax)
je 0xd3084
movq -0x98(%rbp), %rdx
addq $0x28, %rdx
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe5450
jmp 0xd3062
movq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe54d0
leaq -0x78(%rbp), %rdi
callq 0xe5500
movl $0x1, -0x7c(%rbp)
jmp 0xd30c7
movq -0x98(%rbp), %rdx
addq $0x28, %rdx
leaq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe5520
jmp 0xd30a1
movq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xe55a0
leaq -0x90(%rbp), %rdi
callq 0xe55d0
movl $0x1, -0x7c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: VectorNode::isConst() const
bool VectorNode::isConst() const
{
	for (auto &c : args)
		if (c != nullptr && !c->isConst())
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe5310
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe5340
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xd3147
jmp 0xd3190
leaq -0x20(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe53d0
testb $0x1, %al
jne 0xd3167
jmp 0xd3183
movq -0x30(%rbp), %rdi
callq 0x2d030
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xd3183
movb $0x0, -0x1(%rbp)
jmp 0xd3194
jmp 0xd3185
leaq -0x20(%rbp), %rdi
callq 0xe5430
jmp 0xd3134
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: BreakNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void BreakNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "BREAK\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x111713(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd38bd
movq 0x111701(%rip), %rdi    # 0x1e4fa0
leaq 0x7fec2(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x78(%rbp), %rdi
leaq 0x7feb9(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd38e0
movq 0x1116dc(%rip), %rdi    # 0x1e4fa0
leaq 0x7fea7(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x78(%rbp), %rdi
leaq 0x7fe9e(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x70(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xd27b0
movq -0x80(%rbp), %rsi
leaq 0x7fe70(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd390b
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd3921
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x111666(%rip), %rdi    # 0x1e4fa0
leaq 0x7fe53(%rip), %rsi     # 0x153794
callq 0x11560
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd3972
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: ContinueNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ContinueNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "CONTINUE\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x111433(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd3b9d
movq 0x111421(%rip), %rdi    # 0x1e4fa0
leaq 0x7fbe2(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x78(%rbp), %rdi
leaq 0x7fbd9(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd3bc0
movq 0x1113fc(%rip), %rdi    # 0x1e4fa0
leaq 0x7fbc7(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x78(%rbp), %rdi
leaq 0x7fbbe(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x70(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xd27b0
movq -0x80(%rbp), %rsi
leaq 0x7fb90(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd3beb
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd3c01
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x111386(%rip), %rdi    # 0x1e4fa0
leaq 0x7fb7a(%rip), %rsi     # 0x15379b
callq 0x11560
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd3c52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)