LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: prippa[P]Abstract-VM/source/main.cpp
// Function: main
int		main(int argc, char **argv)
{
	Base base;

	try
	{
		if (argc == 1)
			base.bs_read_from_input();
		else if (argc == 2)
			base.bs_read_from_file(argv[1]);
		else
		{
			std::cout << "Incorrect Use!" << std::endl;
			return (-1);
		}
		base.bs_valid_str();
		if (base.bs_is_valid_data())
			base.bs_run_calculator();
	}
	catch (const std::exception & e)
	{
		std::cout << "Line " <<  Exceptions::line << " : "<< e.what() << std::endl;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x9750
cmpl $0x1, -0x8(%rbp)
jne 0x7bac
leaq -0x138(%rbp), %rdi
callq 0x8ea0
jmp 0x7abd
jmp 0x7c10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
movl -0x144(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7c9a
movq -0x140(%rbp), %rdi
callq 0x7190
movq %rax, -0x150(%rbp)
movq 0x58487(%rip), %rdi     # 0x5ff88
leaq 0x3a50b(%rip), %rsi     # 0x42013
callq 0x7440
movq %rax, -0x158(%rbp)
jmp 0x7b16
movq -0x158(%rbp), %rdi
leaq 0x5890c(%rip), %rax     # 0x60430
movl (%rax), %esi
callq 0x7590
movq %rax, -0x160(%rbp)
jmp 0x7b34
movq -0x160(%rbp), %rdi
leaq 0x3ba7d(%rip), %rsi     # 0x435bf
callq 0x7440
movq %rax, -0x168(%rbp)
jmp 0x7b50
movq -0x150(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x168(%rbp), %rdi
movq %rax, %rsi
callq 0x7440
movq %rax, -0x170(%rbp)
jmp 0x7b78
movq -0x170(%rbp), %rdi
movq 0x583ba(%rip), %rsi     # 0x5ff40
callq 0x7480
jmp 0x7b8d
callq 0x7690
jmp 0x7b94
jmp 0x7b96
movl $0x0, -0x4(%rbp)
movl $0x1, -0x148(%rbp)
jmp 0x7c82
cmpl $0x2, -0x8(%rbp)
jne 0x7bca
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x138(%rbp), %rdi
callq 0x8f70
jmp 0x7bc8
jmp 0x7c0e
movq 0x583b7(%rip), %rdi     # 0x5ff88
leaq 0x3a42c(%rip), %rsi     # 0x42004
callq 0x7440
movq %rax, -0x178(%rbp)
jmp 0x7be6
movq -0x178(%rbp), %rdi
movq 0x5834c(%rip), %rsi     # 0x5ff40
callq 0x7480
jmp 0x7bfb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x148(%rbp)
jmp 0x7c82
jmp 0x7c10
leaq -0x138(%rbp), %rdi
callq 0x91b0
jmp 0x7c1e
leaq -0x138(%rbp), %rdi
callq 0x94f0
movb %al, -0x179(%rbp)
jmp 0x7c32
movb -0x179(%rbp), %al
testb $0x1, %al
jne 0x7c3e
jmp 0x7c4e
leaq -0x138(%rbp), %rdi
callq 0x9510
jmp 0x7c4c
jmp 0x7c4e
jmp 0x7b96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
callq 0x7690
jmp 0x7c80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x7c9a
jmp 0x7c9a
leaq -0x138(%rbp), %rdi
callq 0x98a0
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
leaq -0x138(%rbp), %rdi
callq 0x98a0
movq -0x140(%rbp), %rdi
callq 0x7730
movq %rax, %rdi
callq 0x7cc0
nopw (%rax,%rax)
// File: prippa[P]Abstract-VM/source/Base.class.cpp
// Function: Base::bs_read_from_file(char*)
void	Base::bs_read_from_file(char *file_name)
{
	std::ifstream ifs;

	ifs.open(file_name);
	if (!ifs.is_open())
		throw Exceptions::FileOpen(file_name);
	for (std::string line; std::getline(ifs, line);)
		str_.push_back(line);
	ifs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x280(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x7500
movq -0x278(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x72c0
jmp 0x8fb8
leaq -0x218(%rbp), %rdi
callq 0x7660
movb %al, -0x281(%rbp)
jmp 0x8fcc
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x90da
jmp 0x8fdc
movb $0x1, -0x24a(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x2a0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x298(%rbp)
leaq -0x249(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x7740
movq -0x298(%rbp), %rsi
movq -0x290(%rbp), %rdx
leaq -0x248(%rbp), %rdi
callq 0x75c0
jmp 0x902e
movq -0x2a0(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x7cd0
jmp 0x9043
movq -0x2a0(%rbp), %rdi
movb $0x0, -0x24a(%rbp)
leaq 0x564e8(%rip), %rsi     # 0x5f540
leaq -0x6ff(%rip), %rdx      # 0x8960
callq 0x76e0
jmp 0x91af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x9197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x90b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x7290
leaq -0x249(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x24a(%rbp)
jne 0x90c9
jmp 0x90d5
movq -0x2a0(%rbp), %rdi
callq 0x7340
jmp 0x9197
leaq -0x270(%rbp), %rdi
callq 0x75d0
leaq -0x218(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x70c0
movq %rax, -0x2a8(%rbp)
jmp 0x9102
movq -0x2a8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x7540
movb %al, -0x2a9(%rbp)
jmp 0x9120
movb -0x2a9(%rbp), %al
testb $0x1, %al
jne 0x915a
jmp 0x912c
leaq -0x270(%rbp), %rdi
callq 0x7290
jmp 0x9174
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x7290
jmp 0x9197
movq -0x280(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x99b0
jmp 0x916f
jmp 0x90e6
leaq -0x218(%rbp), %rdi
callq 0x70d0
jmp 0x9182
leaq -0x218(%rbp), %rdi
callq 0x7100
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x7100
movq -0x220(%rbp), %rdi
callq 0x7730
nop
// File: prippa[P]Abstract-VM/source/Base.class.cpp
// Function: Base::bs_valid_str()
void	Base::bs_valid_str(void)
{
	for (auto i = str_.begin(); i != str_.end(); ++i)
	{
		try
		{
			if (!bs_parser(*i))
				break;
		}
		catch (const std::exception &e)
		{
			std::cout << e.what() << std::endl;
		}
		++Exceptions::line;
	}
	if (!is_exit_command_)
		throw Exceptions::NoExitCommandError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x99f0
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
callq 0x9a50
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9a20
testb $0x1, %al
jne 0x91f0
jmp 0x92b8
leaq -0x10(%rbp), %rdi
callq 0x9a80
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x9320
movb %al, -0x39(%rbp)
jmp 0x920a
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x92a1
jmp 0x9217
jmp 0x92b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x9305
movq -0x20(%rbp), %rdi
callq 0x7190
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0x56d2c(%rip), %rdi     # 0x5ff88
callq 0x7440
movq %rax, -0x48(%rbp)
jmp 0x9267
movq -0x48(%rbp), %rdi
movq 0x56cce(%rip), %rsi     # 0x5ff40
callq 0x7480
jmp 0x9279
callq 0x7690
leaq 0x571ab(%rip), %rax     # 0x60430
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x5719f(%rip), %rax     # 0x60430
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
callq 0x9aa0
jmp 0x91cd
jmp 0x927e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7690
jmp 0x92b6
jmp 0x9305
movq -0x38(%rbp), %rax
testb $0x1, 0x19(%rax)
jne 0x92ff
movl $0x8, %edi
callq 0x7200
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x7230
movq -0x50(%rbp), %rdi
callq 0x9ac0
movq -0x50(%rbp), %rdi
leaq 0x562a5(%rip), %rsi     # 0x5f598
leaq -0x8ba(%rip), %rdx      # 0x8a40
callq 0x76e0
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x7730
movq %rax, %rdi
callq 0x7cc0
nopw %cs:(%rax,%rax)
// File: prippa[P]Abstract-VM/source/Base.class.cpp
// Function: Base::bs_parser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool	Base::bs_parser(std::string const & str)
{
	if (str.empty() || std::all_of(str.begin(), str.end(), isspace))
		return (true);
	if (std::regex_match(str.c_str(), result_, cmd_))
	{
		if (result_[REGEX_CMD_INDEX] == "exit")
		{
			is_exit_command_ = true;
			return (false);
		}
		return (true);
	}
	else if (std::regex_match(str.c_str(), comment_)
		|| std::regex_match(str.c_str(), cmd_with_value_))
		return (true);
	else
	{
		is_valid_data_ = false;
		throw Exceptions::SyntaxError(std::to_string(Exceptions::line), str);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x76b0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x56(%rbp)
jne 0x937e
movq -0x18(%rbp), %rdi
callq 0x7420
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7780
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq 0x56baa(%rip), %rdx     # 0x5ff20
callq 0x9b00
movb %al, -0x56(%rbp)
movb -0x56(%rbp), %al
testb $0x1, %al
jne 0x9387
jmp 0x9390
movb $0x1, -0x1(%rbp)
jmp 0x94d9
movq -0x18(%rbp), %rdi
callq 0x71a0
movq -0x60(%rbp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
addq $0x20, %rsi
addq $0x60, %rdx
xorl %ecx, %ecx
callq 0x9b50
testb $0x1, %al
jne 0x93b8
jmp 0x93f9
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0x9be0
movq %rax, %rdi
leaq 0x3909b(%rip), %rsi     # 0x4246f
callq 0x9bb0
testb $0x1, %al
jne 0x93df
jmp 0x93f0
movq -0x60(%rbp), %rax
movb $0x1, 0x19(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x94d9
movb $0x1, -0x1(%rbp)
jmp 0x94d9
movq -0x18(%rbp), %rdi
callq 0x71a0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
addq $0x40, %rsi
xorl %edx, %edx
callq 0x9c50
testb $0x1, %al
jne 0x943c
movq -0x18(%rbp), %rdi
callq 0x71a0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
addq $0x80, %rsi
xorl %edx, %edx
callq 0x9c50
testb $0x1, %al
jne 0x943c
jmp 0x9445
movb $0x1, -0x1(%rbp)
jmp 0x94d9
movq -0x60(%rbp), %rax
movb $0x0, 0x18(%rax)
movb $0x1, -0x55(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x68(%rbp)
leaq 0x56fca(%rip), %rax     # 0x60430
movl (%rax), %esi
leaq -0x48(%rbp), %rdi
callq 0x9ca0
jmp 0x9473
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0x7dc0
jmp 0x9486
movq -0x68(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x560c3(%rip), %rsi     # 0x5f558
leaq -0xacc(%rip), %rdx      # 0x89d0
callq 0x76e0
jmp 0x94ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x94c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7290
testb $0x1, -0x55(%rbp)
jne 0x94ce
jmp 0x94d7
movq -0x68(%rbp), %rdi
callq 0x7340
jmp 0x94e4
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7730
nopl (%rax)
// File: prippa[P]Abstract-VM/source/Base.class.cpp
// Function: Base::bs_run_calculator()
void	Base::bs_run_calculator(void)
{
	Exceptions::line = 1;
	for (auto i = str_.begin(); (i != str_.end() && is_exit_command_); ++i)
	{
		if (std::regex_match((*i).c_str(), result_, cmd_)
			|| std::regex_match((*i).c_str(), result_, cmd_with_value_))
			cmd_executor_.ce_execute_command(*this);
		++Exceptions::line;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x56f05(%rip), %rax     # 0x60430
movl $0x1, (%rax)
callq 0x99f0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a50
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9a20
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x9562
jmp 0x956c
movq -0x20(%rbp), %rax
movb 0x19(%rax), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x9578
jmp 0x960f
leaq -0x10(%rbp), %rdi
callq 0x9a80
movq %rax, %rdi
callq 0x71a0
movq -0x20(%rbp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
addq $0x20, %rsi
addq $0x60, %rdx
xorl %ecx, %ecx
callq 0x9b50
testb $0x1, %al
jne 0x95d9
leaq -0x10(%rbp), %rdi
callq 0x9a80
movq %rax, %rdi
callq 0x71a0
movq -0x20(%rbp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
addq $0x20, %rsi
addq $0x80, %rdx
xorl %ecx, %ecx
callq 0x9b50
testb $0x1, %al
jne 0x95d9
jmp 0x95ec
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0xb8, %rdi
callq 0x3bc70
leaq 0x56e3d(%rip), %rax     # 0x60430
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x56e31(%rip), %rax     # 0x60430
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
callq 0x9aa0
jmp 0x953a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: prippa[P]Abstract-VM/source/Factory.class.cpp
// Function: FactoryClass::Factory::createDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
IOperand const	*FactoryClass::Factory::createDouble(std::string const & value) const
{
	long double num = std::stold(value);

	if (num > DBL_MAX)
		throw Exceptions::OverflowError("double");
	else if (num < -DBL_MAX)
		throw Exceptions::UnderflowError("double");
	else
		return (new Operand<double>(SCD(num)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x333b0
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
fldl 0x10cdc(%rip)           # 0x43448
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x32832
jmp 0x3277a
movb $0x1, -0x55(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x98(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7740
movq -0x90(%rbp), %rdx
leaq 0x10cb3(%rip), %rsi     # 0x43460
leaq -0x40(%rbp), %rdi
callq 0x75c0
jmp 0x327b8
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7f80
jmp 0x327ca
movq -0x98(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x2cdd4(%rip), %rsi     # 0x5f5b0
leaq -0x29d53(%rip), %rdx    # 0x8a90
callq 0x76e0
jmp 0x3295c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x32810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7290
leaq -0x41(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x55(%rbp)
jne 0x32821
jmp 0x3282d
movq -0x98(%rbp), %rdi
callq 0x7340
jmp 0x32953
fldt -0x20(%rbp)
fldl 0x10c15(%rip)           # 0x43450
fucompi %st(1), %st
fstp %st(0)
jbe 0x328fc
jmp 0x32847
movb $0x1, -0x7a(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0xa8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x7740
movq -0xa0(%rbp), %rdx
leaq 0x10be6(%rip), %rsi     # 0x43460
leaq -0x78(%rbp), %rdi
callq 0x75c0
jmp 0x32885
movq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8070
jmp 0x32897
movq -0xa8(%rbp), %rdi
movb $0x0, -0x7a(%rbp)
leaq 0x2cd1f(%rip), %rsi     # 0x5f5c8
leaq -0x29db0(%rip), %rdx    # 0x8b00
callq 0x76e0
jmp 0x3295c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x328dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x7290
leaq -0x79(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x7a(%rbp)
jne 0x328ee
jmp 0x328fa
movq -0xa8(%rbp), %rdi
callq 0x7340
jmp 0x32953
movl $0x38, %edi
callq 0x7450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
fldt -0x20(%rbp)
fstpl -0x88(%rbp)
movsd -0x88(%rbp), %xmm0
callq 0x333f0
jmp 0x3292b
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x7410
movq -0x50(%rbp), %rdi
callq 0x7730
nopl (%rax)
// File: prippa[P]Abstract-VM/source/Factory.class.cpp
// Function: FactoryClass::Factory::createFloat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
IOperand const	*FactoryClass::Factory::createFloat(std::string const & value) const
{
	long double num = std::stold(value);

	if (num > FLT_MAX)
		throw Exceptions::OverflowError("float");
	else if (num < -FLT_MAX)
		throw Exceptions::UnderflowError("float");
	else
		return (new Operand<float>(SCF(num)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x333b0
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
flds 0x10acc(%rip)           # 0x43458
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x32a52
jmp 0x3299a
movb $0x1, -0x55(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x90(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x7740
movq -0x88(%rbp), %rdx
leaq 0x10a9a(%rip), %rsi     # 0x43467
leaq -0x40(%rbp), %rdi
callq 0x75c0
jmp 0x329d8
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7f80
jmp 0x329ea
movq -0x90(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x2cbb4(%rip), %rsi     # 0x5f5b0
leaq -0x29f73(%rip), %rdx    # 0x8a90
callq 0x76e0
jmp 0x32b76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x32a30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7290
leaq -0x41(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x55(%rbp)
jne 0x32a41
jmp 0x32a4d
movq -0x90(%rbp), %rdi
callq 0x7340
jmp 0x32b6d
fldt -0x20(%rbp)
flds 0x10a01(%rip)           # 0x4345c
fucompi %st(1), %st
fstp %st(0)
jbe 0x32b1c
jmp 0x32a67
movb $0x1, -0x7a(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0xa0(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x7740
movq -0x98(%rbp), %rdx
leaq 0x109cd(%rip), %rsi     # 0x43467
leaq -0x78(%rbp), %rdi
callq 0x75c0
jmp 0x32aa5
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8070
jmp 0x32ab7
movq -0xa0(%rbp), %rdi
movb $0x0, -0x7a(%rbp)
leaq 0x2caff(%rip), %rsi     # 0x5f5c8
leaq -0x29fd0(%rip), %rdx    # 0x8b00
callq 0x76e0
jmp 0x32b76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x32afd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x7290
leaq -0x79(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x7a(%rbp)
jne 0x32b0e
jmp 0x32b1a
movq -0xa0(%rbp), %rdi
callq 0x7340
jmp 0x32b6d
movl $0x38, %edi
callq 0x7450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
fldt -0x20(%rbp)
fstps -0x80(%rbp)
movss -0x80(%rbp), %xmm0
callq 0x33470
jmp 0x32b45
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x7410
movq -0x50(%rbp), %rdi
callq 0x7730
nopw %cs:(%rax,%rax)
// File: prippa[P]Abstract-VM/source/Factory.class.cpp
// Function: FactoryClass::Factory::createInt32(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
IOperand const	*FactoryClass::Factory::createInt32(std::string const & value) const
{
	int64_t num = std::stoll(value);

	if (num > INT32_MAX)
		throw Exceptions::OverflowError("int32");
	else if (num < INT32_MIN)
		throw Exceptions::UnderflowError("int32");
	else
		return (new Operand<int32_t>(SC32(num)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x334f0
movq %rax, -0x18(%rbp)
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jle 0x32c69
movb $0x1, -0x4d(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x7740
movq -0x80(%rbp), %rdx
leaq 0x10889(%rip), %rsi     # 0x4346d
leaq -0x38(%rbp), %rdi
callq 0x75c0
jmp 0x32bef
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7f80
jmp 0x32c01
movq -0x88(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x2c99d(%rip), %rsi     # 0x5f5b0
leaq -0x2a18a(%rip), %rdx    # 0x8a90
callq 0x76e0
jmp 0x32d7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x32c47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7290
leaq -0x39(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x4d(%rbp)
jne 0x32c58
jmp 0x32c64
movq -0x88(%rbp), %rdi
callq 0x7340
jmp 0x32d75
cmpq $-0x80000000, -0x18(%rbp) # imm = 0x80000000
jge 0x32d2c
movb $0x1, -0x72(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x98(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7740
movq -0x90(%rbp), %rdx
leaq 0x107c3(%rip), %rsi     # 0x4346d
leaq -0x70(%rbp), %rdi
callq 0x75c0
jmp 0x32cb5
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8070
jmp 0x32cc7
movq -0x98(%rbp), %rdi
movb $0x0, -0x72(%rbp)
leaq 0x2c8ef(%rip), %rsi     # 0x5f5c8
leaq -0x2a1e0(%rip), %rdx    # 0x8b00
callq 0x76e0
jmp 0x32d7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x32d0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7290
leaq -0x71(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x72(%rbp)
jne 0x32d1e
jmp 0x32d2a
movq -0x98(%rbp), %rdi
callq 0x7340
jmp 0x32d75
movl $0x38, %edi
callq 0x7450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movl -0x18(%rbp), %esi
callq 0x33530
jmp 0x32d4d
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x7410
movq -0x48(%rbp), %rdi
callq 0x7730
nop
// File: prippa[P]Abstract-VM/source/Factory.class.cpp
// Function: FactoryClass::Factory::createInt16(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
IOperand const	*FactoryClass::Factory::createInt16(std::string const & value) const
{
	int64_t num = std::stoll(value);

	if (num > INT16_MAX)
		throw Exceptions::OverflowError("int16");
	else if (num < INT16_MIN)
		throw Exceptions::UnderflowError("int16");
	else
		return (new Operand<int16_t>(SC16(num)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x334f0
movq %rax, -0x18(%rbp)
cmpq $0x7fff, -0x18(%rbp)    # imm = 0x7FFF
jle 0x32e69
movb $0x1, -0x4d(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x7740
movq -0x80(%rbp), %rdx
leaq 0x1068f(%rip), %rsi     # 0x43473
leaq -0x38(%rbp), %rdi
callq 0x75c0
jmp 0x32def
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7f80
jmp 0x32e01
movq -0x88(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x2c79d(%rip), %rsi     # 0x5f5b0
leaq -0x2a38a(%rip), %rdx    # 0x8a90
callq 0x76e0
jmp 0x32f7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x32e47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7290
leaq -0x39(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x4d(%rbp)
jne 0x32e58
jmp 0x32e64
movq -0x88(%rbp), %rdi
callq 0x7340
jmp 0x32f76
cmpq $-0x8000, -0x18(%rbp)   # imm = 0x8000
jge 0x32f2c
movb $0x1, -0x72(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x98(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7740
movq -0x90(%rbp), %rdx
leaq 0x105c9(%rip), %rsi     # 0x43473
leaq -0x70(%rbp), %rdi
callq 0x75c0
jmp 0x32eb5
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8070
jmp 0x32ec7
movq -0x98(%rbp), %rdi
movb $0x0, -0x72(%rbp)
leaq 0x2c6ef(%rip), %rsi     # 0x5f5c8
leaq -0x2a3e0(%rip), %rdx    # 0x8b00
callq 0x76e0
jmp 0x32f7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x32f0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7290
leaq -0x71(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x72(%rbp)
jne 0x32f1e
jmp 0x32f2a
movq -0x98(%rbp), %rdi
callq 0x7340
jmp 0x32f76
movl $0x38, %edi
callq 0x7450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movswl -0x18(%rbp), %esi
callq 0x335b0
jmp 0x32f4e
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x7410
movq -0x48(%rbp), %rdi
callq 0x7730
nop
// File: prippa[P]Abstract-VM/source/Factory.class.cpp
// Function: FactoryClass::Factory::createInt8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
IOperand const	*FactoryClass::Factory::createInt8(std::string const & value) const
{
	int64_t num = std::stoll(value);

	if (num > INT8_MAX)
		throw Exceptions::OverflowError("int8");
	else if (num < INT8_MIN)
		throw Exceptions::UnderflowError("int8");
	else
		return (new Operand<int8_t>(SC8(num)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x334f0
movq %rax, -0x18(%rbp)
cmpq $0x7f, -0x18(%rbp)
jle 0x33066
movb $0x1, -0x4d(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x7740
movq -0x80(%rbp), %rdx
leaq 0xf168(%rip), %rsi      # 0x42149
leaq -0x38(%rbp), %rdi
callq 0x75c0
jmp 0x32fec
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7f80
jmp 0x32ffe
movq -0x88(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x2c5a0(%rip), %rsi     # 0x5f5b0
leaq -0x2a587(%rip), %rdx    # 0x8a90
callq 0x76e0
jmp 0x33179
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x33044
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7290
leaq -0x39(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x4d(%rbp)
jne 0x33055
jmp 0x33061
movq -0x88(%rbp), %rdi
callq 0x7340
jmp 0x33170
cmpq $-0x80, -0x18(%rbp)
jge 0x33126
movb $0x1, -0x72(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x98(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7740
movq -0x90(%rbp), %rdx
leaq 0xf0a5(%rip), %rsi      # 0x42149
leaq -0x70(%rbp), %rdi
callq 0x75c0
jmp 0x330af
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8070
jmp 0x330c1
movq -0x98(%rbp), %rdi
movb $0x0, -0x72(%rbp)
leaq 0x2c4f5(%rip), %rsi     # 0x5f5c8
leaq -0x2a5da(%rip), %rdx    # 0x8b00
callq 0x76e0
jmp 0x33179
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x33107
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7290
leaq -0x71(%rbp), %rdi
callq 0x74a0
testb $0x1, -0x72(%rbp)
jne 0x33118
jmp 0x33124
movq -0x98(%rbp), %rdi
callq 0x7340
jmp 0x33170
movl $0x38, %edi
callq 0x7450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movsbl -0x18(%rbp), %esi
callq 0x33630
jmp 0x33148
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x7410
movq -0x48(%rbp), %rdi
callq 0x7730
nopl (%rax)
// File: prippa[P]Abstract-VM/source/Factory.class.cpp
// Function: FactoryClass::Factory::Factory()
FactoryClass::Factory::Factory(void)
{
	func_ = point_to_func_t(TYPE_SIZE);
	func_[Int8] = &Factory::createInt8;
	func_[Int16] = &Factory::createInt16;
	func_[Int32] = &Factory::createInt32;
	func_[Float] = &Factory::createFloat;
	func_[Double] = &Factory::createDouble;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x336d0
leaq -0x21(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x336f0
movq -0x40(%rbp), %rdx
leaq -0x20(%rbp), %rdi
movl $0x5, %esi
callq 0x33710
jmp 0x332a1
movq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x58(%rbp)
callq 0x33780
movq -0x58(%rbp), %rdi
callq 0x337b0
leaq -0x21(%rbp), %rdi
callq 0x33810
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33830
movq -0x48(%rbp), %rdi
leaq -0x35c(%rip), %rcx      # 0x32f80
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl $0x1, %esi
callq 0x33830
movq -0x48(%rbp), %rdi
leaq -0x57c(%rip), %rcx      # 0x32d80
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl $0x2, %esi
callq 0x33830
movq -0x48(%rbp), %rdi
leaq -0x79c(%rip), %rcx      # 0x32b80
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl $0x3, %esi
callq 0x33830
movq -0x48(%rbp), %rdi
leaq -0x9dc(%rip), %rcx      # 0x32960
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl $0x4, %esi
callq 0x33830
leaq -0xc18(%rip), %rcx      # 0x32740
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x33810
movq -0x50(%rbp), %rdi
callq 0x337b0
movq -0x30(%rbp), %rdi
callq 0x7730
// File: prippa[P]Abstract-VM/source/../includes/Operand.template.hpp
// Function: Operand<double>::op_set_types()
void	op_set_types(void)
	{
		if (typeid(int8_t) == typeid(T)) { type_ = Int8; precision_ = 0; }
		else if (typeid(int16_t) == typeid(T)) { type_ = Int16; precision_ = 0; }
		else if (typeid(int32_t) == typeid(T)) { type_ = Int32; precision_ = 0; }
		else if (typeid(float) == typeid(T)) { type_ = Float; precision_ = 7; }
		else { type_ = Double; precision_ = 14; }

		if (type_ < Float)
			str_ = std::to_string(value_);
		else
		{
			std::stringstream set(std::stringstream::out);
			set << std::setprecision(precision_) << value_;
			str_ = set.str();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq 0x2c397(%rip), %rdi     # 0x5ff98
movq 0x2c3e8(%rip), %rsi     # 0x5fff0
callq 0x16a00
testb $0x1, %al
jne 0x33c13
jmp 0x33c2d
movq -0x1f0(%rbp), %rax
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
jmp 0x33cd8
movq 0x2c334(%rip), %rdi     # 0x5ff68
movq 0x2c3b5(%rip), %rsi     # 0x5fff0
callq 0x16a00
testb $0x1, %al
jne 0x33c46
jmp 0x33c5d
movq -0x1f0(%rbp), %rax
movl $0x1, 0x30(%rax)
movl $0x0, 0x34(%rax)
jmp 0x33cd6
movq 0x2c2b4(%rip), %rdi     # 0x5ff18
movq 0x2c385(%rip), %rsi     # 0x5fff0
callq 0x16a00
testb $0x1, %al
jne 0x33c76
jmp 0x33c8d
movq -0x1f0(%rbp), %rax
movl $0x2, 0x30(%rax)
movl $0x0, 0x34(%rax)
jmp 0x33cd4
movq 0x2c314(%rip), %rdi     # 0x5ffa8
movq 0x2c355(%rip), %rsi     # 0x5fff0
callq 0x16a00
testb $0x1, %al
jne 0x33ca6
jmp 0x33cbd
movq -0x1f0(%rbp), %rax
movl $0x3, 0x30(%rax)
movl $0x7, 0x34(%rax)
jmp 0x33cd2
movq -0x1f0(%rbp), %rax
movl $0x4, 0x30(%rax)
movl $0xe, 0x34(%rax)
jmp 0x33cd4
jmp 0x33cd6
jmp 0x33cd8
movq -0x1f0(%rbp), %rax
cmpl $0x3, 0x30(%rax)
jge 0x33d1c
movq -0x1f0(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq -0x28(%rbp), %rdi
callq 0x34c30
movq -0x1f0(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0x7520
leaq -0x28(%rbp), %rdi
callq 0x7290
jmp 0x33df9
leaq -0x1b0(%rbp), %rdi
movl $0x10, %esi
callq 0x7370
movq -0x1f0(%rbp), %rax
leaq -0x1a0(%rbp), %rcx
movq %rcx, -0x200(%rbp)
movl 0x34(%rax), %edi
callq 0x34c80
movl %eax, -0x1f4(%rbp)
jmp 0x33d52
movq -0x200(%rbp), %rdi
movl -0x1f4(%rbp), %eax
movl %eax, -0x1b4(%rbp)
movl -0x1b4(%rbp), %esi
callq 0x7650
movq %rax, -0x208(%rbp)
jmp 0x33d79
movq -0x208(%rbp), %rdi
movq -0x1f0(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x77b0
jmp 0x33d93
leaq -0x1e8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x7430
jmp 0x33da8
movq -0x1f0(%rbp), %rdi
addq $0x10, %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x7520
leaq -0x1e8(%rbp), %rdi
callq 0x7290
leaq -0x1b0(%rbp), %rdi
callq 0x7360
jmp 0x33df9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x7360
jmp 0x33e02
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x7730
nop
// File: prippa[P]Abstract-VM/source/../includes/Operand.template.hpp
// Function: Operand<double>::operator+(IOperand const&) const
IOperand const * operator+(IOperand const & rhs) const
	{
		eOperandType e = (type_ >= rhs.getType() ? type_ : rhs.getType());

		if (e < Float)
			return (fac_.createOperand(e, std::to_string(SC64(value_)
				+ std::stoll(rhs.toString()))));
		else
			return (fac_.createOperand(e, std::to_string(SCLD(value_)
				+ std::stold(rhs.toString()))));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x30(%rax), %eax
movl %eax, -0x74(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ecx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jl 0x33e93
movq -0x80(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x84(%rbp)
jmp 0x33ea3
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x33f5d
movq -0x80(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x9c(%rbp)
cvttsd2si 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x334f0
movq -0xa8(%rbp), %rsi
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x34df0
movl -0x9c(%rbp), %esi
movq -0x98(%rbp), %rdx
leaq 0x2c93c(%rip), %rdi     # 0x60858
callq 0x33180
movq %rax, -0x90(%rbp)
jmp 0x33f2a
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7290
jmp 0x33ff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7290
jmp 0x34005
movq -0x80(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0xbc(%rbp)
fldl 0x8(%rax)
fstpt -0xc8(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x333b0
fldt -0xc8(%rbp)
faddp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x34f20
movl -0xbc(%rbp), %esi
movq -0xb8(%rbp), %rdx
leaq 0x2c89b(%rip), %rdi     # 0x60858
callq 0x33180
movq %rax, -0xb0(%rbp)
jmp 0x33fcb
movq -0xb0(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7290
jmp 0x33ff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7290
jmp 0x34005
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7730
nop
// File: prippa[P]Abstract-VM/source/../includes/Operand.template.hpp
// Function: Operand<double>::operator==(IOperand const&) const
bool	operator==(IOperand const & rhs) const
	{
		eOperandType e = (type_ >= rhs.getType() ? type_ : rhs.getType());

		if (e < Float)
			return (SC32(value_) == std::stoi(rhs.toString()));
		else if (e == Float)
			return (SCF(value_) == std::stof(rhs.toString()));
		else
			return (SCD(value_) == std::stod(rhs.toString()));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x30(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jl 0x3485d
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3486a
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x348b1
movq -0x28(%rbp), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x35140
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x34936
cmpl $0x3, -0x1c(%rbp)
jne 0x348f9
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x35180
movaps %xmm0, %xmm1
movss -0x34(%rbp), %xmm0
ucomiss %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x34936
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x351c0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: prippa[P]Abstract-VM/source/CommandsExecutor.class.cpp
// Function: CommandsExecutor::ce_pop(Base&)
void	CommandsExecutor::ce_pop(Base & bs)
{
	if (bs.stack_.empty())
		throw Exceptions::EmptyStackError(bs.result_[REGEX_CMD_INDEX]);
	right_ = bs.stack_.back();
	bs.stack_.pop_back();
	ce_del_io(&right_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c5f0
testb $0x1, %al
jne 0x3a3b1
jmp 0x3a44f
movb $0x1, -0x3d(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0x9be0
movq %rax, -0x50(%rbp)
jmp 0x3a3db
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3c610
jmp 0x3a3ea
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8320
jmp 0x3a3f9
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x25230(%rip), %rsi     # 0x5f638
leaq -0x317df(%rip), %rdx    # 0x8c30
callq 0x76e0
jmp 0x3a49c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3a43c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7290
testb $0x1, -0x3d(%rbp)
jne 0x3a444
jmp 0x3a44d
movq -0x58(%rbp), %rdi
callq 0x7340
jmp 0x3a493
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c640
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c680
movq -0x48(%rbp), %rdi
movq %rdi, %rsi
addq $0x60, %rsi
callq 0x3a340
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7730
nopl (%rax)
// File: prippa[P]Abstract-VM/source/CommandsExecutor.class.cpp
// Function: CommandsExecutor::ce_add(Base&)
void	CommandsExecutor::ce_add(Base & bs)
{
	if (bs.stack_.size() < CE_MINIMUM_ARGS)
		throw Exceptions::NotEnoughArgumentsError();
	right_ = bs.stack_.back();
	bs.stack_.pop_back();
	left_ = bs.stack_.back();
	bs.stack_.pop_back();
	const IOperand *res = *left_ + *right_;
	bs.stack_.push_back(res);
	ce_del_io(&left_);
	ce_del_io(&right_);
}

// 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)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c7f0
cmpq $0x2, %rax
jae 0x3a59b
movl $0x8, %edi
callq 0x7200
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x7230
movq -0x28(%rbp), %rdi
callq 0x3c820
movq -0x28(%rbp), %rdi
leaq 0x25079(%rip), %rsi     # 0x5f608
leaq -0x31a26(%rip), %rdx    # 0x8b70
callq 0x76e0
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c640
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c680
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c640
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c680
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x60(%rax), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x18(%rbp), %rsi
callq 0x3c860
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x68, %rsi
callq 0x3a340
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x60, %rsi
callq 0x3a340
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: prippa[P]Abstract-VM/source/CommandsExecutor.class.cpp
// Function: CommandsExecutor::ce_print(Base&)
void	CommandsExecutor::ce_print(Base & bs)
{
	if (bs.stack_.empty())
		throw Exceptions::EmptyStackError(bs.result_[REGEX_CMD_INDEX]);
	right_ = bs.stack_.back();
	if (right_->getType() != Int8)
	{
		right_ = nullptr;
		throw Exceptions::PrintCommandError();
	}
	int8_t c = static_cast<int8_t>(std::stoi(right_->toString()));
	std::cout << c << std::endl;
	right_ = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c5f0
testb $0x1, %al
jne 0x3ab01
jmp 0x3aba2
movb $0x1, -0x3d(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0x9be0
movq %rax, -0x50(%rbp)
jmp 0x3ab2b
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3c610
jmp 0x3ab3a
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8320
jmp 0x3ab49
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x24ae0(%rip), %rsi     # 0x5f638
leaq -0x31f2f(%rip), %rdx    # 0x8c30
callq 0x76e0
jmp 0x3ac74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3ab8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7290
testb $0x1, -0x3d(%rbp)
jne 0x3ab94
jmp 0x3ab9d
movq -0x58(%rbp), %rdi
callq 0x7340
jmp 0x3ac6b
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c640
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x60(%rax)
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x0, %eax
je 0x3ac18
movq -0x48(%rbp), %rax
movq $0x0, 0x60(%rax)
movl $0x8, %edi
callq 0x7200
movq %rax, %rdi
movq %rdi, -0x60(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x7230
movq -0x60(%rbp), %rdi
callq 0x3c8a0
movq -0x60(%rbp), %rdi
leaq 0x24aac(%rip), %rsi     # 0x5f6b8
leaq -0x31f23(%rip), %rdx    # 0x8cf0
callq 0x76e0
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x35140
movb %al, -0x3e(%rbp)
movq 0x25347(%rip), %rdi     # 0x5ff88
movsbl -0x3e(%rbp), %esi
callq 0x75b0
movq %rax, %rdi
movq 0x252ec(%rip), %rsi     # 0x5ff40
callq 0x7480
movq -0x48(%rbp), %rax
movq $0x0, 0x60(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7730
nopw %cs:(%rax,%rax)
// File: prippa[P]Abstract-VM/source/CommandsExecutor.class.cpp
// Function: CommandsExecutor::ce_max(Base&)
void	CommandsExecutor::ce_max(Base & bs)
{
	if (bs.stack_.empty())
		throw Exceptions::EmptyStackError(bs.result_[REGEX_CMD_INDEX]);
	left_ = bs.stack_.front();
	for (auto i = bs.stack_.begin(); i != bs.stack_.end(); ++i)
	{
		right_ = *i;
		if (*left_ < *right_)
			left_ = right_;
	}
	std::cout << left_->toString() << std::endl;
	right_ = nullptr;
	left_ = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c5f0
testb $0x1, %al
jne 0x3acd1
jmp 0x3ad72
movb $0x1, -0x3d(%rbp)
movl $0x28, %edi
callq 0x7200
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0x9be0
movq %rax, -0x60(%rbp)
jmp 0x3acfb
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3c610
jmp 0x3ad0a
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8320
jmp 0x3ad19
movq -0x68(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x24910(%rip), %rsi     # 0x5f638
leaq -0x320ff(%rip), %rdx    # 0x8c30
callq 0x76e0
jmp 0x3ae5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3ad5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7290
testb $0x1, -0x3d(%rbp)
jne 0x3ad64
jmp 0x3ad6d
movq -0x68(%rbp), %rdi
callq 0x7340
jmp 0x3ae55
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3c8e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x9f70
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x9fd0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9fa0
testb $0x1, %al
jne 0x3adcb
jmp 0x3ae0f
leaq -0x48(%rbp), %rdi
callq 0xa000
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x60(%rax)
movq 0x68(%rax), %rdi
movq 0x60(%rax), %rsi
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0x3adf6
jmp 0x3ae02
movq -0x58(%rbp), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x68(%rax)
jmp 0x3ae04
leaq -0x48(%rbp), %rdi
callq 0xa020
jmp 0x3ada4
movq -0x58(%rbp), %rax
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rsi
movq 0x25161(%rip), %rdi     # 0x5ff88
callq 0x73e0
movq %rax, %rdi
movq 0x2510a(%rip), %rsi     # 0x5ff40
callq 0x7480
movq -0x58(%rbp), %rax
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7730
nop
// File: prippa[P]Abstract-VM/source/CommandsExecutor.class.cpp
// Function: CommandsExecutor::ce_debug(Base&)
void	CommandsExecutor::ce_debug(Base & bs)
{
	size_t i8 = 0, i16 = 0, i32 = 0, f = 0, d = 0;
	eOperandType type;
	for (auto i = bs.stack_.begin(); i != bs.stack_.end(); ++i)
	{
		type = (*i)->getType();
		if (type == Int8)
			++i8;
		else if (type == Int16)
			++i16;
		else if (type == Int32)
			++i32;
		else if (type == Float)
			++f;
		else
			++d;
	}
	std::cout << "int8   : " << i8 << std::endl;
	std::cout << "int16  : " << i16 << std::endl;
	std::cout << "int32  : " << i32 << std::endl;
	std::cout << "float  : " << f << std::endl;
	std::cout << "double : " << d << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x9f70
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x9fd0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9fa0
testb $0x1, %al
jne 0x3b096
jmp 0x3b11d
leaq -0x48(%rbp), %rdi
callq 0xa000
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x3b0bf
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3b10d
cmpl $0x1, -0x3c(%rbp)
jne 0x3b0d3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3b10b
cmpl $0x2, -0x3c(%rbp)
jne 0x3b0e7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3b109
cmpl $0x3, -0x3c(%rbp)
jne 0x3b0fb
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3b107
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3b109
jmp 0x3b10b
jmp 0x3b10d
jmp 0x3b10f
leaq -0x48(%rbp), %rdi
callq 0xa020
jmp 0x3b06c
movq 0x24e64(%rip), %rdi     # 0x5ff88
leaq 0x848e(%rip), %rsi      # 0x435b9
callq 0x7440
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x70f0
movq %rax, %rdi
movq 0x24dfa(%rip), %rsi     # 0x5ff40
callq 0x7480
movq 0x24e36(%rip), %rdi     # 0x5ff88
leaq 0x846a(%rip), %rsi      # 0x435c3
callq 0x7440
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x70f0
movq %rax, %rdi
movq 0x24dcc(%rip), %rsi     # 0x5ff40
callq 0x7480
movq 0x24e08(%rip), %rdi     # 0x5ff88
leaq 0x8446(%rip), %rsi      # 0x435cd
callq 0x7440
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x70f0
movq %rax, %rdi
movq 0x24d9e(%rip), %rsi     # 0x5ff40
callq 0x7480
movq 0x24dda(%rip), %rdi     # 0x5ff88
leaq 0x8422(%rip), %rsi      # 0x435d7
callq 0x7440
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x70f0
movq %rax, %rdi
movq 0x24d70(%rip), %rsi     # 0x5ff40
callq 0x7480
movq 0x24dac(%rip), %rdi     # 0x5ff88
leaq 0x83fe(%rip), %rsi      # 0x435e1
callq 0x7440
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x70f0
movq %rax, %rdi
movq 0x24d42(%rip), %rsi     # 0x5ff40
callq 0x7480
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: prippa[P]Abstract-VM/source/CommandsExecutor.class.cpp
// Function: CommandsExecutor::ce_push(Base&)
void	CommandsExecutor::ce_push(Base & bs)
{
	bs.stack_.push_back(
		fac_.createOperand(
			type_[bs.result_[REGEX_TYPE_INDEX]],
			bs.result_[REGEX_VALUE_INDEX]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xa0, %rax
movq %rax, -0x88(%rbp)
addq $0x20, %rdi
movl $0x2, %esi
callq 0x9be0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3c610
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3c950
movq %rax, -0x70(%rbp)
jmp 0x3b270
movq -0x70(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x94(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl $0x3, %esi
callq 0x9be0
movq %rax, -0x90(%rbp)
jmp 0x3b297
movq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3c610
jmp 0x3b2a9
movl -0x94(%rbp), %esi
leaq 0x255a2(%rip), %rdi     # 0x60858
leaq -0x68(%rbp), %rdx
callq 0x33180
movq %rax, -0xa0(%rbp)
jmp 0x3b2c8
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3c910
jmp 0x3b2e5
leaq -0x68(%rbp), %rdi
callq 0x7290
leaq -0x38(%rbp), %rdi
callq 0x7290
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3b323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7290
leaq -0x38(%rbp), %rdi
callq 0x7290
movq -0x40(%rbp), %rdi
callq 0x7730
nopw %cs:(%rax,%rax)