LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
reference operator[](typename object_t::key_type key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_type = value_t::object;
            m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto result = m_value.object->emplace(std::move(key), nullptr);
            return set_parent(result.first->second);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0x6cdba
movb $0x1, (%r14)
callq 0x61582
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x61454
movb (%r14), %al
cmpb $0x1, %al
jne 0x6cde1
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rdx
andq $0x0, (%rdx)
movq %rbx, %rsi
callq 0x6ceca
addq $0x40, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x242b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x66bc4
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0xfeb5(%rip), %rsi      # 0x7ccb7
leaq -0x40(%rbp), %rdi
callq 0x6ce61
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
movq %r14, %rcx
callq 0x66a5e
xorl %r15d, %r15d
leaq 0x40c5c(%rip), %rsi     # 0xada88
leaq -0x94b7(%rip), %rdx     # 0x6397c
movq %rbx, %rdi
callq 0x248f0
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x24ad8
testb %r15b, %r15b
jne 0x6ce51
jmp 0x6ce59
movq %rax, %r14
movq %rbx, %rdi
callq 0x24430
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x138(%rbp), %rdi
callq 0x794e
cmpl $0x2, %r14d
je 0x6826
cmpl $0x1, %r14d
jne 0x6862
leaq -0x138(%rbp), %rdi
callq 0x740c
jmp 0x6836
movq 0x8(%rbx), %rsi
leaq -0x138(%rbp), %rdi
callq 0x74a0
leaq -0x138(%rbp), %rdi
callq 0x75dc
leaq -0x138(%rbp), %rdi
callq 0x77ca
xorl %ebx, %ebx
testb %al, %al
je 0x6880
leaq -0x138(%rbp), %rdi
callq 0x77d4
jmp 0x6880
movq 0x2370f(%rip), %rdi     # 0x29f78
leaq 0x14794(%rip), %rsi     # 0x1b004
callq 0x6350
movq %rax, %rdi
callq 0x61b0
pushq $-0x1
popq %rbx
leaq -0x138(%rbp), %rdi
callq 0x7a4a
movl %ebx, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x6918
movq %rbx, %rdi
callq 0x6150
movq %rax, %rbx
movq 0x236c4(%rip), %rdi     # 0x29f78
leaq 0x14758(%rip), %rsi     # 0x1b013
callq 0x6350
leaq 0x23a49(%rip), %rcx     # 0x2a310
movl (%rcx), %esi
movq %rax, %rdi
callq 0x6260
leaq 0x15c6b(%rip), %rsi     # 0x1c543
movq %rax, %rdi
callq 0x6350
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x6350
movq %rax, %rdi
callq 0x61b0
xorl %ebx, %ebx
callq 0x6500
jmp 0x6880
movq %rax, %rbx
jmp 0x6918
movq %rax, %rbx
callq 0x6500
leaq -0x138(%rbp), %rdi
callq 0x7a4a
movq %rbx, %rdi
callq 0x6550
movq %rax, %rdi
callq 0x6934
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x248(%rbp), %r15
movq %r15, %rdi
callq 0x63c0
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x6230
leaq -0x1d0(%rbp), %rdi
callq 0x60c0
testb %al, %al
je 0x7553
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x248(%rbp), %r14
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7524
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7ad4
jmp 0x74fe
leaq -0x40(%rbp), %rdi
callq 0x6190
leaq -0x248(%rbp), %rdi
callq 0x60a0
leaq -0x248(%rbp), %rdi
callq 0x60d0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %r14, %rsi
callq 0x6140
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6944
xorl %r15d, %r15d
leaq 0x22069(%rip), %rsi     # 0x295f0
leaq -0x422(%rip), %rdx      # 0x716c
movq %rbx, %rdi
callq 0x6520
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x75ac
jmp 0x75c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
jmp 0x75c7
movq %rax, %r14
jmp 0x75c7
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
leaq -0x248(%rbp), %rdi
callq 0x60d0
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x22d1c(%rip), %r12     # 0x2a310
movq 0x2297d(%rip), %r14     # 0x29f78
movq %rdi, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x7650
leaq 0x10(%r13), %rsi
movq %rbx, %rdi
callq 0x76aa
testb %al, %al
je 0x7650
incl (%r12)
jmp 0x75fe
movq %rax, %r15
cmpl $0x1, %edx
jne 0x7699
movq %r15, %rdi
callq 0x6150
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x6350
movq %rax, %rdi
callq 0x61b0
callq 0x6500
jmp 0x7617
cmpb $0x0, 0x19(%rbx)
je 0x7665
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x61c0
leaq 0x21fac(%rip), %rcx     # 0x29620
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x21fc6(%rip), %rsi     # 0x29648
movq 0x22947(%rip), %rdx     # 0x29fd0
movq %rax, %rdi
callq 0x6520
movq %rax, %r15
callq 0x6500
movq %r15, %rdi
callq 0x6550
movq %rax, %rdi
callq 0x6934
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rsi
movb $0x1, %bl
testq %rsi, %rsi
je 0x76e0
movq %rdi, %r15
movq (%r14), %rdi
addq %rdi, %rsi
movq 0x22849(%rip), %rdx     # 0x29f20
callq 0x7ae4
testb %al, %al
je 0x76ef
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
leaq 0x20(%r15), %r12
leaq 0x60(%r15), %rdx
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x7aff
testb %al, %al
je 0x772f
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x7b48
leaq 0x13cc1(%rip), %rsi     # 0x1b3db
movq %rax, %rdi
callq 0x7b37
testb %al, %al
je 0x76e0
movb $0x1, 0x19(%r15)
xorl %ebx, %ebx
jmp 0x76e0
movq (%r14), %rdi
leaq 0x40(%r15), %rsi
xorl %edx, %edx
callq 0x7b88
testb %al, %al
jne 0x76e0
movq (%r14), %rdi
leaq 0x80(%r15), %rsi
xorl %edx, %edx
callq 0x7b88
testb %al, %al
jne 0x76e0
movb $0x0, 0x18(%r15)
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x22ba3(%rip), %rax     # 0x2a310
movl (%rax), %esi
leaq -0x40(%rbp), %rdi
callq 0x7bba
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x69f8
xorl %r15d, %r15d
leaq 0x21e74(%rip), %rsi     # 0x29608
leaq -0x5e9(%rip), %rdx      # 0x71b2
movq %rbx, %rdi
callq 0x6520
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x77b9
jmp 0x77c1
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
leaq 0x20(%rdi), %r14
leaq 0x60(%rdi), %r15
leaq 0x80(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0xb8(%rdi), %rax
movq %rax, -0x38(%rbp)
pushq $0x1
popq %rax
leaq 0x22b00(%rip), %r12     # 0x2a310
movq %rdi, %rbx
movl %eax, (%r12)
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0x7865
cmpb $0x0, 0x19(%r13)
je 0x7865
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x7aff
testb %al, %al
jne 0x7851
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x7aff
testb %al, %al
je 0x785d
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x18ee4
movl (%r12), %eax
incl %eax
jmp 0x7813
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x146d4
fldl 0x8377(%rip)            # 0x1c3b8
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x14086
fldl 0x8371(%rip)            # 0x1c3c0
fld %st(1)
fstpt -0x34(%rbp)
fucompi %st(1), %st
fstp %st(0)
ja 0x140d1
pushq $0x38
popq %rdi
callq 0x6360
movq %rax, %rbx
fldt -0x34(%rbp)
fstpl -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq %rax, %rdi
callq 0x146f2
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x8336(%rip), %rsi      # 0x1c3d0
leaq -0x58(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x6b1c
xorl %r15d, %r15d
leaq 0x155a0(%rip), %rsi     # 0x29660
leaq -0xceb3(%rip), %rdx     # 0x7214
movq %rbx, %rdi
callq 0x6520
jmp 0x14118
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x82ed(%rip), %rsi      # 0x1c3d0
leaq -0x58(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x6bd0
xorl %r15d, %r15d
leaq 0x1556f(%rip), %rsi     # 0x29678
leaq -0xceb6(%rip), %rdx     # 0x725a
movq %rbx, %rdi
callq 0x6520
jmp 0x1411c
jmp 0x1412f
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x14132
jmp 0x14147
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
jmp 0x14147
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x146d4
flds 0x825b(%rip)            # 0x1c3c8
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x141b2
flds 0x8251(%rip)            # 0x1c3cc
fld %st(1)
fstpt -0x2c(%rbp)
fucompi %st(1), %st
fstp %st(0)
ja 0x141fd
pushq $0x38
popq %rdi
callq 0x6360
movq %rax, %rbx
fldt -0x2c(%rbp)
fstps -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movq %rax, %rdi
callq 0x1473a
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x8211(%rip), %rsi      # 0x1c3d7
leaq -0x50(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x6b1c
xorl %r15d, %r15d
leaq 0x15474(%rip), %rsi     # 0x29660
leaq -0xcfdf(%rip), %rdx     # 0x7214
movq %rbx, %rdi
callq 0x6520
jmp 0x14244
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x81c8(%rip), %rsi      # 0x1c3d7
leaq -0x50(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x6bd0
xorl %r15d, %r15d
leaq 0x15443(%rip), %rsi     # 0x29678
leaq -0xcfe2(%rip), %rdx     # 0x725a
movq %rbx, %rdi
callq 0x6520
jmp 0x14248
jmp 0x1425b
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x1425e
jmp 0x14273
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
jmp 0x14273
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x14782
movq %rax, %rbx
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, %rbx
jge 0x142d5
movabsq $-0x80000001, %rax      # imm = 0xFFFFFFFF7FFFFFFF
cmpq %rax, %rbx
jle 0x1431e
pushq $0x38
popq %rdi
callq 0x6360
movq %rax, %r15
movq %rax, %rdi
movl %ebx, %esi
callq 0x147a4
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x80f6(%rip), %rsi      # 0x1c3dd
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6b1c
xorl %r15d, %r15d
leaq 0x15353(%rip), %rsi     # 0x29660
leaq -0xd100(%rip), %rdx     # 0x7214
movq %rbx, %rdi
callq 0x6520
jmp 0x14365
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x80ad(%rip), %rsi      # 0x1c3dd
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6bd0
xorl %r15d, %r15d
leaq 0x15322(%rip), %rsi     # 0x29678
leaq -0xd103(%rip), %rdx     # 0x725a
movq %rbx, %rdi
callq 0x6520
jmp 0x14369
jmp 0x1437c
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x1437f
jmp 0x14394
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
jmp 0x14394
movq %rax, %r14
movq %r15, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x14782
cmpq $0x8000, %rax           # imm = 0x8000
jge 0x143ed
movq %rax, %rbx
cmpq $-0x8001, %rax          # imm = 0xFFFF7FFF
jle 0x14436
pushq $0x38
popq %rdi
callq 0x6360
movq %rax, %r15
movswl %bx, %esi
movq %rax, %rdi
callq 0x147ea
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x7fe4(%rip), %rsi      # 0x1c3e3
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6b1c
xorl %r15d, %r15d
leaq 0x1523b(%rip), %rsi     # 0x29660
leaq -0xd218(%rip), %rdx     # 0x7214
movq %rbx, %rdi
callq 0x6520
jmp 0x1447d
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x7f9b(%rip), %rsi      # 0x1c3e3
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6bd0
xorl %r15d, %r15d
leaq 0x1520a(%rip), %rsi     # 0x29678
leaq -0xd21b(%rip), %rdx     # 0x725a
movq %rbx, %rdi
callq 0x6520
jmp 0x14481
jmp 0x14494
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x14497
jmp 0x144ac
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
jmp 0x144ac
movq %rax, %r14
movq %r15, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x14782
cmpq $0x80, %rax
jge 0x14505
movq %rax, %rbx
cmpq $-0x81, %rax
jle 0x1454e
pushq $0x38
popq %rdi
callq 0x6360
movq %rax, %r15
movsbl %bl, %esi
movq %rax, %rdi
callq 0x14832
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x6c32(%rip), %rsi      # 0x1b149
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6b1c
xorl %r15d, %r15d
leaq 0x15123(%rip), %rsi     # 0x29660
leaq -0xd330(%rip), %rdx     # 0x7214
movq %rbx, %rdi
callq 0x6520
jmp 0x14595
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
leaq 0x6be9(%rip), %rsi      # 0x1b149
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x6140
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6bd0
xorl %r15d, %r15d
leaq 0x150f2(%rip), %rsi     # 0x29678
leaq -0xd333(%rip), %rdx     # 0x725a
movq %rbx, %rdi
callq 0x6520
jmp 0x14599
jmp 0x145ac
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x145af
jmp 0x145c4
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
jmp 0x145c4
movq %rax, %r14
movq %r15, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rdi
pushq $0x5
popq %rsi
leaq -0x11(%rbp), %rdx
callq 0x1487a
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17e70
movq %r14, %rdi
callq 0x17d48
movq (%rbx), %rax
leaq -0x1a6(%rip), %rcx      # 0x144b4
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movq (%rbx), %rax
leaq -0x2d0(%rip), %rcx      # 0x1439c
movq %rcx, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq (%rbx), %rax
leaq -0x403(%rip), %rcx      # 0x1427c
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq (%rbx), %rax
leaq -0x542(%rip), %rcx      # 0x14150
movq %rcx, 0x30(%rax)
andq $0x0, 0x38(%rax)
movq (%rbx), %rax
leaq -0x681(%rip), %rcx      # 0x14024
movq %rcx, 0x40(%rax)
andq $0x0, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17d48
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movq 0x1550a(%rip), %rdi     # 0x29f88
movq 0x15563(%rip), %rsi     # 0x29fe8
callq 0xbdd4
xorl %ecx, %ecx
testb %al, %al
jne 0x14ac5
movq 0x154c9(%rip), %rdi     # 0x29f60
movq 0x1554a(%rip), %rsi     # 0x29fe8
callq 0xbdd4
testb %al, %al
je 0x14aab
pushq $0x1
jmp 0x14ac4
movq 0x15466(%rip), %rdi     # 0x29f18
movq 0x1552f(%rip), %rsi     # 0x29fe8
callq 0xbdd4
testb %al, %al
je 0x14b03
pushq $0x2
popq %rcx
movl %ecx, 0x30(%rbx)
andl $0x0, 0x34(%rbx)
movsd 0x8(%rbx), %xmm0
leaq -0x1b8(%rbp), %r14
movq %r14, %rdi
callq 0x15388
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6400
movq %r14, %rdi
callq 0x6190
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq 0x1548e(%rip), %rdi     # 0x29f98
movq 0x154d7(%rip), %rsi     # 0x29fe8
callq 0xbdd4
movzbl %al, %eax
pushq $0x4
popq %rcx
subl %eax, %ecx
testb %al, %al
pushq $0x7
popq %rax
pushq $0xe
popq %rdx
cmovnel %eax, %edx
movl %ecx, 0x30(%rbx)
movl %edx, 0x34(%rbx)
leaq -0x1b8(%rbp), %rdi
pushq $0x10
popq %rsi
callq 0x62c0
leaq -0x1a8(%rbp), %rdi
movslq 0x34(%rbx), %rax
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
movq %rax, -0x1a0(%rbp,%rcx)
movsd 0x8(%rbx), %xmm0
callq 0x64d0
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x64c0
addq $0x10, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6400
movq %r14, %rdi
callq 0x6190
leaq -0x1b8(%rbp), %rdi
callq 0x62b0
jmp 0x14af7
jmp 0x14ba0
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x62b0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl 0x30(%rdi), %ebx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
cmpl %eax, %ebx
jge 0x14bfc
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movl %eax, %ebx
jmp 0x14c00
movl 0x30(%r15), %ebx
cmpl $0x2, %ebx
jg 0x14c46
cvttsd2si 0x8(%r15), %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
pushq $0xa
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x14782
addq %rax, %r15
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x15466
leaq 0x15afe(%rip), %rdi     # 0x2a738
movl %ebx, %esi
movq %r14, %rdx
callq 0x145cc
jmp 0x14c85
fldl 0x8(%r15)
fstpt -0x24(%rbp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x146d4
fldt -0x24(%rbp)
faddp %st, %st(1)
fstpt (%rsp)
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x154c6
leaq 0x15abd(%rip), %rdi     # 0x2a738
movl %ebx, %esi
movq %r14, %rdx
callq 0x145cc
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x6190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14ca1
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x6190
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/prippa[P]Abstract-VM/source/../includes/Operand.template.hpp
// Function: Operand<double>::operator/(IOperand const&) const
IOperand const * operator/(IOperand const & rhs) const
	{
		if (std::stold(rhs.toString()) == 0)
			throw Exceptions::DivisionByZeroError();

		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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x50(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x146d4
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x14ec0
jnp 0x14f89
movl 0x30(%r15), %ebx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
cmpl %eax, %ebx
jge 0x14ede
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movl %eax, %ebx
jmp 0x14ee2
movl 0x30(%r15), %ebx
cmpl $0x2, %ebx
jg 0x14f30
cvttsd2si 0x8(%r15), %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
pushq $0xa
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x14782
movq %rax, %rcx
movq %r15, %rax
cqto
idivq %rcx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x15466
leaq 0x15814(%rip), %rdi     # 0x2a738
movl %ebx, %esi
movq %r14, %rdx
callq 0x145cc
jmp 0x14f6f
fldl 0x8(%r15)
fstpt -0x24(%rbp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x146d4
fldt -0x24(%rbp)
fdivp %st, %st(1)
fstpt (%rsp)
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x154c6
leaq 0x157d3(%rip), %rdi     # 0x2a738
movl %ebx, %esi
movq %r14, %rdx
callq 0x145cc
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x6190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x61c0
leaq 0x14768(%rip), %rcx     # 0x29700
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x14782(%rip), %rsi     # 0x29728
movq 0x15023(%rip), %rdx     # 0x29fd0
movq %rax, %rdi
callq 0x6520
jmp 0x14fb7
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x6190
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x30(%rdi), %r15d
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
cmpl %eax, %r15d
jge 0x15149
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x1514d
movl 0x30(%r14), %eax
cmpl $0x2, %eax
jg 0x15176
cvttsd2si 0x8(%r14), %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
pushq $0xa
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x155ab
cmpl %r14d, %eax
sete %al
jmp 0x151d3
movsd 0x8(%r14), %xmm0
cmpl $0x3, %eax
jne 0x151a9
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x155cc
cmpeqss -0x20(%rbp), %xmm0
movd %xmm0, %eax
jmp 0x151d0
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm0, -0x20(%rbp)
callq *0x50(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x155ea
movsd -0x20(%rbp), %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rsi), %rdi
cmpq %rdi, 0xa0(%rsi)
je 0x17f54
movq 0xa8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x60(%rbx)
callq 0x1932a
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x17f44
movq (%rdi), %rax
callq *0x60(%rax)
andq $0x0, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
addq $0x20, %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x7b48
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x1951c
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x6da8
xorl %r15d, %r15d
leaq 0x11755(%rip), %rsi     # 0x296e8
leaq -0x10c98(%rip), %rdx    # 0x7302
movq %rbx, %rdi
callq 0x6520
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x17fb8
jmp 0x17fc0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x1, 0xb0(%rsi)
jbe 0x180c1
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rsi), %r15
movq 0xa8(%rsi), %rax
movq 0x10(%rax), %rax
movq %rax, 0x60(%rdi)
movq %r15, %rdi
callq 0x1932a
movq 0xa8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x68(%rbx)
movq %r15, %rdi
callq 0x1932a
movq 0x60(%rbx), %rsi
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x19338
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1809d
movq (%rdi), %rax
callq *0x60(%rax)
andq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x180b1
movq (%rdi), %rax
callq *0x60(%rax)
andq $0x0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x61c0
leaq 0x115c0(%rip), %rcx     # 0x29690
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x115da(%rip), %rsi     # 0x296b8
movq 0x11eeb(%rip), %rdx     # 0x29fd0
movq %rax, %rdi
callq 0x6520
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
leaq 0xa0(%rsi), %rax
cmpq %rax, 0xa0(%rsi)
je 0x184ac
movq %rdi, %rbx
movq 0xa8(%r14), %rax
movq 0x10(%rax), %rdi
movq %rdi, 0x60(%rbx)
movq (%rdi), %rax
callq *0x8(%rax)
testl %eax, %eax
jne 0x184fa
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
pushq $0xa
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x155ab
movsbl %al, %esi
movq 0x11ae9(%rip), %rdi     # 0x29f78
callq 0x63f0
movq %rax, %rdi
callq 0x61b0
andq $0x0, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
addq $0x20, %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x7b48
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x1951c
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x6da8
xorl %r15d, %r15d
leaq 0x111fd(%rip), %rsi     # 0x296e8
leaq -0x111f0(%rip), %rdx    # 0x7302
movq %rbx, %rdi
callq 0x6520
andq $0x0, 0x60(%rbx)
pushq $0x8
popq %rdi
callq 0x61c0
leaq 0x11232(%rip), %rcx     # 0x29740
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x1124c(%rip), %rsi     # 0x29768
movq 0x11aad(%rip), %rdx     # 0x29fd0
movq %rax, %rdi
callq 0x6520
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x18541
jmp 0x18549
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xa0(%rsi), %r15
movq 0xa0(%rsi), %r12
cmpq %r15, %r12
je 0x185ed
movq %rdi, %rbx
movq 0x10(%r12), %rax
movq %rax, 0x68(%rdi)
leaq 0x60(%rdi), %r14
cmpq %r15, %r12
je 0x185b8
movq 0x10(%r12), %rsi
movq %rsi, 0x60(%rbx)
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x185b2
movq 0x60(%rbx), %rax
movq %rax, 0x68(%rbx)
movq (%r12), %r12
jmp 0x1858e
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x119af(%rip), %rdi     # 0x29f78
movq %rax, %rsi
callq 0x6310
movq %rax, %rdi
callq 0x61b0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
addq $0x20, %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x7b48
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1951c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6da8
xorl %r15d, %r15d
leaq 0x110b9(%rip), %rsi     # 0x296e8
leaq -0x11334(%rip), %rdx    # 0x7302
movq %rbx, %rdi
callq 0x6520
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x18654
jmp 0x1865c
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
addq $0xa0, %r15
xorl %r12d, %r12d
leaq 0x3d9b(%rip), %r14      # 0x1c52c
movq %r15, %rbx
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
xorl %r13d, %r13d
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x187ed
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x3, %eax
ja 0x187e7
movl %eax, %eax
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
incq %r13
jmp 0x187af
incq -0x38(%rbp)
jmp 0x187af
incq %r12
jmp 0x187af
incq -0x30(%rbp)
jmp 0x187af
incq -0x40(%rbp)
jmp 0x187af
movq 0x11784(%rip), %rbx     # 0x29f78
leaq 0x3d42(%rip), %rsi      # 0x1c53d
movq %rbx, %rdi
callq 0x6350
movq %rax, %rdi
movq %r13, %rsi
callq 0x6260
movq %rax, %rdi
callq 0x61b0
leaq 0x3d2a(%rip), %rsi      # 0x1c547
movq %rbx, %rdi
callq 0x6350
movq %rax, %rdi
movq %r12, %rsi
callq 0x6260
movq %rax, %rdi
callq 0x61b0
leaq 0x3d12(%rip), %rsi      # 0x1c551
movq %rbx, %rdi
callq 0x6350
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x6260
movq %rax, %rdi
callq 0x61b0
leaq 0x3cf9(%rip), %rsi      # 0x1c55b
movq %rbx, %rdi
callq 0x6350
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x6260
movq %rax, %rdi
callq 0x61b0
leaq 0x3ce0(%rip), %rsi      # 0x1c565
movq %rbx, %rdi
callq 0x6350
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x6260
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsi), %r14
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x7b48
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x1951c
movq %r15, %rdi
movq %r12, %rsi
callq 0x19358
movl (%rax), %r15d
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x7b48
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1951c
leaq 0x11e29(%rip), %rdi     # 0x2a738
leaq -0x40(%rbp), %rdx
movl %r15d, %esi
callq 0x145cc
addq $0xa0, %rbx
leaq -0x48(%rbp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x19348
leaq -0x40(%rbp), %rdi
callq 0x6190
leaq -0x68(%rbp), %rdi
callq 0x6190
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18960
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x6190
jmp 0x18963
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x6190
movq %rbx, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/prippa[P]Abstract-VM/source/CommandsExecutor.class.cpp
// Function: CommandsExecutor::ce_assert(Base&)
void	CommandsExecutor::ce_assert(Base & bs)
{
	if (bs.stack_.empty())
		throw Exceptions::EmptyStackError(bs.result_[REGEX_CMD_INDEX]);
	right_ = fac_.createOperand(
		type_[bs.result_[REGEX_TYPE_INDEX]],
		bs.result_[REGEX_VALUE_INDEX]);
	left_ = bs.stack_.back();
	if (!(*right_ == *left_))
	{
		std::string left_str =  left_->toString();
		left_ = nullptr;
		throw Exceptions::AssertError(right_->toString(), left_str);
	}
	left_ = nullptr;
	ce_del_io(&right_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
leaq 0xa0(%rsi), %rax
cmpq %rax, 0xa0(%rsi)
je 0x18a4c
movq %rdi, %rbx
leaq 0x20(%r14), %r15
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x7b48
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x1951c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19358
movl (%rax), %r12d
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x7b48
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1951c
leaq 0x11d51(%rip), %rdi     # 0x2a738
leaq -0x60(%rbp), %rdx
movl %r12d, %esi
callq 0x145cc
movq %rax, 0x60(%rbx)
leaq -0x60(%rbp), %rdi
callq 0x6190
leaq -0x40(%rbp), %rdi
callq 0x6190
movq 0xa8(%r14), %rax
movq 0x10(%rax), %rsi
movq %rsi, 0x68(%rbx)
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x18a9c
andq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x18a3a
movq (%rdi), %rax
callq *0x60(%rax)
andq $0x0, 0x60(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
addq $0x20, %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x7b48
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1951c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6da8
xorl %r15d, %r15d
leaq 0x10c5d(%rip), %rsi     # 0x296e8
leaq -0x11790(%rip), %rdx    # 0x7302
movq %rbx, %rdi
callq 0x6520
jmp 0x18af1
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x6450
andq $0x0, 0x68(%rbx)
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %r15
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x6c92
leaq 0x10bee(%rip), %rsi     # 0x296d0
leaq -0x1182d(%rip), %rdx    # 0x72bc
movq %r15, %rdi
callq 0x6520
jmp 0x18b30
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x18b16
jmp 0x18b3c
movq %rax, %r14
movq %r15, %rdi
callq 0x6290
jmp 0x18b33
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
jmp 0x18b3c
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x6190
jmp 0x18b33
jmp 0x18b30
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/prippa[P]Abstract-VM/source/CommandsExecutor.class.cpp
// Function: CommandsExecutor::ce_less(Base&)
void	CommandsExecutor::ce_less(Base & bs)
{
	if (bs.stack_.empty())
		throw Exceptions::EmptyStackError(bs.result_[REGEX_CMD_INDEX]);
	right_ = fac_.createOperand(
		type_[bs.result_[REGEX_TYPE_INDEX]],
		bs.result_[REGEX_VALUE_INDEX]);
	left_ = bs.stack_.back();
	if (*right_ > *left_)
	{
		std::string left_str =  left_->toString();
		left_ = nullptr;
		throw Exceptions::LessError(right_->toString(), left_str);
	}
	left_ = nullptr;
	ce_del_io(&right_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
leaq 0xa0(%rsi), %rax
cmpq %rax, 0xa0(%rsi)
je 0x18c1c
movq %rdi, %rbx
leaq 0x20(%r14), %r15
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x7b48
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x1951c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19358
movl (%rax), %r12d
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x7b48
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1951c
leaq 0x11b81(%rip), %rdi     # 0x2a738
leaq -0x60(%rbp), %rdx
movl %r12d, %esi
callq 0x145cc
movq %rax, 0x60(%rbx)
leaq -0x60(%rbp), %rdi
callq 0x6190
leaq -0x40(%rbp), %rdi
callq 0x6190
movq 0xa8(%r14), %rax
movq 0x10(%rax), %rsi
movq %rsi, 0x68(%rbx)
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
jne 0x18c6c
andq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x18c0a
movq (%rdi), %rax
callq *0x60(%rax)
andq $0x0, 0x60(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %rbx
addq $0x20, %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x7b48
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1951c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6da8
xorl %r15d, %r15d
leaq 0x10a8d(%rip), %rsi     # 0x296e8
leaq -0x11960(%rip), %rdx    # 0x7302
movq %rbx, %rdi
callq 0x6520
jmp 0x18cc1
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x6450
andq $0x0, 0x68(%rbx)
pushq $0x28
popq %rdi
callq 0x61c0
movq %rax, %r15
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x6f8e
leaq 0x10ae6(%rip), %rsi     # 0x29798
leaq -0x118f3(%rip), %rdx    # 0x73c6
movq %r15, %rdi
callq 0x6520
jmp 0x18d00
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
testb %r15b, %r15b
jne 0x18ce6
jmp 0x18d0c
movq %rax, %r14
movq %r15, %rdi
callq 0x6290
jmp 0x18d03
movq %rax, %r14
movq %rbx, %rdi
callq 0x6290
jmp 0x18d0c
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x6190
jmp 0x18d03
jmp 0x18d00
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x6190
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/ixchow[P]http-tweak/tweak.cpp
// Function: tweak::tweak::~tweak()
tweak::~tweak() {
	auto &internal = get_internal();

	std::unique_lock< std::mutex > lock(internal.mutex);

	auto f = internal.tweaks.find(this);
	assert(f != internal.tweaks.end());
	internal.tweaks.erase(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x41cd
leaq 0xafc8(%rip), %rsi      # 0xf330
leaq -0x20(%rbp), %rdi
callq 0x5a32
leaq -0x10(%rbp), %rsi
movq %rbx, (%rsi)
leaq 0xafd9(%rip), %rdi      # 0xf358
callq 0x83fe
testq %rax, %rax
je 0x43cb
leaq 0xafc8(%rip), %rdi      # 0xf358
movq %rax, %rsi
callq 0x8420
leaq -0x20(%rbp), %rdi
callq 0x5a52
leaq 0x60(%rbx), %rdi
callq 0x3d1e
leaq 0x40(%rbx), %rdi
callq 0x3d1e
leaq 0x20(%rbx), %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x31c0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5dcb(%rip), %rdi      # 0xa19d
leaq 0x5ddf(%rip), %rsi      # 0xa1b8
leaq 0x5de2(%rip), %rcx      # 0xa1c2
pushq $0x46
popq %rdx
callq 0x3270
movq %rax, %rdi
callq 0x3c4e
// File: /workspace/github_cpp_makefile_star2_O2/ixchow[P]http-tweak/tweak.cpp
// Function: tweak::config(unsigned short, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void config(uint16_t port, std::string const &ui_file) {
	auto &internal = get_internal();
	std::unique_lock< std::mutex > lock(internal.mutex);
	internal.port = port;
	internal.ui_file = ui_file;
	if (internal.server) internal.server.reset(); //kill off server so it will be started with new port.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
callq 0x41cd
leaq 0xaf23(%rip), %rsi      # 0xf330
leaq -0x20(%rbp), %rdi
callq 0x5a32
leaq 0xaef3(%rip), %rdi      # 0xf310
movw %r14w, 0xaf6b(%rip)     # 0xf390
movq %rbx, %rsi
callq 0x3210
cmpq $0x0, 0xaf63(%rip)      # 0xf398
je 0x4445
leaq 0xaf5a(%rip), %rdi      # 0xf398
xorl %esi, %esi
callq 0x6a62
leaq -0x20(%rbp), %rdi
callq 0x5a52
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x5a52
movq %rbx, %rdi
callq 0x3540