LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Figures.cpp
// Function: Figures::FP_Line()
void FP_Line()
{
	std::ofstream data[2];
	data[0].open("data/FP_Line_NO.txt");
	data[1].open("data/FP_Line_IO.txt");

	int alpha = 1;
	int beta = 0;
	double Yrho = 1.4;
	Yrho /= 2;
	bool max = true;
	double m, b;

	for (int i = 0; i < 2; i++)
	{
		set_ordering(i == 0);
		for (double delta = 0; delta <= 2 * M_PI; delta += 2 * M_PI / 40)
		{
			FP_line(alpha, beta, Yrho, delta, max, &m, &b);
			data[i] << delta << " " << m << " " << b << std::endl;
		} // delta
		data[i].close();
	} // i, ordering

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
leaq 0x20(%rsp), %rdi
callq 0x2280
leaq 0x220(%rsp), %rdi
callq 0x2280
leaq 0x18c2(%rip), %rsi      # 0x10039
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x2050
leaq 0x18bd(%rip), %rsi      # 0x1004d
leaq 0x220(%rsp), %rdi
movl $0x10, %edx
callq 0x2050
movb $0x1, %bl
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x14a9(%rip), %r13      # 0xfc5e
movzbl %bl, %edi
andl $0x1, %edi
callq 0x3a1f
xorpd %xmm1, %xmm1
movl $0x1, %edi
xorl %esi, %esi
movsd 0x16ed(%rip), %xmm0     # 0xfec0
movsd %xmm1, 0x8(%rsp)
movl $0x1, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x592a
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2260
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21c0
movsd 0x18(%rsp), %xmm0
movq %rbp, %rdi
callq 0x2260
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21c0
movsd 0x10(%rsp), %xmm0
movq %rbp, %rdi
callq 0x2260
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movsd 0x8(%rsp), %xmm1
addsd 0x1657(%rip), %xmm1     # 0xfec8
movsd 0x1657(%rip), %xmm0     # 0xfed0
ucomisd %xmm1, %xmm0
jae 0xe7c4
movq %r14, %rdi
callq 0x2210
leaq 0x220(%rsp), %r14
testb $0x1, %bl
movl $0x0, %ebx
jne 0xe7b5
movq 0x5720(%rip), %rax      # 0x13fc8
movq (%rax), %r14
movq 0x18(%rax), %r15
movq $-0x400, %r12           # imm = 0xFC00
leaq 0x318(%rsp), %rbx
movq %r14, -0xf8(%rbx)
movq -0x18(%r14), %rax
movq %r15, -0xf8(%rbx,%rax)
leaq -0xf0(%rbx), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x20a0
addq $-0x200, %rbx           # imm = 0xFE00
addq $0x200, %r12            # imm = 0x200
jne 0xe8be
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2220
jmp 0xe971
jmp 0xe91a
jmp 0xe91a
movq %rax, %rbx
movq 0x56a4(%rip), %rax      # 0x13fc8
movq (%rax), %r15
movq 0x18(%rax), %r12
movq $-0x400, %r13           # imm = 0xFC00
leaq 0x318(%rsp), %r14
movq %r15, -0xf8(%r14)
movq -0x18(%r15), %rax
movq %r12, -0xf8(%r14,%rax)
leaq -0xf0(%r14), %rdi
callq 0x2150
movq %r14, %rdi
callq 0x20a0
addq $-0x200, %r14           # imm = 0xFE00
addq $0x200, %r13            # imm = 0x200
jne 0xe93a
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/test/src/voidPointer.cpp
// Function: main
int main()
{
	Dummy d1(1, "one");
	
	Dummy* d2 = new Dummy(2, "two");
	delete d2;

	dummyFunc((void*) new Dummy(3, "THREE"));

	cout << "\n\033[0;34mVoid Pointer Test: ";

	bool pass = true;

	if (pass)
	{
		cout << "\033[0;32mOK\033[0m" << endl;
	}
	else
	{
		cout << "\033[0;31mFAIL\033[0m" << endl;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0xdaa(%rip), %rdx       # 0x200a
movq %rsp, %rdi
movl $0x1, %esi
callq 0x139e
movl $0x28, %edi
callq 0x1080
movq %rax, %r14
leaq 0xd8d(%rip), %rdx       # 0x200e
movq %rax, %rdi
movl $0x2, %esi
callq 0x139e
movq 0x8(%r14), %rdi
movq %r14, %rax
addq $0x18, %rax
cmpq %rax, %rdi
je 0x12a9
movq (%rax), %rsi
incq %rsi
callq 0x1090
movl $0x28, %esi
movq %r14, %rdi
callq 0x1090
movl $0x28, %edi
callq 0x1080
movq %rax, %r14
leaq 0xd48(%rip), %rdx       # 0x2012
movq %rax, %rdi
movl $0x3, %esi
callq 0x139e
movq %r14, %rdi
callq 0x120c
movq 0x2cf2(%rip), %rdi      # 0x3fd8
leaq 0xd2b(%rip), %rsi       # 0x2018
movl $0x1b, %edx
callq 0x10a0
movq 0x2cda(%rip), %rbx      # 0x3fd8
leaq 0xd2f(%rip), %rsi       # 0x2034
movl $0xd, %edx
movq %rbx, %rdi
callq 0x10a0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq 0x2ca8(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1050
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1358
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1090
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x1364
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x1090
jmp 0x137b
jmp 0x1378
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1396
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/protocol/redisprotocol.cc
// Function: net::protocol::RedisProtocol::operator()(StringRef const&)
auto RedisProtocol::operator()(const StringRef &src) -> Status{
	// this doing more harm than relps.
//	if (src.size() < 8)	// 4 bytes - "*1\r\n$1\r\n"
//		return Status::BUFFER_NOT_READ;

	size_t pos = 0;

	if (src[pos] != STAR)
		return err_(Error::NO_STAR);

	++pos;

	if (pos + 1 > src.size())
		// at least one character for parameter count
		return Status::BUFFER_NOT_READ;

	size_t const paramsCount = (size_t) readInt_(src, pos);

	params_.clear();

	if (paramsCount == 0 || paramsCount > MAX_PARAMS)
		return err_(Error::PARAM_COUNT);

	{
		Status stat = readLn_(src, pos);
		if ( stat != Status::OK )
			return stat;
	}

	for(size_t i = 0; i < paramsCount; ++i)
		if ( const auto p = readParam_(src, pos) )
			params_.push_back( p.get() );
		else
			return p.code();

	return Status::OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rsi), %r12
cmpb $0x2a, (%r12)
jne 0x16c4
movq %rsi, %rbx
movq $0x1, -0x30(%rbp)
movq (%rsi), %r13
movl $0x1, %r15d
cmpq $0x2, %r13
jb 0x16ca
movq %rdi, %r14
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1758
movq (%r14), %rcx
cmpq %rcx, 0x8(%r14)
je 0x16bc
movq %rcx, 0x8(%r14)
leal -0x5(%rax), %ecx
cmpl $-0x4, %ecx
jae 0x16dc
movl $0x2, %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rcx
leaq 0x1(%rcx), %rdx
cmpq %r13, %rdx
ja 0x16ca
cmpb $0xd, (%r12,%rcx)
jne 0x16c4
cmpb $0xa, (%r12,%rdx)
movl $0x2, %r15d
jne 0x16ca
movslq %eax, %r13
addq $0x2, %rcx
leaq -0x30(%rbp), %r12
movq %rcx, (%r12)
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1802
movl -0x48(%rbp), %r15d
testl %r15d, %r15d
jne 0x16ca
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x173f
leaq -0x40(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%r14)
jmp 0x174b
movq %r14, %rdi
leaq -0x40(%rbp), %rdx
callq 0x18fc
xorl %r15d, %r15d
decq %r13
jne 0x170c
jmp 0x16ca
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Living::dec_hp(int)
void Living::dec_hp(int dmg){
    HealthPower -= dmg;
    cout << name << " was hit for " << dmg << " points of damage." << endl;
    if(HealthPower <= 0){
        cout << name << " just fainted. :(" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
subl %esi, 0x2c(%rdi)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq 0xf6ce(%rip), %rdi      # 0x13fd0
callq 0x31c0
movq %rax, %r15
leaq 0x995f(%rip), %rsi      # 0xe270
movl $0xd, %edx
movq %rax, %rdi
callq 0x31c0
movq %r15, %rdi
movl %r14d, %esi
callq 0x3210
movq %rax, %r14
leaq 0x994b(%rip), %rsi      # 0xe27e
movl $0x12, %edx
movq %rax, %rdi
callq 0x31c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
cmpl $0x0, 0x2c(%rbx)
jle 0x4978
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0xf649(%rip), %rdi      # 0x13fd0
callq 0x31c0
movq %rax, %rbx
leaq 0x98fb(%rip), %rsi      # 0xe291
movl $0x11, %edx
movq %rax, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::buy_Weapon(Weapon*)
void Hero::buy_Weapon(Weapon * w){
    if(Money < w->get_price()){
        cout << "Not enough money!" << endl;
        return;
    }

    Money -= w->get_price();
    Weapons.push_front(w);
    cout << "You succesfully bought a new WEAPON: " << w->get_name() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x48(%rdi), %r15d
movq %rsi, %rdi
callq 0xc840
cmpl %eax, %r15d
jge 0x4c06
movq 0xf40f(%rip), %rbx      # 0x13fd0
leaq 0x96db(%rip), %rsi      # 0xe2a3
movl $0x11, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3100
movq %rbx, %rdi
callq 0xc840
subl %eax, 0x48(%r14)
movq 0x68(%r14), %r15
movl $0x18, %edi
callq 0x3180
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0x78(%r14)
movq 0xf396(%rip), %r14      # 0x13fd0
leaq 0x9674(%rip), %rsi      # 0xe2b5
movl $0x25, %edx
movq %r14, %rdi
callq 0x31c0
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc812
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x31c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4caf
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cd6
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::buy_Armor(Armor*)
void Hero::buy_Armor(Armor * a){
    if(Money < a->get_price()){
        cout << "Not enough money!" << endl;
        return;
    }

    Money -= a->get_price();
    Armors.push_front(a);
    cout << "You succesfully bought a new ARMOR: " << a->get_name() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x48(%rdi), %r15d
movq %rsi, %rdi
callq 0xc840
cmpl %eax, %r15d
jge 0x4d4e
movq 0xf2c7(%rip), %rbx      # 0x13fd0
leaq 0x9593(%rip), %rsi      # 0xe2a3
movl $0x11, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3100
movq %rbx, %rdi
callq 0xc840
subl %eax, 0x48(%r14)
movq 0x98(%r14), %r15
movl $0x18, %edi
callq 0x3180
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0xa8(%r14)
movq 0xf248(%rip), %r14      # 0x13fd0
leaq 0x954c(%rip), %rsi      # 0xe2db
movl $0x24, %edx
movq %r14, %rdi
callq 0x31c0
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc812
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x31c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4dfd
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e24
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::buy_Potion(Potion*)
void Hero::buy_Potion(Potion * p){
    if(Money < p->get_price()){
        cout << "Not enough money!" << endl;
        return;
    }

    Money -= p->get_price();
    Potions.push_front(p);
    cout << "You succesfully bought a new POTION: " << p->get_name() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x48(%rdi), %r15d
movq %rsi, %rdi
callq 0xc840
cmpl %eax, %r15d
jge 0x4e9c
movq 0xf179(%rip), %rbx      # 0x13fd0
leaq 0x9445(%rip), %rsi      # 0xe2a3
movl $0x11, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3100
movq %rbx, %rdi
callq 0xc840
subl %eax, 0x48(%r14)
movq 0xb0(%r14), %r15
movl $0x18, %edi
callq 0x3180
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0xc0(%r14)
movq 0xf0fa(%rip), %r14      # 0x13fd0
leaq 0x9423(%rip), %rsi      # 0xe300
movl $0x25, %edx
movq %r14, %rdi
callq 0x31c0
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc812
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x31c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f4b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f72
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::buy_Spell(Spell*)
void Hero::buy_Spell(Spell * s){
    if(Money < s->get_price()){
        cout << "Not enough money!" << endl;
        return;
    }

    Money -= s->get_price();
    Spells.push_front(s);
    cout << "You succesfully bought a new SPELL: " << s->get_name() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x48(%rdi), %r15d
movq %rsi, %rdi
callq 0xc840
cmpl %eax, %r15d
jge 0x4fea
movq 0xf02b(%rip), %rbx      # 0x13fd0
leaq 0x92f7(%rip), %rsi      # 0xe2a3
movl $0x11, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3100
movq %rbx, %rdi
callq 0xc840
subl %eax, 0x48(%r14)
movq 0x80(%r14), %r15
movl $0x18, %edi
callq 0x3180
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0x90(%r14)
movq 0xefac(%rip), %r14      # 0x13fd0
leaq 0x92fb(%rip), %rsi      # 0xe326
movl $0x24, %edx
movq %r14, %rdi
callq 0x31c0
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc812
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x31c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5099
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50c0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::display_Weapons()
void Hero::display_Weapons(){
    list<Weapon*>::iterator it;

    for(it = Weapons.begin(); it != Weapons.end(); ++it){
        cout << (*it)->get_name() << endl;
        cout << "Damage: " << (*it)->get_damage() << endl;
        cout << "Hands needed: " << (*it)->get_handsNeeded() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r12
addq $0x68, %rbx
cmpq %rbx, %r12
je 0x5d5c
movq 0xe38a(%rip), %r15      # 0x13fd0
leaq 0x8796(%rip), %r13      # 0xe3e3
movq 0x10(%r12), %rsi
leaq -0x48(%rbp), %rdi
callq 0xc812
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x31c0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5cae
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movl $0x8, %edx
movq %r15, %rdi
leaq 0x84c1(%rip), %rsi      # 0xe17e
callq 0x31c0
movq 0x10(%r12), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movl $0xe, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x31c0
movq 0x10(%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %r15, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x5c4d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5d87
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::display_Armors()
void Hero::display_Armors(){
    list<Armor*>::iterator it;

    for(it = Armors.begin(); it != Armors.end(); ++it){
        cout << (*it)->get_name() << endl;
        cout << "Defense: " << (*it)->get_protection() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x98(%rdi), %r14
addq $0x98, %rbx
cmpq %rbx, %r14
je 0x5e83
movq 0xe20e(%rip), %r15      # 0x13fd0
leaq 0x8602(%rip), %r12      # 0xe3cb
movq 0x10(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0xc812
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x31c0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5e29
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movl $0x9, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %r15, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x5dc9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5eae
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::display_Potions()
void Hero::display_Potions(){
    list<Potion*>::iterator it;

    if(Potions.empty()){
        cout << "You don't have any Potions" << endl;
        return;
    }

    for(it = Potions.begin(); it != Potions.end(); ++it){
        cout << (*it)->get_name() << endl;
        cout << "Stat: " << (*it)->get_statname();
        cout << "% " << (*it)->get_buff() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0xb0(%rdi), %r13
addq $0xb0, %rbx
cmpq %rbx, %r13
je 0x6002
leaq -0x48(%rbp), %r14
movq 0xe0e4(%rip), %r15      # 0x13fd0
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0xc812
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x31c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5f4b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movl $0x6, %edx
movq %r15, %rdi
leaq 0x84b3(%rip), %rsi      # 0xe40d
callq 0x31c0
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0xce28
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x31c0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5f94
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movl $0x2, %edx
movq %r15, %rdi
leaq 0x8471(%rip), %rsi      # 0xe414
callq 0x31c0
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r15, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq (%r13), %r13
cmpq %rbx, %r13
jne 0x5eec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdfc7(%rip), %rbx      # 0x13fd0
leaq 0x83e2(%rip), %rsi      # 0xe3f2
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
jmp 0x6054
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6070
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::equip_weapon(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Hero::equip_weapon(string weapon_name){

    int flag = 0;
    list<Weapon*> :: iterator wp;
    cout << GetWeaponsListSize() << endl;
    for(wp = Weapons.begin(); wp != Weapons.end(); ++wp){

        if( (*wp)->get_name() == weapon_name){
            flag = 1;
            break;
        }
    }

    if(flag == 1){
        Strength += (*wp)->get_damage();
        Weapon_Equiped = (*wp);
    }else{
        cout << "You dont have that weapon in your inventory" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl 0x78(%rdi), %esi
movq 0xdf07(%rip), %rdi      # 0x13fd0
callq 0x3210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq %rbx, -0x30(%rbp)
leaq 0x68(%rbx), %r14
movq %r14, %rbx
movq (%rbx), %rbx
cmpq %r14, %rbx
je 0x6182
movq 0x10(%rbx), %rsi
leaq -0x50(%rbp), %rdi
callq 0xc812
movq -0x48(%rbp), %rdx
cmpq 0x8(%r15), %rdx
jne 0x613e
movq -0x50(%rbp), %r13
testq %rdx, %rdx
je 0x6147
movq (%r15), %rsi
movq %r13, %rdi
callq 0x31a0
testl %eax, %eax
sete %r12b
jmp 0x614a
movq -0x50(%rbp), %r13
xorl %r12d, %r12d
jmp 0x614a
movb $0x1, %r12b
leaq -0x40(%rbp), %rax
cmpq %rax, %r13
je 0x6162
movq -0x40(%rbp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x3190
testb %r12b, %r12b
je 0x6103
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x30(%rbp), %rcx
addl %eax, 0x38(%rcx)
movq 0x10(%rbx), %rax
movq %rax, 0x58(%rcx)
jmp 0x61c4
leaq 0x828e(%rip), %rsi      # 0xe417
movl $0x2b, %edx
movq 0xde3b(%rip), %rbx      # 0x13fd0
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::equip_armor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Hero::equip_armor(string armor_name){

    int flag = 0;
    list<Armor*> :: iterator ar;
    for(ar = Armors.begin(); ar != Armors.end(); ++ar){

        if( (*ar)->get_name() == armor_name){
            flag =1;
            break;
        }
    }

    if(flag == 1){
        Defense += (*ar)->get_protection();
        Armor_Equiped = (*ar);
    }else{

        cout << "You dont have that armor in your inventory" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq 0x98(%rdi), %rbx
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x6280
movq 0x10(%r13), %rsi
leaq -0x50(%rbp), %rdi
callq 0xc812
movq -0x48(%rbp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x623c
movq -0x50(%rbp), %r12
testq %rdx, %rdx
je 0x6245
movq (%r14), %rsi
movq %r12, %rdi
callq 0x31a0
testl %eax, %eax
sete %r15b
jmp 0x6248
movq -0x50(%rbp), %r12
xorl %r15d, %r15d
jmp 0x6248
movb $0x1, %r15b
leaq -0x40(%rbp), %rax
cmpq %rax, %r12
je 0x6260
movq -0x40(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x3190
testb %r15b, %r15b
je 0x6200
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x30(%rbp), %rcx
addl %eax, 0x44(%rcx)
movq 0x10(%r13), %rax
movq %rax, 0x60(%rcx)
jmp 0x62c2
movq 0xdd49(%rip), %rbx      # 0x13fd0
leaq 0x81b5(%rip), %rsi      # 0xe443
movl $0x2a, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::castSpell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Spell * Hero::castSpell(string spell_name){
    int flag = 0;
    list<Spell*> :: iterator is;

    for(is = Spells.begin(); is!= Spells.end(); ++is){
          
        if((*is)->get_name() == spell_name){
            flag = 1;
            break;
        }

    }


    if(flag == 1){

         if(MagicPower >= (*is)->get_MagicPower()){

            MagicPower -= (*is)->get_MagicPower();

         }
         return *is;

    }else{

        cout << "You dont have that spell in your inventory" << endl;
    }



}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq 0x80(%rdi), %rbx
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x6392
movq 0x10(%r13), %rsi
leaq -0x50(%rbp), %rdi
callq 0xc812
movq -0x48(%rbp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x6334
movq -0x50(%rbp), %r12
testq %rdx, %rdx
je 0x633d
movq (%r14), %rsi
movq %r12, %rdi
callq 0x31a0
testl %eax, %eax
sete %r15b
jmp 0x6340
movq -0x50(%rbp), %r12
xorl %r15d, %r15d
jmp 0x6340
movb $0x1, %r15b
leaq -0x40(%rbp), %rax
cmpq %rax, %r12
je 0x6358
movq -0x40(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x3190
testb %r15b, %r15b
je 0x62f4
movq -0x30(%rbp), %r14
movl 0x34(%r14), %ebx
movq 0x10(%r13), %rdi
callq 0xc4ea
cmpl %eax, %ebx
jl 0x637f
movq 0x10(%r13), %rdi
callq 0xc4ea
subl %eax, 0x34(%r14)
movq 0x10(%r13), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::round_won()
void Hero::round_won(){
    Money += Level*25;
    exp += Level*20;
    if(exp >= NextLvlExp){
        Level++;
        exp = 0;
        set_NextLvlExp();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x28(%rdi), %eax
leal (%rax,%rax,4), %ecx
leal (%rcx,%rcx,4), %edx
addl %edx, 0x48(%rdi)
shll $0x2, %ecx
addl 0x4c(%rdi), %ecx
movl %ecx, 0x4c(%rdi)
cmpl 0x50(%rdi), %ecx
jl 0x67a6
incl %eax
movl %eax, 0x28(%rdi)
movl $0x0, 0x4c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Warrior::level_up()
void Warrior::level_up(){
    Strength += Strength*0.3;
    Agility += Agility*0.3;
    Dexterity += Dexterity*0.2;
    Level++;
    set_NextLvlExp();

    cout << "The WARRIOR " << name << " just LEVELED UP. New LEVEL: " << Level << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cvtsi2sdl 0x38(%rdi), %xmm0
movsd 0x7963(%rip), %xmm1     # 0xe260
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x38(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x3c(%rdi), %xmm0
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x3c(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x40(%rdi), %xmm0
movsd 0x7931(%rip), %xmm1     # 0xe268
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x40(%rdi)
incl 0x28(%rdi)
movq 0xd680(%rip), %r14      # 0x13fd0
leaq 0x7be1(%rip), %rsi      # 0xe538
movl $0xc, %edx
movq %r14, %rdi
callq 0x31c0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31c0
movq %rax, %r14
leaq 0x7bc7(%rip), %rsi      # 0xe545
movl $0x1d, %edx
movq %rax, %rdi
callq 0x31c0
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x3210
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Sorcerer::level_up()
void Sorcerer::level_up(){
    Strength += Strength*0.2;
    Agility += Agility*0.3;
    Dexterity += Dexterity*0.3;
    Level++;
    set_NextLvlExp();

    cout << "The SORCERER " << name << " just LEVELED UP. New LEVEL: " << Level << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cvtsi2sdl 0x38(%rdi), %xmm0
movsd 0x774f(%rip), %xmm1     # 0xe268
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x38(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x3c(%rdi), %xmm0
movsd 0x7728(%rip), %xmm1     # 0xe260
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x3c(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x40(%rdi), %xmm0
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x40(%rdi)
incl 0x28(%rdi)
movq 0xd464(%rip), %r14      # 0x13fd0
leaq 0x7a15(%rip), %rsi      # 0xe588
movl $0xd, %edx
movq %r14, %rdi
callq 0x31c0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31c0
movq %rax, %r14
leaq 0x79ab(%rip), %rsi      # 0xe545
movl $0x1d, %edx
movq %rax, %rdi
callq 0x31c0
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x3210
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Paladin::level_up()
void Paladin::level_up(){
    Strength += Strength*0.3;
    Agility += Agility*0.2;
    Dexterity += Dexterity*0.3;
    Level++;
    set_NextLvlExp();

    cout << "The PALADIN " << name << " just LEVELED UP. New LEVEL: " << Level << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cvtsi2sdl 0x38(%rdi), %xmm0
movsd 0x752b(%rip), %xmm1     # 0xe260
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x38(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x3c(%rdi), %xmm0
movsd 0x7510(%rip), %xmm2     # 0xe268
mulsd %xmm0, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x3c(%rdi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x40(%rdi), %xmm0
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x40(%rdi)
incl 0x28(%rdi)
movq 0xd248(%rip), %r14      # 0x13fd0
leaq 0x782a(%rip), %rsi      # 0xe5b9
movl $0xc, %edx
movq %r14, %rdi
callq 0x31c0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31c0
movq %rax, %r14
leaq 0x778f(%rip), %rsi      # 0xe545
movl $0x1d, %edx
movq %rax, %rdi
callq 0x31c0
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x3210
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Monsters.cpp
// Function: Monster::get_attacked(Spell*)
void Monster::get_attacked(Spell* sp){
    string spell;
    spell = sp->get_class();

    int red;
    red = sp->get_Reduction();

    if(spell == "IceSpell"){
        red = Damage*red/100;
        decrease_damage(red);
    }else if(spell == "FireSpell"){
        red = Defence*red/100;
        decreade_def(red);
    }else{
        red = Agility*red/100;
        decrease_Agility(red);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq (%rsi), %rax
leaq -0x60(%rbp), %rdi
callq *0x30(%rax)
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %r15
movq %r15, %rsi
callq 0x31d0
movq (%r15), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x7388
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3190
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movl %eax, %r14d
leaq 0x7255(%rip), %rsi      # 0xe5f0
leaq -0x40(%rbp), %rdi
callq 0x30a0
testl %eax, %eax
je 0x73e1
leaq 0x724a(%rip), %rsi      # 0xe5f9
leaq -0x40(%rbp), %rdi
callq 0x30a0
testl %eax, %eax
je 0x7406
movl 0x3c(%rbx), %eax
imull %eax, %r14d
movslq %r14d, %rcx
imulq $-0x51eb851f, %rcx, %rcx # imm = 0xAE147AE1
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
addl %eax, %ecx
movl %ecx, 0x3c(%rbx)
jmp 0x7429
movl 0x34(%rbx), %eax
imull %eax, %r14d
movslq %r14d, %rcx
imulq $-0x51eb851f, %rcx, %rcx # imm = 0xAE147AE1
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
addl %eax, %ecx
movl %ecx, 0x34(%rbx)
jmp 0x7429
movl 0x38(%rbx), %eax
imull %eax, %r14d
movslq %r14d, %rcx
imulq $-0x51eb851f, %rcx, %rcx # imm = 0xAE147AE1
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
addl %eax, %ecx
movl %ecx, 0x38(%rbx)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x743e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3190
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x744d
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x7465
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Monsters.cpp
// Function: Monster::get_attacked(int)
void Monster::get_attacked(int dmg){
    int p = rand()%100;

    if(p <= Agility){
        cout << name << " dodged the attack!" << endl;
    }else{
        HealthPower -= dmg + Defence;
        cout << name << " was hit for " << dmg << " points of damage" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x3080
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
cmpl 0x3c(%r14), %eax
jle 0x75e8
movl 0x38(%r14), %eax
addl %ebx, %eax
subl %eax, 0x2c(%r14)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq 0xca1f(%rip), %rdi      # 0x13fd0
callq 0x31c0
movq %rax, %r14
leaq 0x6cb0(%rip), %rsi      # 0xe270
movl $0xd, %edx
movq %rax, %rdi
callq 0x31c0
movq %r14, %rdi
movl %ebx, %esi
callq 0x3210
movq %rax, %rbx
leaq 0x7036(%rip), %rsi      # 0xe617
movl $0x11, %edx
jmp 0x760b
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq 0xc9d9(%rip), %rdi      # 0x13fd0
callq 0x31c0
movq %rax, %rbx
leaq 0x6ffd(%rip), %rsi      # 0xe603
movl $0x13, %edx
movq %rax, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Market.cpp
// Function: Market::~Market()
Market::~Market() {

	Weapons.clear();
	Armors.clear();
	Potions.clear();
	Spells.clear();
	ItemsToSell.clear();	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9b22
leaq 0x18(%rbx), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9b5e
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x9b9a
leaq 0x48(%rbx), %r12
movq %r12, %rdi
callq 0x9bd6
leaq 0x60(%rbx), %r13
movq %r13, %rdi
callq 0x9c12
movq 0x60(%rbx), %rdi
cmpq %r13, %rdi
je 0x7931
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %r13, %r14
jne 0x791c
movq (%r12), %rdi
cmpq %r12, %rdi
je 0x794f
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %r12, %r14
jne 0x793a
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x796c
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %r15, %r14
jne 0x7957
movq -0x30(%rbp), %r15
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x798d
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %r15, %r14
jne 0x7978
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x79aa
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x7995
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Market.cpp
// Function: Market::EnterMarket()
void Market::EnterMarket(){

	cout << "Welcome to the Market" << endl << "Press 1 to buy,2 to sell and any button to leave" << endl;
	string flag;
	cin >> flag;
	if(flag == "1"){
		buy();
	}else if(flag == "2"){
		sell();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0xba89(%rip), %r14      # 0x13fd0
leaq 0x6128(%rip), %rsi      # 0xe676
movl $0x15, %edx
movq %r14, %rdi
callq 0x31c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq %rax, %r14
leaq 0x6100(%rip), %rsi      # 0xe68c
movl $0x30, %edx
movq %rax, %rdi
callq 0x31c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0xba05(%rip), %rdi      # 0x13fe0
leaq -0x30(%rbp), %rsi
callq 0x31e0
leaq 0x60d2(%rip), %rsi      # 0xe6bd
leaq -0x30(%rbp), %rdi
callq 0x30a0
testl %eax, %eax
je 0x8616
leaq 0x60c0(%rip), %rsi      # 0xe6bf
leaq -0x30(%rbp), %rdi
callq 0x30a0
testl %eax, %eax
jne 0x861e
movq %rbx, %rdi
callq 0x90e4
jmp 0x861e
movq %rbx, %rdi
callq 0x865c
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x8633
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3190
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x8654
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::Grid(Market*, Squad*)
Grid::Grid(Market* m, Squad* sq){
    market = m;
    team = sq;

    Map = new int*[HEIGHT];                 //creating the map

    for(int i = 0; i < HEIGHT; i++){
        Map[i] = new int [WIDTH];
    }
    srand(time(NULL));

    for(int x = 0; x < HEIGHT; x++){
        for(int y = 0; y < WIDTH; y++){
            int p;                          //possibility
            p = rand()%100;

            if(p <= 15 ){
                Map[x][y] = 0;
            }else if(p <= 35){
                Map[x][y] = 2;
            }else{
                Map[x][y] = 1;
            }
        }
    }
    x = 0;
    y= 0;
    Map[0][0] = 1;
    pt = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r15
movq %r15, 0x20(%rdi)
movq %r15, 0x18(%rdi)
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %r12
movq %r12, 0x38(%rdi)
movq %r12, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x48(%rdi), %r13
movq %r13, 0x50(%rdi)
movq %r13, 0x48(%rdi)
movq %rax, 0x58(%rdi)
movq %rsi, 0x68(%rdi)
movq %rdx, 0x70(%rdi)
movl $0x28, %edi
callq 0x3030
movq %rax, 0x60(%rbx)
xorl %r14d, %r14d
movl $0x14, %edi
callq 0x3030
movq 0x60(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x5, %r14
jne 0x9d4f
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x3140
movl %eax, %edi
callq 0x3150
xorl %r15d, %r15d
callq 0x3080
movslq %eax, %rcx
imulq $0x51eb851f, %rcx, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %eax
subl %eax, %ecx
cmpl $0xf, %ecx
jg 0x9db6
movq 0x60(%rbx), %rax
movq (%rax,%r14,8), %rcx
movl $0x0, (%rcx,%r15,4)
jmp 0x9dd5
movq 0x60(%rbx), %rax
movq (%rax,%r14,8), %rdx
cmpl $0x23, %ecx
ja 0x9dcd
movl $0x2, (%rdx,%r15,4)
jmp 0x9dd5
movl $0x1, (%rdx,%r15,4)
incq %r15
cmpq $0x5, %r15
jne 0x9d7e
incq %r14
cmpq $0x5, %r14
jne 0x9d7b
movq $0x0, 0x78(%rbx)
movq (%rax), %rax
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
jmp 0x9e36
movq %rax, -0x30(%rbp)
movq (%r13), %rdi
cmpq %r13, %rdi
je 0x9e36
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %r13, %r14
jne 0x9e21
movq (%r12), %rdi
cmpq %r12, %rdi
je 0x9e54
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %r12, %r14
jne 0x9e3f
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x9e71
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %r15, %r14
jne 0x9e5c
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x9e8e
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x9e79
movq -0x30(%rbp), %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::move_up()
void Grid::move_up(){

    if(y -1 < 0){
        cout << "You can not move upwards" << endl;
    }else{
        if(Map[y-1][x] == 0){
            cout << "This is a non accessible square" << endl;
            return;            
        }
        py = y;
        px = x;
        Map[py][px] = pt;
        y--;
        pt = Map[y][x];
        Map[y][x] = 3;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq 0x7c(%rdi), %rcx
testq %rcx, %rcx
jle 0x9f00
movq 0x60(%rdi), %rax
movq -0x8(%rax,%rcx,8), %rsi
movl 0x78(%rdi), %edx
movslq %edx, %rdx
cmpl $0x0, (%rsi,%rdx,4)
je 0x9f15
movl %ecx, 0x84(%rdi)
movl %edx, 0x80(%rdi)
movl 0x88(%rdi), %esi
movq (%rax,%rcx,8), %rcx
movl %esi, (%rcx,%rdx,4)
movslq 0x7c(%rdi), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x7c(%rdi)
movq -0x8(%rax,%rcx,8), %rax
movslq 0x78(%rdi), %rcx
movl (%rax,%rcx,4), %edx
movl %edx, 0x88(%rdi)
movl $0x3, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xa0c9(%rip), %rbx      # 0x13fd0
leaq 0x4af0(%rip), %rsi      # 0xe9fe
movl $0x18, %edx
jmp 0x9f28
movq 0xa0b4(%rip), %rbx      # 0x13fd0
leaq 0x4af4(%rip), %rsi      # 0xea17
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3100
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::move_down()
void Grid::move_down(){
    cout << y << endl;
    if(y + 1 > HEIGHT-1){
        cout << "You can not move down" << endl;
    }else{
        if(Map[y+1][x] == 0){
            cout << "This is a non accessible square" << endl;
            return;            
        }
        py = y;
        px = x;
        Map[py][px] = pt;
        y++;
        pt = Map[y][x];
        Map[y][x] = 3;
        
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x7c(%rdi), %esi
movq 0xa05b(%rip), %rbx      # 0x13fd0
movq %rbx, %rdi
callq 0x3210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movslq 0x7c(%r14), %rcx
cmpq $0x4, %rcx
jl 0x9fbf
leaq 0x4a7f(%rip), %rsi      # 0xea37
movl $0x15, %edx
jmp 0xa02e
movq 0x60(%r14), %rax
movq 0x8(%rax,%rcx,8), %rsi
movl 0x78(%r14), %edx
movslq %edx, %rdx
cmpl $0x0, (%rsi,%rdx,4)
je 0xa022
movl %ecx, 0x84(%r14)
movl %edx, 0x80(%r14)
movl 0x88(%r14), %esi
movq (%rax,%rcx,8), %rcx
movl %esi, (%rcx,%rdx,4)
movslq 0x7c(%r14), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x7c(%r14)
movq 0x8(%rax,%rcx,8), %rax
movslq 0x78(%r14), %rcx
movl (%rax,%rcx,4), %edx
movl %edx, 0x88(%r14)
movl $0x3, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49ee(%rip), %rsi      # 0xea17
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3100
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::move_left()
void Grid::move_left(){
    if(x - 1 < 0){
        cout << "You can not move to the left" << endl;
    }else{
        if(Map[y][x-1] == 0){
            cout << "This is a non accessible square" << endl;
            return;
        }
        py = y;
        px = x;
        Map[py][px] = pt;
        x--;
        pt = Map[y][x];
        Map[y][x] = 3;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq 0x78(%rdi), %rcx
testq %rcx, %rcx
jle 0xa0cb
movq 0x60(%rdi), %rax
movslq 0x7c(%rdi), %rsi
movq (%rax,%rsi,8), %rdx
cmpl $0x0, -0x4(%rdx,%rcx,4)
je 0xa0e0
movl %esi, 0x84(%rdi)
movl %ecx, 0x80(%rdi)
movl 0x88(%rdi), %esi
movl %esi, (%rdx,%rcx,4)
movslq 0x78(%rdi), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x78(%rdi)
movslq 0x7c(%rdi), %rdx
movq (%rax,%rdx,8), %rax
movl -0x4(%rax,%rcx,4), %edx
movl %edx, 0x88(%rdi)
movl $0x3, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x9efe(%rip), %rbx      # 0x13fd0
leaq 0x4974(%rip), %rsi      # 0xea4d
movl $0x1c, %edx
jmp 0xa0f3
movq 0x9ee9(%rip), %rbx      # 0x13fd0
leaq 0x4929(%rip), %rsi      # 0xea17
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3100