LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x40, %rsp
movq (%rsi), %rbx
callq 0x6060
movq %rax, %r14
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x48(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6530
cmpq %rbx, (%r15)
je 0x162a3
movl (%r14), %eax
testl %eax, %eax
je 0x16251
cmpl $0x22, %eax
jne 0x16254
fstp %st(0)
leaq 0xc19d(%rip), %rdi      # 0x223e9
callq 0x64a0
movl %r12d, (%r14)
flds 0xc16e(%rip)            # 0x223c8
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x162b1
flds 0xc164(%rip)            # 0x223cc
fucompi %st(1), %st
fstpt -0x54(%rbp)
ja 0x16309
movl $0x38, %edi
callq 0x6370
movq %rax, %r14
fldt -0x54(%rbp)
fstps -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movq %rax, %rdi
callq 0x16a28
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
leaq 0xc13d(%rip), %rdi      # 0x223e9
callq 0x6220
fstp %st(0)
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xc108(%rip), %rsi      # 0x223d7
leaq 0xc106(%rip), %rdx      # 0x223dc
leaq -0x48(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6e4a
xorl %r12d, %r12d
leaq 0x16398(%rip), %rsi     # 0x2c690
leaq -0xe95b(%rip), %rdx     # 0x79a4
movq %r14, %rdi
callq 0x6550
jmp 0x1635d
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xc0b2(%rip), %rsi      # 0x223d7
leaq 0xc0b0(%rip), %rdx      # 0x223dc
leaq -0x48(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6f60
xorl %r12d, %r12d
leaq 0x1635a(%rip), %rsi     # 0x2c6a8
leaq -0xe941(%rip), %rdx     # 0x7a14
movq %r14, %rdi
callq 0x6550
jmp 0x16361
jmp 0x16379
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x16372
callq 0x6340
testb %r12b, %r12b
jne 0x1637c
jmp 0x1639f
movq %rax, %rbx
movq %r14, %rdi
callq 0x62b0
jmp 0x1639f
movq %rax, %rbx
movq %r14, %rdi
callq 0x6340
jmp 0x1639f
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1639f
movl %r12d, (%r14)
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %r15
callq 0x6060
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x60a0
cmpq %r15, (%r12)
je 0x1644b
movq %rax, %rbx
movl (%r14), %eax
testl %eax, %eax
je 0x16402
cmpl $0x22, %eax
jne 0x16405
leaq 0xbff2(%rip), %rdi      # 0x223ef
callq 0x64a0
movl %r13d, (%r14)
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, %rbx
jge 0x16457
movabsq $-0x80000001, %rax      # imm = 0xFFFFFFFF7FFFFFFF
cmpq %rax, %rbx
jle 0x164ad
movl $0x38, %edi
callq 0x6370
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x16a82
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbf9d(%rip), %rdi      # 0x223ef
callq 0x6220
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xbf6a(%rip), %rsi      # 0x223dd
leaq 0xbf68(%rip), %rdx      # 0x223e2
leaq -0x48(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6e4a
xorl %r12d, %r12d
leaq 0x161f4(%rip), %rsi     # 0x2c690
leaq -0xeaff(%rip), %rdx     # 0x79a4
movq %r14, %rdi
callq 0x6550
jmp 0x16501
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xbf14(%rip), %rsi      # 0x223dd
leaq 0xbf12(%rip), %rdx      # 0x223e2
leaq -0x48(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6f60
xorl %r12d, %r12d
leaq 0x161b6(%rip), %rsi     # 0x2c6a8
leaq -0xeae5(%rip), %rdx     # 0x7a14
movq %r14, %rdi
callq 0x6550
jmp 0x16505
jmp 0x1651d
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x16516
callq 0x6340
testb %r12b, %r12b
jne 0x16520
jmp 0x16543
movq %rax, %rbx
movq %r14, %rdi
callq 0x62b0
jmp 0x16543
movq %rax, %rbx
movq %r14, %rdi
callq 0x6340
jmp 0x16543
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x16543
movl %r13d, (%r14)
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %r15
callq 0x6060
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x60a0
cmpq %r15, (%r12)
je 0x165e9
movq %rax, %rbx
movl (%r14), %eax
testl %eax, %eax
je 0x165a6
cmpl $0x22, %eax
jne 0x165a9
leaq 0xbe4e(%rip), %rdi      # 0x223ef
callq 0x64a0
movl %r13d, (%r14)
cmpq $0x8000, %rbx           # imm = 0x8000
jge 0x165f5
cmpq $-0x8001, %rbx          # imm = 0xFFFF7FFF
jle 0x1664b
movl $0x38, %edi
callq 0x6370
movq %rax, %r14
movswl %bx, %esi
movq %rax, %rdi
callq 0x16ada
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbdff(%rip), %rdi      # 0x223ef
callq 0x6220
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xbdd2(%rip), %rsi      # 0x223e3
leaq 0xbdd0(%rip), %rdx      # 0x223e8
leaq -0x48(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6e4a
xorl %r12d, %r12d
leaq 0x16056(%rip), %rsi     # 0x2c690
leaq -0xec9d(%rip), %rdx     # 0x79a4
movq %r14, %rdi
callq 0x6550
jmp 0x1669f
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xbd7c(%rip), %rsi      # 0x223e3
leaq 0xbd7a(%rip), %rdx      # 0x223e8
leaq -0x48(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6f60
xorl %r12d, %r12d
leaq 0x16018(%rip), %rsi     # 0x2c6a8
leaq -0xec83(%rip), %rdx     # 0x7a14
movq %r14, %rdi
callq 0x6550
jmp 0x166a3
jmp 0x166bb
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x166b4
callq 0x6340
testb %r12b, %r12b
jne 0x166be
jmp 0x166e1
movq %rax, %rbx
movq %r14, %rdi
callq 0x62b0
jmp 0x166e1
movq %rax, %rbx
movq %r14, %rdi
callq 0x6340
jmp 0x166e1
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x166e1
movl %r13d, (%r14)
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %r15
callq 0x6060
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x60a0
cmpq %r15, (%r12)
je 0x16787
movq %rax, %rbx
movl (%r14), %eax
testl %eax, %eax
je 0x16744
cmpl $0x22, %eax
jne 0x16747
leaq 0xbcb0(%rip), %rdi      # 0x223ef
callq 0x64a0
movl %r13d, (%r14)
cmpq $0x80, %rbx
jge 0x16793
cmpq $-0x81, %rbx
jle 0x167e9
movl $0x38, %edi
callq 0x6370
movq %rax, %r14
movsbl %bl, %esi
movq %rax, %rdi
callq 0x16b32
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbc61(%rip), %rdi      # 0x223ef
callq 0x6220
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xa99a(%rip), %rsi      # 0x21149
leaq 0xa997(%rip), %rdx      # 0x2114d
leaq -0x48(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6e4a
xorl %r12d, %r12d
leaq 0x15eb8(%rip), %rsi     # 0x2c690
leaq -0xee3b(%rip), %rdx     # 0x79a4
movq %r14, %rdi
callq 0x6550
jmp 0x1683d
movl $0x28, %edi
callq 0x61d0
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xa944(%rip), %rsi      # 0x21149
leaq 0xa941(%rip), %rdx      # 0x2114d
leaq -0x48(%rbp), %rdi
callq 0x16c24
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x6f60
xorl %r12d, %r12d
leaq 0x15e7a(%rip), %rsi     # 0x2c6a8
leaq -0xee21(%rip), %rdx     # 0x7a14
movq %r14, %rdi
callq 0x6550
jmp 0x16841
jmp 0x16859
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x16852
callq 0x6340
testb %r12b, %r12b
jne 0x1685c
jmp 0x1687f
movq %rax, %rbx
movq %r14, %rdi
callq 0x62b0
jmp 0x1687f
movq %rax, %rbx
movq %r14, %rdi
callq 0x6340
jmp 0x1687f
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1687f
movl %r13d, (%r14)
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movl $0x5, %esi
callq 0x16b8a
movq (%rbx), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rbx)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
testq %rdi, %rdi
je 0x1693d
callq 0x6340
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1693d
callq 0x6340
movq (%rbx), %rax
leaq -0x25d(%rip), %rcx      # 0x166ea
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq (%rbx), %rax
leaq -0x40e(%rip), %rdx      # 0x1654c
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq (%rbx), %rax
leaq -0x5c4(%rip), %rdx      # 0x163a8
movq %rdx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movq (%rbx), %rax
leaq -0x77e(%rip), %rdx      # 0x16200
movq %rdx, 0x30(%rax)
movq %rcx, 0x38(%rax)
movq (%rbx), %rax
leaq -0x938(%rip), %rdx      # 0x16058
movq %rdx, 0x40(%rax)
movq %rcx, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x169b1
callq 0x6340
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movq 0x162ba(%rip), %rax     # 0x2cf98
movq 0x8(%rax), %rdi
movq 0x162ff(%rip), %rax     # 0x2cfe8
movq 0x8(%rax), %r14
xorl %r15d, %r15d
cmpq %r14, %rdi
je 0x16e37
cmpb $0x2a, (%rdi)
je 0x16d0e
movq %r14, %rsi
callq 0x6460
testl %eax, %eax
je 0x16e37
movq 0x16263(%rip), %rax     # 0x2cf78
movq 0x8(%rax), %rdi
movl $0x1, %r15d
cmpq %r14, %rdi
je 0x16e37
cmpb $0x2a, (%rdi)
je 0x16d3d
movq %r14, %rsi
callq 0x6460
testl %eax, %eax
je 0x16e37
movq 0x161f4(%rip), %rax     # 0x2cf38
movq 0x8(%rax), %rdi
movl $0x2, %r15d
cmpq %r14, %rdi
je 0x16e37
cmpb $0x2a, (%rdi)
je 0x16d6c
movq %r14, %rsi
callq 0x6460
testl %eax, %eax
je 0x16e37
movq 0x1622d(%rip), %rax     # 0x2cfa0
movq 0x8(%rax), %rdi
movl $0x7, %r15d
movl $0x3, %r12d
cmpq %r14, %rdi
je 0x16da5
cmpb $0x2a, (%rdi)
je 0x16d99
movq %r14, %rsi
callq 0x6460
testl %eax, %eax
je 0x16da5
movl $0xe, %r15d
movl $0x4, %r12d
movl %r12d, 0x30(%rbx)
movl %r15d, 0x34(%rbx)
leaq -0x1c8(%rbp), %rdi
movl $0x10, %esi
callq 0x62d0
leaq -0x1b8(%rbp), %rdi
movslq 0x34(%rbx), %rax
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
movq %rax, -0x1b0(%rbp,%rcx)
movsd 0x8(%rbx), %xmm0
callq 0x64f0
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x64e0
addq $0x10, %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6410
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x16e16
callq 0x6340
movq 0x1612b(%rip), %rsi     # 0x2cf48
leaq -0x1c8(%rbp), %rdi
callq 0x62c0
leaq -0x148(%rbp), %rdi
callq 0x6130
jmp 0x16e8e
movl %r15d, 0x30(%rbx)
movl $0x0, 0x34(%rbx)
movsd 0x8(%rbx), %xmm0
movq 0x1610a(%rip), %rsi     # 0x2cf58
leaq 0xb5a0(%rip), %rcx      # 0x223f5
leaq -0x1c8(%rbp), %r14
movl $0x148, %edx            # imm = 0x148
movq %r14, %rdi
movb $0x1, %al
callq 0x183b1
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6410
movq (%r14), %rdi
leaq -0x1b8(%rbp), %rax
cmpq %rax, %rdi
je 0x16e8e
callq 0x6340
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16ea0
movq %rax, %rbx
movq 0x1609e(%rip), %rsi     # 0x2cf48
leaq -0x1c8(%rbp), %rdi
callq 0x62c0
leaq -0x148(%rbp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x30(%rdi), %r15d
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
cmpl %eax, %r15d
jge 0x17e4c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x17e50
movl 0x30(%r14), %eax
cmpl $0x2, %eax
jg 0x17ebe
cvttsd2si 0x8(%r14), %r13d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movq (%rax), %r14
callq 0x6060
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x6470
cmpq %r14, (%r15)
je 0x17f99
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x17fa5
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x17fa5
testl %ecx, %ecx
jne 0x17eb3
movl %r12d, (%rbx)
cmpl %r13d, %eax
sete %al
jmp 0x17f8a
movsd 0x8(%r14), %xmm0
movsd %xmm0, -0x30(%rbp)
cmpl $0x3, %eax
jne 0x17f1a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movq (%rax), %r14
callq 0x6060
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6440
cmpq %r14, (%r15)
je 0x17fb1
movl (%rbx), %eax
testl %eax, %eax
je 0x17f62
cmpl $0x22, %eax
jne 0x17f65
leaq 0xa4ec(%rip), %rdi      # 0x22401
callq 0x64a0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movq (%rax), %r14
callq 0x6060
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x62e0
cmpq %r14, (%r15)
je 0x17fbd
movl (%rbx), %eax
testl %eax, %eax
je 0x17f75
cmpl $0x22, %eax
jne 0x17f78
leaq 0xa4a9(%rip), %rdi      # 0x22406
callq 0x64a0
movl %r12d, (%rbx)
cvtsd2ss -0x30(%rbp), %xmm1
cmpeqss %xmm1, %xmm0
movd %xmm0, %eax
jmp 0x17f87
movl %r12d, (%rbx)
movsd -0x30(%rbp), %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa45c(%rip), %rdi      # 0x223fc
callq 0x6220
leaq 0xa450(%rip), %rdi      # 0x223fc
callq 0x64a0
leaq 0xa449(%rip), %rdi      # 0x22401
callq 0x6220
leaq 0xa442(%rip), %rdi      # 0x22406
callq 0x6220
jmp 0x17fcd
jmp 0x17fcd
cmpl $0x0, (%rbx)
jne 0x17fd5
movl %r12d, (%rbx)
movq %rax, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0xa0(%rsi), %rax
cmpq %rax, 0xa0(%rsi)
je 0x1dc81
movq %rdi, %rbx
movq 0xa8(%r14), %r15
movq 0x10(%r15), %rax
movq %rax, 0x60(%rdi)
decq 0xb0(%r14)
movq %r15, %rdi
callq 0x6510
movq %r15, %rdi
callq 0x6340
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x1dc6e
movq (%rdi), %rax
callq *0x60(%rax)
movq $0x0, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x61d0
movq %rax, %rbx
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rax
subq %rsi, %rax
je 0x1dcc0
movq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
addq $-0x5, %rdx
cmpq $-0x3, %rdx
ja 0x1dcc0
addq $0x18, %rsi
jmp 0x1dcc7
addq %rax, %rsi
addq $-0x48, %rsi
leaq -0x38(%rbp), %rdi
callq 0x1f8c0
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x72a6
xorl %r15d, %r15d
leaq 0xea2f(%rip), %rsi      # 0x2c718
leaq -0x161e0(%rip), %rdx    # 0x7b10
movq %rbx, %rdi
callq 0x6550
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dd0d
callq 0x6340
testb %r15b, %r15b
jne 0x1dd17
jmp 0x1dd1f
movq %rax, %r14
movq %rbx, %rdi
callq 0x62b0
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq 0xb0(%rsi), %rax
cmpq $0x1, %rax
jbe 0x1de8a
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rsi), %r15
movq 0xa8(%rsi), %r12
movq 0x10(%r12), %rcx
movq %rcx, 0x60(%rdi)
decq %rax
movq %rax, 0xb0(%rsi)
movq %r12, %rdi
callq 0x6510
movq %r12, %rdi
callq 0x6340
movq 0xa8(%r14), %r12
movq 0x10(%r12), %rax
movq %rax, 0x68(%rbx)
decq 0xb0(%r14)
movq %r12, %rdi
callq 0x6510
movq %r12, %rdi
callq 0x6340
movq 0x60(%rbx), %rsi
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r12
movl $0x18, %edi
callq 0x6370
movq %r12, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x6070
incq 0xb0(%r14)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1de62
movq (%rdi), %rax
callq *0x60(%rax)
movq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x1de79
movq (%rdi), %rax
callq *0x60(%rax)
movq $0x0, 0x60(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x61d0
leaq 0xe825(%rip), %rcx      # 0x2c6c0
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0xe83f(%rip), %rsi      # 0x2c6e8
movq 0xf120(%rip), %rdx      # 0x2cfd0
movq %rax, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
leaq 0xa0(%rsi), %rax
cmpq %rax, 0xa0(%rsi)
je 0x1e3f3
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 0x1e432
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq (%rax), %r15
callq 0x6060
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x6470
cmpq %r15, (%r12)
je 0x1e468
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x1e474
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x1e474
testl %ecx, %ecx
jne 0x1e39b
movl %r13d, (%r14)
leaq -0x48(%rbp), %rsi
movb %al, (%rsi)
movq 0xebe8(%rip), %rdi      # 0x2cf90
movl $0x1, %edx
callq 0x63e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6280
movq $0x0, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x61d0
movq %rax, %rbx
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rax
subq %rsi, %rax
je 0x1e480
movq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
addq $-0x5, %rdx
cmpq $-0x3, %rdx
ja 0x1e480
addq $0x18, %rsi
jmp 0x1e487
movq $0x0, 0x60(%rbx)
movl $0x8, %edi
callq 0x61d0
leaq 0xe325(%rip), %rcx      # 0x2c770
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0xe33f(%rip), %rsi      # 0x2c798
movq 0xeb70(%rip), %rdx      # 0x2cfd0
movq %rax, %rdi
callq 0x6550
leaq 0x3f8d(%rip), %rdi      # 0x223fc
callq 0x6220
leaq 0x3f81(%rip), %rdi      # 0x223fc
callq 0x64a0
addq %rax, %rsi
addq $-0x48, %rsi
leaq -0x48(%rbp), %rdi
callq 0x1f8c0
movb $0x1, %r14b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x72a6
xorl %r14d, %r14d
leaq 0xe26f(%rip), %rsi      # 0x2c718
leaq -0x169a0(%rip), %rdx    # 0x7b10
movq %rbx, %rdi
callq 0x6550
movq %rax, %r15
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e4cd
callq 0x6340
testb %r14b, %r14b
jne 0x1e4d7
jmp 0x1e4ed
movq %rax, %r15
movq %rbx, %rdi
callq 0x62b0
jmp 0x1e4ed
movq %rax, %r15
cmpl $0x0, (%r14)
jne 0x1e4ed
movl %r13d, (%r14)
movq %r15, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e5b9
movq %rdi, %rbx
movq 0x10(%r12), %rax
movq %rax, 0x68(%rdi)
leaq 0x60(%rdi), %r14
movq 0x10(%r12), %rsi
movq %rsi, 0x60(%rbx)
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x1e555
movq 0x60(%rbx), %rax
movq %rax, 0x68(%rbx)
movq (%r12), %r12
cmpq %r15, %r12
jne 0x1e536
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0xea1a(%rip), %rdi      # 0x2cf90
callq 0x63e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6280
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movl $0x28, %edi
callq 0x61d0
movq %rax, %rbx
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rax
subq %rsi, %rax
je 0x1e5fb
movq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
addq $-0x5, %rdx
cmpq $-0x3, %rdx
ja 0x1e5fb
addq $0x18, %rsi
jmp 0x1e602
addq %rax, %rsi
addq $-0x48, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1f8c0
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x72a6
xorl %r15d, %r15d
leaq 0xe0f4(%rip), %rsi      # 0x2c718
leaq -0x16b1b(%rip), %rdx    # 0x7b10
movq %rbx, %rdi
callq 0x6550
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e648
callq 0x6340
testb %r15b, %r15b
jne 0x1e652
jmp 0x1e65a
movq %rax, %r14
movq %rbx, %rdi
callq 0x62b0
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq 0xa0(%rsi), %r14
addq $0xa0, %rbx
cmpq %rbx, %r14
je 0x1e84e
xorl %r12d, %r12d
leaq 0x3d37(%rip), %r15      # 0x2252c
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
xorl %r13d, %r13d
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x3, %eax
ja 0x1e840
movl %eax, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
incq %r12
jmp 0x1e844
incq -0x30(%rbp)
jmp 0x1e844
incq -0x38(%rbp)
jmp 0x1e844
incq %r13
jmp 0x1e844
incq -0x40(%rbp)
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x1e810
jmp 0x1e86c
xorl %r13d, %r13d
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
xorl %r12d, %r12d
movq 0xe71d(%rip), %r14      # 0x2cf90
leaq 0x3cc3(%rip), %rsi      # 0x2253d
movl $0x9, %edx
movq %r14, %rdi
callq 0x63e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x6270
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6280
leaq 0x3c84(%rip), %rsi      # 0x22547
movl $0x9, %edx
movq %r14, %rdi
callq 0x63e0
movq %r14, %rdi
movq %r13, %rsi
callq 0x6270
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6280
leaq 0x3c45(%rip), %rsi      # 0x22551
movl $0x9, %edx
movq %r14, %rdi
callq 0x63e0
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x6270
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6280
leaq 0x3c05(%rip), %rsi      # 0x2255b
movl $0x9, %edx
movq %r14, %rdi
callq 0x63e0
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x6270
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6280
leaq 0x3bc5(%rip), %rsi      # 0x22565
movl $0x9, %edx
movq %r14, %rdi
callq 0x63e0
movq %r14, %rdi
movq -0x40(%rbp), %rsi
callq 0x6270
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
subq %rax, %rcx
je 0x1ea37
movq %rcx, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
addq $-0x6, %rdx
cmpq $-0x4, %rdx
ja 0x1ea37
addq $0x30, %rax
jmp 0x1ea3e
addq %rcx, %rax
addq $-0x48, %rax
cmpb $0x1, 0x10(%rax)
jne 0x1ea5e
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x58(%rbp), %rdi
callq 0x16c24
jmp 0x1ea71
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x1f908
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rdx
subq %rcx, %rdx
je 0x1eaa5
movq %rdx, %rsi
sarq $0x3, %rsi
imulq %r15, %rsi
addq $-0x7, %rsi
cmpq $-0x5, %rsi
ja 0x1eaa5
addq $0x48, %rcx
jmp 0x1eaac
addq %rdx, %rcx
addq $-0x48, %rcx
movl (%rax), %r14d
cmpb $0x1, 0x10(%rcx)
jne 0x1eacf
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x38(%rbp), %rdi
callq 0x16c24
jmp 0x1eae2
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xec5f(%rip), %rdi      # 0x2d748
leaq -0x38(%rbp), %rdx
movl %r14d, %esi
callq 0x16888
movq %rax, %r14
movl $0x18, %edi
callq 0x6370
leaq 0xa0(%rbx), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x6070
incq 0xb0(%rbx)
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1eb2e
callq 0x6340
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1eb40
callq 0x6340
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1eb4d
movq %rax, %rbx
jmp 0x1eb67
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1eb67
callq 0x6340
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1eb79
callq 0x6340
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4374
leaq 0xaf3c(%rip), %rax      # 0xf338
leaq -0x18(%rbp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x8efe
movb $0x1, -0x10(%rbp)
leaq -0x20(%rbp), %rsi
movq %rbx, (%rsi)
leaq 0xaf42(%rip), %rdi      # 0xf360
callq 0x923c
testq %rax, %rax
je 0x44a4
leaq 0xaf31(%rip), %rdi      # 0xf360
movq %rax, %rsi
callq 0x929e
leaq -0x18(%rbp), %rdi
callq 0x681c
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x4457
leaq 0x60(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x446e
leaq 0x40(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x4486
movq (%rax), %rsi
incq %rsi
callq 0x3380
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x449d
movq (%rbx), %rsi
incq %rsi
callq 0x3380
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x6cfa(%rip), %rdi      # 0xb1a5
leaq 0x6d0e(%rip), %rsi      # 0xb1c0
leaq 0x6d11(%rip), %rcx      # 0xb1ca
movl $0x46, %edx
callq 0x3280
jmp 0x44c7
jmp 0x44c7
movq %rax, %rdi
callq 0x3e8a
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
callq 0x4374
leaq 0xae48(%rip), %rax      # 0xf338
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
leaq 0xae1a(%rip), %r12      # 0xf318
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x8efe
movb $0x1, 0x8(%r15)
movw %r14w, 0xae80(%rip)     # 0xf398
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3220
movq 0xae76(%rip), %rsi      # 0xf3a0
testq %rsi, %rsi
je 0x4546
movq $0x0, 0xae66(%rip) # 0xf3a0
leaq 0xae5f(%rip), %rdi      # 0xf3a0
callq 0x7b2e
leaq -0x30(%rbp), %rdi
callq 0x681c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x681c
movq %rbx, %rdi
callq 0x3570
// File: /workspace/github_cpp_makefile_star2_O3/ixchow[P]http-tweak/tweak.cpp
// Function: utf8_to_json(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string utf8_to_json(std::string const &data) {
	std::string ret;
	auto it = std::back_inserter(ret);

	*it = '"'; ++it;
	for (auto c = data.begin(); c != data.end(); ++c) {
		if (*c == '\\' || *c == '"') {
			*it = '\\'; ++it; *it = *c; ++it;
		} else {
			*it = *c; ++it;
		}
	}
	*it = '"'; ++it;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x22, %esi
callq 0x3320
cmpq $0x0, 0x8(%r14)
je 0x5358
movq (%r14), %r12
movzbl (%r12), %eax
cmpl $0x5c, %eax
je 0x532d
cmpl $0x22, %eax
jne 0x533e
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x3320
movb (%r12), %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3320
incq %r12
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r12
jne 0x531e
movq %rbx, %rdi
movl $0x22, %esi
callq 0x3320
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5374
jmp 0x5374
jmp 0x5374
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x538a
movq (%r15), %rsi
incq %rsi
callq 0x3380
movq %r14, %rdi
callq 0x3570
// File: /workspace/github_cpp_makefile_star2_O3/Mirrvin[P]DragonsResurrectingInc/main.cpp
// Function: issuerMonitor(void*)
void *issuerMonitor (void* x) {
    packet_t packet;
    pthread_t handleResurrection;
    bool end = false;
    while(!end) {
        packet = Monitor::receiveMessage();
        if(packet.status.MPI_TAG == RESURRECTION_FINISHED)
            pthread_create( &handleResurrection, NULL, &handleResurrectionFinished,NULL);
        else {
            end = true;
            printf("%u: issuer ends listining\n",Monitor::getLamport());
        }
    }
    pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x5716
cmpl $0x77, 0x14(%rbx)
jne 0x251a
leaq -0x94(%rip), %rbx       # 0x2461
leaq -0x20(%rbp), %r14
leaq -0x48(%rbp), %r15
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x21f0
movq %r15, %rdi
callq 0x5716
cmpl $0x77, -0x34(%rbp)
je 0x24fd
callq 0x58c2
leaq 0x4bc9(%rip), %rdi      # 0x70ef
movl %eax, %esi
xorl %eax, %eax
callq 0x2030
xorl %edi, %edi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/Mirrvin[P]DragonsResurrectingInc/main.cpp
// Function: handleLoop(void*)
void *handleLoop (void* s ) {
    Specialist *specialist = (Specialist*) s;
    bool end = false;
    int count = 0;
    while(!end) {
        pthread_mutex_lock(&Monitor::handleMutex); // czeka, aż kolejka nie będzie pusta
        pthread_mutex_lock(&Monitor::messageQueueMutex); // dostęp do kolejki wiadomości
        if(!Monitor::messageQueue.empty()) {
            packet_t packet = Monitor::messageQueue.front();           
            Monitor::messageQueue.pop();
            pthread_mutex_unlock(&Monitor::messageQueueMutex);
            if(!specialist->handle(packet)) {
                end = true;
            }
        } else {
            pthread_mutex_unlock(&Monitor::messageQueueMutex);
        }

        pthread_mutex_lock(&Monitor::messageQueueMutex);
        if(!Monitor::messageQueue.empty()) {
            pthread_mutex_unlock(&Monitor::handleMutex); // kolejka nie jest pusta, lecimy dalej
        }
        pthread_mutex_unlock(&Monitor::messageQueueMutex);       
        count++;
    }
    Monitor::endListening();
    pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x7c17(%rip), %r14      # 0xa168
leaq 0x7c38(%rip), %r15      # 0xa190
leaq 0x7ca9(%rip), %r12      # 0xa208
movq %r14, %rdi
callq 0x2180
movq %r15, %rdi
callq 0x2180
movq 0x10(%r12), %rax
cmpq %rax, 0x30(%r12)
je 0x25ce
movq 0x20(%rax), %rcx
movq %rcx, -0x30(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq %r12, %rdi
callq 0x5626
movq %r15, %rdi
callq 0x20c0
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rsp)
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq *0x10(%rax)
movl %eax, %r13d
xorb $0x1, %r13b
jmp 0x25d9
movq %r15, %rdi
callq 0x20c0
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2180
movq 0x30(%r12), %rax
cmpq 0x10(%r12), %rax
je 0x25f5
movq %r14, %rdi
callq 0x20c0
movq %r15, %rdi
callq 0x20c0
testb %r13b, %r13b
je 0x255f
callq 0x587c
xorl %edi, %edi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/Mirrvin[P]DragonsResurrectingInc/main.cpp
// Function: rootLoop(int)
void rootLoop(int size){
    printf("Heads: 3, 6, 9...\nBodies: 1, 4, 7...\nTails: 2, 5, 8...\nSKELETON_NUMBER %d\nDESK_NUMBER %d\nORDER_NUMBER %d\n",SKELETON_NUMBER,DESK_NUMBER,ORDER_NUMBER);
    pthread_t issuerMonitorThread;
    pthread_create( &issuerMonitorThread, NULL, &issuerMonitor,NULL);

    packet_t packet;
    packet.data = 0;
    int orderId = 1;
    sleep(12);

    // while(orderId <= ORDER_NUMBER) { 
    while(true) { 
        pthread_mutex_lock(&Monitor::newOrderMutex);

        pthread_mutex_lock(&Monitor::skeletonsMutex);
        Monitor::currentSkeletons-=1;
        pthread_mutex_unlock(&Monitor::skeletonsMutex);
        
        if(Monitor::currentSkeletons > 0)
            pthread_mutex_unlock(&Monitor::newOrderMutex);
        
        // sleep(2);
        packet.lamport = Monitor::getLamport();
        printf("%u: New order no. %d!\n",Monitor::getLamport() ,orderId);
        for(int i = 1;i < size; i++){ // broadcast NEW_ORDER
            if(i%3 + 1 == TAIL) {
                sendMessage(NEW_ORDER,i);
            }
        }
        orderId++;
    }

    // sleep(3);
    // for(int i = 1;i < size; i++){ // broadcast END
    //     MPI_Send(&packet, sizeof(packet_t), MPI_BYTE, i, END, MPI_COMM_WORLD);
    // }
    // sendMessage(END, ISSUER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
leaq 0x4ade(%rip), %rdi      # 0x710a
movl $0x1, %r14d
movl $0x2, %esi
movl $0x1, %edx
movl $0x5, %ecx
xorl %eax, %eax
callq 0x2030
leaq -0x180(%rip), %rdx      # 0x24cf
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x21f0
movl $0xc, %edi
callq 0x20b0
leaq 0x7b73(%rip), %r15      # 0xa1e0
movl $0xaaaaaaab, %r13d      # imm = 0xAAAAAAAB
movq %r15, %rdi
callq 0x2180
leaq 0x7b36(%rip), %r12      # 0xa1b8
movq %r12, %rdi
callq 0x2180
leaq 0x7a87(%rip), %rax      # 0xa118
decl (%rax)
movq %r12, %rdi
callq 0x20c0
leaq 0x7a76(%rip), %rax      # 0xa118
cmpl $0x0, (%rax)
jle 0x26af
movq %r15, %rdi
callq 0x20c0
callq 0x58c2
callq 0x58c2
leaq 0x4ab4(%rip), %rdi      # 0x7174
movl %eax, %esi
movl %r14d, -0x2c(%rbp)
movl %r14d, %edx
xorl %eax, %eax
callq 0x2030
cmpl $0x2, %ebx
movq 0x78e6(%rip), %r12      # 0x9fc0
jl 0x272b
movl $0x1, %r14d
movl %r14d, %eax
imulq %r13, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
movl %r14d, %ecx
subl %eax, %ecx
cmpl $0x2, %ecx
jne 0x2723
callq 0x588a
movl %eax, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x28, %esi
movq %r12, %rdx
movl %r14d, %ecx
movl $0x64, %r8d
movq 0x78b2(%rip), %r9       # 0x9fd0
callq 0x2070
incl %r14d
cmpl %r14d, %ebx
jne 0x26e2
movl -0x2c(%rbp), %r14d
incl %r14d
jmp 0x2673
// File: /workspace/github_cpp_makefile_star2_O3/Mirrvin[P]DragonsResurrectingInc/main.cpp
// Function: headLoop()
void headLoop(){
    Specialist *specialist = new HeadSpecialist(Monitor::rank, Monitor::size);
    pthread_t handleThread;
    pthread_create( &handleThread, NULL, &handleLoop, specialist);
    Monitor::listen();
    pthread_join(handleThread,NULL);
    delete specialist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x20, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x79d6(%rip), %rax      # 0xa12c
movl (%rax), %esi
leaq 0x79d1(%rip), %rax      # 0xa130
movl (%rax), %edx
movq %rbx, %rdi
callq 0x29cc
leaq -0x23a(%rip), %rdx      # 0x2536
leaq -0x18(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x21f0
callq 0x57a0
movq (%r14), %rdi
xorl %esi, %esi
callq 0x2110
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/Mirrvin[P]DragonsResurrectingInc/main.cpp
// Function: bodyLoop()
void bodyLoop(){
    Specialist *specialist = new BodySpecialist(Monitor::rank, Monitor::size);
    pthread_t handleThread;
    pthread_create( &handleThread, NULL, &handleLoop, specialist);
    Monitor::listen();
    pthread_join(handleThread,NULL);
    delete specialist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x70, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x7953(%rip), %rax      # 0xa12c
movl (%rax), %esi
leaq 0x794e(%rip), %rax      # 0xa130
movl (%rax), %edx
movq %rbx, %rdi
callq 0x5d30
leaq 0x74f5(%rip), %rax      # 0x9ce8
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq %rax, 0x1e(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x68(%rbx)
leaq -0x2e8(%rip), %rdx      # 0x2536
leaq -0x18(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x21f0
callq 0x57a0
movq (%r14), %rdi
xorl %esi, %esi
callq 0x2110
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x70, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/Mirrvin[P]DragonsResurrectingInc/main.cpp
// Function: tailLoop()
void tailLoop(){   
    Specialist *specialist = new TailSpecialist(Monitor::rank,Monitor::size);
    pthread_t handleThread;
    pthread_create(&handleThread, NULL, &handleLoop, specialist);
    Monitor::listen();
    pthread_join(handleThread,NULL);
    delete specialist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x78, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x78a5(%rip), %rax      # 0xa12c
movl (%rax), %esi
leaq 0x78a0(%rip), %rax      # 0xa130
movl (%rax), %edx
movq %rbx, %rdi
callq 0x5d30
leaq 0x7487(%rip), %rax      # 0x9d28
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movw $0x0, 0x28(%rbx)
movl $0x0, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rax, 0x70(%rbx)
leaq -0x39f(%rip), %rdx      # 0x2536
leaq -0x18(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x21f0
callq 0x57a0
movq (%r14), %rdi
xorl %esi, %esi
callq 0x2110
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x78, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/Mirrvin[P]DragonsResurrectingInc/main.cpp
// Function: main
int main(int argc, char **argv)
{
    int provided;
    MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
    if(check_thread_support(provided)) {
        Monitor::initialize();

        int type = Monitor::rank%3 + 1;
        if (Monitor::rank == ISSUER){
            rootLoop(Monitor::size);
        } else if (type == HEAD) {
            headLoop();
        } else if (type == BODY) {
            bodyLoop();
        } else if (type == TAIL) {
            tailLoop();
        }
    } else {
        printf("Multiple threads are not supported by open mpi. Exiting application");
    }
    MPI_Finalize();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x10(%rbp), %rax
movl %edi, (%rax)
leaq -0x18(%rbp), %rcx
movq %rsi, (%rcx)
leaq -0xc(%rbp), %rbx
movq %rax, %rdi
movq %rcx, %rsi
movl $0x3, %edx
movq %rbx, %rcx
callq 0x2040
cmpl $0x3, (%rbx)
jl 0x2994
callq 0x56ba
leaq 0x77cf(%rip), %rax      # 0xa12c
movl (%rax), %eax
testl %eax, %eax
je 0x29be
movslq %eax, %rcx
imulq $0x55555556, %rcx, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
cmpl $0x2, %eax
je 0x29b7
cmpl $0x1, %eax
je 0x29b0
testl %eax, %eax
jne 0x29a2
callq 0x2737
jmp 0x29a2
leaq 0x47f0(%rip), %rdi      # 0x718b
xorl %eax, %eax
callq 0x2030
callq 0x20d0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
callq 0x27ba
jmp 0x29a2
callq 0x2868
jmp 0x29a2
leaq 0x776b(%rip), %rax      # 0xa130
movl (%rax), %edi
callq 0x2612