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

	for (int i = 0; i < 2; i++)
	{
		set_ordering(i == 0);
		for (double Y = -40; Y <= 40; Y += 0.05)
		{
			double a = Y * Y_to_a;

			data[i] << Y << " ";
			data[i] << std::abs(c12 * s12 * eps) << " ";
			data[i] << std::abs(epsp(a)) << " ";
			data[i] << std::endl;
		}
		data[i].close();
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
leaq 0x20(%rsp), %rdi
callq 0x2250
leaq 0x220(%rsp), %rbx
movq %rbx, %rdi
callq 0x2250
leaq 0x2bfd(%rip), %rsi      # 0xded6
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x2040
leaq 0x2c09(%rip), %rsi      # 0xdef6
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x2040
leaq 0x2031(%rip), %rax      # 0xd330
leaq 0x1fea(%rip), %rcx      # 0xd2f0
movsd (%rcx), %xmm0
leaq 0x1fc7(%rip), %rcx      # 0xd2d8
mulsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0x28ff(%rip), %rbx      # 0xdc2e
leaq 0x6e4a(%rip), %r12      # 0x12180
cmpq $0x2, %r15
je 0xb412
xorl %edi, %edi
testq %r15, %r15
sete %dil
callq 0x37e3
movq %r15, %rax
shlq $0x9, %rax
leaq (%rsp,%rax), %r14
addq $0x20, %r14
movsd 0x2a9b(%rip), %xmm1     # 0xde00
movsd 0x2a9b(%rip), %xmm0     # 0xde08
ucomisd %xmm1, %xmm0
jb 0xb402
movq %r14, %rdi
movsd %xmm1, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movsd (%r12), %xmm0
mulsd 0x18(%rsp), %xmm0
andpd 0x2118(%rip), %xmm0     # 0xd4c0
movq %r14, %rdi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
callq 0x37ac
andpd 0x20ec(%rip), %xmm0     # 0xd4c0
movq %r14, %rdi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x20d0
movsd 0x8(%rsp), %xmm1
addsd 0x2a23(%rip), %xmm1     # 0xde20
jmp 0xb365
movq %r14, %rdi
callq 0x21f0
incq %r15
jmp 0xb336
movl $0x200, %ebx            # imm = 0x200
movq $-0x200, %r14           # imm = 0xFE00
leaq (%rsp,%rbx), %rdi
addq $0x20, %rdi
callq 0x2200
addq %r14, %rbx
cmpq %r14, %rbx
jne 0xb41e
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2200
jmp 0xb47a
jmp 0xb455
jmp 0xb455
movq %rax, %rbx
movl $0x200, %r14d           # imm = 0x200
movq $-0x200, %r15           # imm = 0xFE00
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x2200
addq %r15, %r14
cmpq %r15, %r14
jne 0xb465
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2250
leaq 0x220(%rsp), %rbx
movq %rbx, %rdi
callq 0x2250
leaq 0x1f53(%rip), %rsi      # 0xdfe1
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x2040
leaq 0x1f53(%rip), %rsi      # 0xdff5
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x2040
xorl %ebp, %ebp
pushq $0x1
popq %rbx
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0x1b6b(%rip), %r12      # 0xdc2e
cmpq $0x2, %rbp
je 0xc186
xorl %edi, %edi
testq %rbp, %rbp
sete %dil
callq 0x37e3
movq %rbp, %rax
shlq $0x9, %rax
leaq (%rsp,%rax), %r13
addq $0x20, %r13
xorpd %xmm1, %xmm1
movsd 0x1d72(%rip), %xmm0     # 0xde68
ucomisd %xmm1, %xmm0
jb 0xc176
movl %ebx, %edi
xorl %esi, %esi
movsd 0x1d68(%rip), %xmm0     # 0xde70
movsd %xmm1, 0x8(%rsp)
movl %ebx, %edx
movq %r14, %rcx
movq %r15, %r8
callq 0x524b
movq %r13, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2230
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
movsd 0x18(%rsp), %xmm0
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
movsd 0x10(%rsp), %xmm0
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20d0
movsd 0x8(%rsp), %xmm1
addsd 0x1d07(%rip), %xmm1     # 0xde78
jmp 0xc0ee
movq %r13, %rdi
callq 0x21f0
incq %rbp
jmp 0xc0c3
movl $0x200, %ebx            # imm = 0x200
movq $-0x200, %r14           # imm = 0xFE00
leaq (%rsp,%rbx), %rdi
addq $0x20, %rdi
callq 0x2200
addq %r14, %rbx
cmpq %r14, %rbx
jne 0xc192
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 0x2200
jmp 0xc1f1
jmp 0xc1cc
jmp 0xc1cc
movq %rax, %rbx
movl $0x200, %r14d           # imm = 0x200
movq $-0x200, %r15           # imm = 0xFE00
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x2200
addq %r15, %r14
cmpq %r15, %r14
jne 0xc1dc
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/coderguang[P]domainCheck/filecn.cpp
// Function: make3list()
void make3list(){

  ofstream file3;
  file3.open("cnlist3.txt");
  file3<<"thisisatestfile3"<<com<<endl;

  for(int i=0;i<MAX;i++){
  file3<<"thiis3test"<<str[i]<<com<<endl;
     for(int j=0;j<MAX;j++)
	for(int k=0;k<MAX;k++){
          file3<<str[i]<<str[j]<<str[k]<<com<<endl;
    }	
  }
  file3<<"list3endtest"<<com<<endl;	
  cout<<"make list3 done!"<<endl;
  file3.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq -0x228(%rbp), %rbx
movq %rbx, %rdi
callq 0x10f0
leaq 0xd3d(%rip), %rsi       # 0x2023
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x1030
leaq 0xd37(%rip), %rsi       # 0x202f
leaq -0x228(%rbp), %rdi
callq 0x10a0
leaq 0x2dcd(%rip), %rsi      # 0x40d8
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1050
xorl %r12d, %r12d
leaq -0x228(%rbp), %r14
leaq 0x2dac(%rip), %r15      # 0x40d8
cmpq $0x1a, %r12
je 0x13dd
movq %r14, %rdi
leaq 0xd00(%rip), %rsi       # 0x2040
callq 0x10a0
movq 0x2d6c(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r12), %esi
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
movq %rax, %rdi
callq 0x1050
xorl %r13d, %r13d
cmpq $0x1a, %r13
je 0x13d5
xorl %ebx, %ebx
cmpq $0x1a, %rbx
je 0x13d0
movq 0x2d34(%rip), %rax      # 0x40b8
movsbl (%rax,%r12), %esi
movq %r14, %rdi
callq 0x10b0
movq 0x2d20(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r13), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x2d0c(%rip), %rcx      # 0x40b8
movsbl (%rcx,%rbx), %esi
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
movq %rax, %rdi
callq 0x1050
incq %rbx
jmp 0x1377
incq %r13
jmp 0x136f
incq %r12
jmp 0x132c
leaq 0xc67(%rip), %rsi       # 0x204b
leaq -0x228(%rbp), %rdi
callq 0x10a0
leaq 0x2ce1(%rip), %rsi      # 0x40d8
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1050
movq 0x2bca(%rip), %rdi      # 0x3fd8
leaq 0xc43(%rip), %rsi       # 0x2058
callq 0x10a0
movq %rax, %rdi
callq 0x1050
leaq -0x228(%rbp), %rdi
callq 0x10c0
leaq -0x228(%rbp), %rdi
callq 0x10d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1450
jmp 0x1450
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/coderguang[P]domainCheck/filecn.cpp
// Function: make4list()
void make4list(){

  ofstream file4;
  file4.open("cnlist4.txt");
  file4<<"thisisatestfile4"<<com<<endl;

  for(int m=0;m<MAX;m++)
    for(int i=0;i<MAX;i++){
      file4<<"thiis4test"<<str[m]<<str[i]<<com<<endl;
        for(int j=0;j<MAX;j++)
          for(int k=0;k<MAX;k++){
            file4<<str[m]<<str[i]<<str[j]<<str[k]<<com<<endl;
          }	
         }
  file4<<"list4endtest"<<com<<endl;	
  cout<<"make list4 done!"<<endl;
  file4.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq -0x228(%rbp), %rbx
movq %rbx, %rdi
callq 0x10f0
leaq 0xbd8(%rip), %rsi       # 0x2069
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x1030
leaq 0xbd2(%rip), %rsi       # 0x2075
leaq -0x228(%rbp), %rdi
callq 0x10a0
leaq 0x2c22(%rip), %rsi      # 0x40d8
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1050
xorl %r12d, %r12d
leaq 0x2c08(%rip), %r15      # 0x40d8
cmpq $0x1a, %r12
je 0x15c6
xorl %r13d, %r13d
cmpq $0x1a, %r13
je 0x15be
leaq -0x228(%rbp), %rdi
leaq 0xb91(%rip), %rsi       # 0x2086
callq 0x10a0
movq 0x2bb7(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r12), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x2ba3(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r13), %esi
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
movq %rax, %rdi
callq 0x1050
xorl %ebx, %ebx
cmpq $0x1a, %rbx
je 0x15b6
xorl %r14d, %r14d
cmpq $0x1a, %r14
je 0x15b1
movq 0x2b6b(%rip), %rax      # 0x40b8
movsbl (%rax,%r12), %esi
leaq -0x228(%rbp), %rdi
callq 0x10b0
movq 0x2b53(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r13), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x2b3f(%rip), %rcx      # 0x40b8
movsbl (%rcx,%rbx), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x2b2c(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
movq %rax, %rdi
callq 0x1050
incq %r14
jmp 0x1540
incq %rbx
jmp 0x1537
incq %r13
jmp 0x14dd
incq %r12
jmp 0x14d0
leaq 0xac4(%rip), %rsi       # 0x2091
leaq -0x228(%rbp), %rdi
callq 0x10a0
leaq 0x2af8(%rip), %rsi      # 0x40d8
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1050
movq 0x29e1(%rip), %rdi      # 0x3fd8
leaq 0xaa0(%rip), %rsi       # 0x209e
callq 0x10a0
movq %rax, %rdi
callq 0x1050
leaq -0x228(%rbp), %rdi
callq 0x10c0
leaq -0x228(%rbp), %rdi
callq 0x10d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1639
jmp 0x1639
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/coderguang[P]domainCheck/filecn.cpp
// Function: make5list()
void make5list(){


  ofstream file5;
  file5.open("cnlist5.txt");
  file5<<"thisisatestfile5"<<com<<endl;

  for(int s=0;s<MAX;s++)
    for(int m=0;m<MAX;m++)
      for(int i=0;i<MAX;i++){
        file5<<"thiis5test"<<str[s]<<str[m]<<str[i]<<com<<endl;
          for(int j=0;j<MAX;j++)
            for(int k=0;k<MAX;k++){
              file5<<str[s]<<str[m]<<str[i]<<str[j]<<str[k]<<com<<endl;
            } 
     }
  file5<<"list5endtest"<<com<<endl;	
  cout<<"make list5 done!"<<endl;
  file5.close();
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq -0x228(%rbp), %rbx
movq %rbx, %rdi
callq 0x10f0
leaq 0xa35(%rip), %rsi       # 0x20af
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x1030
leaq 0xa2f(%rip), %rsi       # 0x20bb
leaq -0x228(%rbp), %rdi
callq 0x10a0
leaq 0x2a39(%rip), %rsi      # 0x40d8
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1050
xorl %r12d, %r12d
cmpq $0x1a, %r12
je 0x17fa
xorl %r13d, %r13d
cmpq $0x1a, %r13
je 0x17f2
xorl %ebx, %ebx
cmpq $0x1a, %rbx
je 0x17ea
leaq -0x228(%rbp), %rdi
leaq 0x9e9(%rip), %rsi       # 0x20cc
callq 0x10a0
movq 0x29c9(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r12), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x29b5(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r13), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x29a1(%rip), %rcx      # 0x40b8
movsbl (%rcx,%rbx), %esi
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
leaq 0x29ab(%rip), %rsi      # 0x40d8
callq 0x1090
movq %rax, %rdi
callq 0x1050
xorl %r14d, %r14d
cmpq $0x1a, %r14
je 0x17e2
xorl %r15d, %r15d
cmpq $0x1a, %r15
je 0x17da
movq 0x295d(%rip), %rax      # 0x40b8
movsbl (%rax,%r12), %esi
leaq -0x228(%rbp), %rdi
callq 0x10b0
movq 0x2945(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r13), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x2931(%rip), %rcx      # 0x40b8
movsbl (%rcx,%rbx), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x291e(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x10b0
movq 0x290a(%rip), %rcx      # 0x40b8
movsbl (%rcx,%r15), %esi
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
leaq 0x2913(%rip), %rsi      # 0x40d8
callq 0x1090
movq %rax, %rdi
callq 0x1050
incq %r15
jmp 0x174a
incq %r14
jmp 0x173d
incq %rbx
jmp 0x16cb
incq %r13
jmp 0x16bf
incq %r12
jmp 0x16b2
leaq 0x8d6(%rip), %rsi       # 0x20d7
leaq -0x228(%rbp), %rdi
callq 0x10a0
leaq 0x28c4(%rip), %rsi      # 0x40d8
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1050
movq 0x27ad(%rip), %rdi      # 0x3fd8
leaq 0x8b2(%rip), %rsi       # 0x20e4
callq 0x10a0
movq %rax, %rdi
callq 0x1050
leaq -0x228(%rbp), %rdi
callq 0x10c0
leaq -0x228(%rbp), %rdi
callq 0x10d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x186d
jmp 0x186d
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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 0xdd7(%rip), %rdx       # 0x200a
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x1306
pushq $0x28
popq %rdi
callq 0x1070
movq %rax, %r14
leaq 0xdbe(%rip), %rdx       # 0x200e
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x1306
movq %r14, %rdi
addq $0x8, %rdi
callq 0x1030
pushq $0x28
popq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1080
movq %rbx, %rdi
callq 0x1070
movq %rax, %r14
leaq 0xd8b(%rip), %rdx       # 0x2012
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x1306
movq %r14, %rdi
callq 0x11ec
movq 0x2d37(%rip), %rdi      # 0x3fd8
leaq 0xd70(%rip), %rsi       # 0x2018
callq 0x1060
movq 0x2d24(%rip), %rdi      # 0x3fd8
leaq 0xd79(%rip), %rsi       # 0x2034
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x8(%rsp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x12de
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x1080
jmp 0x12f3
jmp 0x12f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]asyncore_cpp/net/test/test_redisprotocol.cc
// Function: main
int main(){
	net::protocol::RedisProtocol p;

	test(p, "*3\r\n$3\r\nSET\r\n$4\r\ncity\r\n$5\r\nSofia\r\n");

	test(p, "*2\r\n$3\r\nGET\r\n$4\r\ncity\r\n");

	test(p, "*92\r\n$3\r\nGET\r\n$4\r\ncity\r\n");
	test(p, "$2\r\n$3\r\nGET\r\n$4\r\ncity\r\n");
	test(p, "*2\r\n*3\r\nGET\r\n$4\r\ncity\r\n");

#if 0
	using Status = net::protocol::RedisProtocol::Status;

	const char *data = "*3\r\n$3\r\nSET\r\n$4\r\ncity\r\n$5\r\nSofia\r\n";

	for(int i = 0; i < 2500000; ++i){
		const auto &status = p(data);

		if (status == Status::BUFFER_NOT_READ)
			std::cout << "problem" << std::endl;
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x1326
leaq 0xd4c(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x135b
leaq 0xd60(%rip), %rsi       # 0x2027
leaq -0x20(%rbp), %rdi
callq 0x135b
leaq 0xd68(%rip), %rsi       # 0x203f
leaq -0x20(%rbp), %rdi
callq 0x135b
leaq 0xd71(%rip), %rsi       # 0x2058
leaq -0x20(%rbp), %rdi
callq 0x135b
leaq 0xd79(%rip), %rsi       # 0x2070
leaq -0x20(%rbp), %rdi
callq 0x135b
leaq -0x20(%rbp), %rdi
callq 0x14fe
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x14fe
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]asyncore_cpp/net/test/test_redisprotocol.cc
// Function: void test<net::protocol::RedisProtocol>(net::protocol::RedisProtocol&, char const*)
void test(PROTOCOL &p, const char *data){
	using Status = typename PROTOCOL::Status;

	const Status status = p(data);

	std::cout	<< "Result status: " << test_status(status) << std::endl
			<< std::endl
	;

	if (status == Status::OK)
		p.print();

	std::cout	<< "---(eof)---" << std::endl
			<< std::endl
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x1512
movq %rbx, %rdi
movq %r14, %rsi
callq 0x159a
movl %eax, %r14d
movq 0x2c4e(%rip), %rdi      # 0x3fd8
leaq 0xd07(%rip), %rsi       # 0x2098
callq 0x10a0
cmpl $0x1, %r14d
leaq 0xd16(%rip), %rcx       # 0x20b7
leaq 0xd14(%rip), %rdx       # 0x20bc
cmoveq %rcx, %rdx
testl %r14d, %r14d
leaq 0xcfe(%rip), %rsi       # 0x20b4
cmovneq %rdx, %rsi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1050
testl %r14d, %r14d
jne 0x13df
movq %rbx, %rdi
callq 0x1558
movq 0x2bf2(%rip), %rdi      # 0x3fd8
leaq 0xcbb(%rip), %rsi       # 0x20a8
callq 0x10a0
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1050
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
pushq $0x2
popq %r15
cmpb $0x2a, (%rax)
jne 0x1645
movq %rsi, %rbx
movq $0x1, -0x30(%rbp)
cmpq $0x2, (%rsi)
jae 0x15d3
pushq $0x1
popq %r15
jmp 0x1645
movq %rdi, %r14
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1658
movl %eax, %r12d
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x15f2
movq %rax, 0x8(%r14)
leal -0x5(%r12), %eax
cmpl $-0x4, %eax
jb 0x1645
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x16b4
movl %eax, %r15d
testl %eax, %eax
jne 0x1645
movslq %r12d, %r13
leaq -0x30(%rbp), %r12
subq $0x1, %r13
jb 0x1642
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x16ea
movl -0x48(%rbp), %r15d
testl %r15d, %r15d
jne 0x1645
movq %r14, %rdi
leaq -0x40(%rbp), %rsi
callq 0x17fe
jmp 0x1616
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rdi, %r14
subl %esi, 0x2c(%rdi)
leaq 0x8(%rdi), %rbx
movq 0xeca2(%rip), %rdi      # 0x12fd0
movq %rbx, %rsi
callq 0x3170
leaq 0x7f0b(%rip), %rsi      # 0xc248
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
movl %r15d, %esi
callq 0x3230
leaq 0x7eff(%rip), %rsi      # 0xc256
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30f0
cmpl $0x0, 0x2c(%r14)
jle 0x4379
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xec50(%rip), %rdi      # 0x12fd0
movq %rbx, %rsi
callq 0x3170
leaq 0x7eda(%rip), %rsi      # 0xc269
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::Hero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int)
Hero::Hero(string nam, int hp, int mp, int str, int ag, int dex)
    :Living(nam,hp),MagicPower(mp),Strength(str),Agility(ag),Dexterity(dex){
    Money = 500;
    exp = 0;
    NextLvlExp = 20;
    Armor_Equiped = NULL;
    Weapon_Equiped = NULL;
    Defense = 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, -0x2c(%rbp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %rbx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x3200
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x42b0
movl 0x10(%rbp), %r14d
leaq -0x50(%rbp), %rdi
callq 0x30e0
leaq 0xe5ef(%rip), %rax      # 0x129e8
movq %rax, (%rbx)
movl %r12d, 0x34(%rbx)
movl %r15d, 0x38(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x3c(%rbx)
movl %r14d, 0x40(%rbx)
leaq 0x68(%rbx), %rax
movq %rax, 0x70(%rbx)
movq %rax, 0x68(%rbx)
andq $0x0, 0x78(%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x88(%rbx)
movq %rax, 0x80(%rbx)
andq $0x0, 0x90(%rbx)
leaq 0x98(%rbx), %rax
movq %rax, 0xa0(%rbx)
movq %rax, 0x98(%rbx)
andq $0x0, 0xa8(%rbx)
leaq 0xb0(%rbx), %rax
movq %rax, 0xb8(%rbx)
movq %rax, 0xb0(%rbx)
andq $0x0, 0xc0(%rbx)
movq $0x1f4, 0x48(%rbx)      # imm = 0x1F4
movl $0x14, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movl $0x5, 0x44(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movq %rsi, -0x20(%rbp)
movl 0x48(%rdi), %r15d
movq %rsi, %rdi
callq 0x9f5c
cmpl %eax, %r15d
jge 0x4563
movq 0xea8b(%rip), %rdi      # 0x12fd0
leaq 0x7d2f(%rip), %rsi      # 0xc27b
callq 0x31a0
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
movq %r14, %rdi
callq 0x9f5c
subl %eax, 0x48(%rbx)
addq $0x68, %rbx
leaq -0x20(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b14
movq 0xea48(%rip), %rdi      # 0x12fd0
leaq 0x7cfe(%rip), %rsi      # 0xc28d
callq 0x31a0
movq %rax, %rbx
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x9f40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
movq %rax, %rdi
callq 0x30f0
leaq -0x40(%rbp), %rdi
callq 0x30e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movq %rsi, -0x20(%rbp)
movl 0x48(%rdi), %r15d
movq %rsi, %rdi
callq 0x9f5c
cmpl %eax, %r15d
jge 0x462f
movq 0xe9bf(%rip), %rdi      # 0x12fd0
leaq 0x7c63(%rip), %rsi      # 0xc27b
callq 0x31a0
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
movq %r14, %rdi
callq 0x9f5c
subl %eax, 0x48(%rbx)
addq $0x98, %rbx
leaq -0x20(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b24
movq 0xe979(%rip), %rdi      # 0x12fd0
leaq 0x7c55(%rip), %rsi      # 0xc2b3
callq 0x31a0
movq %rax, %rbx
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x9f40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
movq %rax, %rdi
callq 0x30f0
leaq -0x40(%rbp), %rdi
callq 0x30e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movq %rsi, -0x20(%rbp)
movl 0x48(%rdi), %r15d
movq %rsi, %rdi
callq 0x9f5c
cmpl %eax, %r15d
jge 0x46fd
movq 0xe8f1(%rip), %rdi      # 0x12fd0
leaq 0x7b95(%rip), %rsi      # 0xc27b
callq 0x31a0
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
movq %r14, %rdi
callq 0x9f5c
subl %eax, 0x48(%rbx)
addq $0xb0, %rbx
leaq -0x20(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b34
movq 0xe8ab(%rip), %rdi      # 0x12fd0
leaq 0x7bac(%rip), %rsi      # 0xc2d8
callq 0x31a0
movq %rax, %rbx
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x9f40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
movq %rax, %rdi
callq 0x30f0
leaq -0x40(%rbp), %rdi
callq 0x30e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movq %rsi, -0x20(%rbp)
movl 0x48(%rdi), %r15d
movq %rsi, %rdi
callq 0x9f5c
cmpl %eax, %r15d
jge 0x47cb
movq 0xe823(%rip), %rdi      # 0x12fd0
leaq 0x7ac7(%rip), %rsi      # 0xc27b
callq 0x31a0
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
movq %r14, %rdi
callq 0x9f5c
subl %eax, 0x48(%rbx)
subq $-0x80, %rbx
leaq -0x20(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b44
movq 0xe7e0(%rip), %rdi      # 0x12fd0
leaq 0x7b07(%rip), %rsi      # 0xc2fe
callq 0x31a0
movq %rax, %rbx
movq (%r14), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x9f40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
movq %rax, %rdi
callq 0x30f0
leaq -0x40(%rbp), %rdi
callq 0x30e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
nop
// File: /workspace/github_cpp_makefile_star2_O2/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::display_stats()
void Hero::display_stats(){
    cout << name << "   Level: " << Level << endl;
    cout << "XP: " << exp << "/" << NextLvlExp << endl;
    cout << "HP: " << HealthPower << endl;
    cout << "Coins: " << Money << endl; 
    cout << "Strength: " << Strength << endl;
    cout << "Agility: " << Agility << endl;
    cout << "Dexterity: " << Dexterity << endl;
    cout << "Defense: " << Defense << endl;
    cout << "MAgic Power: " << MagicPower << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq 0xe219(%rip), %r14      # 0x12fd0
movq %r14, %rdi
callq 0x3170
leaq 0x759d(%rip), %rsi      # 0xc363
movq %rax, %rdi
callq 0x31a0
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
leaq 0x7586(%rip), %rsi      # 0xc36e
movq %r14, %rdi
callq 0x31a0
movl 0x4c(%rbx), %esi
movq %rax, %rdi
callq 0x3230
leaq 0x7571(%rip), %rsi      # 0xc373
movq %rax, %rdi
callq 0x31a0
movl 0x50(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
leaq 0x7551(%rip), %rsi      # 0xc375
movq %r14, %rdi
callq 0x31a0
movl 0x2c(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
leaq 0x7534(%rip), %rsi      # 0xc37a
movq %r14, %rdi
callq 0x31a0
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
leaq 0x751a(%rip), %rsi      # 0xc382
movq %r14, %rdi
callq 0x31a0
movl 0x38(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
leaq 0x7503(%rip), %rsi      # 0xc38d
movq %r14, %rdi
callq 0x31a0
movl 0x3c(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
leaq 0x74eb(%rip), %rsi      # 0xc397
movq %r14, %rdi
callq 0x31a0
movl 0x40(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
leaq 0x74d5(%rip), %rsi      # 0xc3a3
movq %r14, %rdi
callq 0x31a0
movl 0x44(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
leaq 0x74bd(%rip), %rsi      # 0xc3ad
movq %r14, %rdi
callq 0x31a0
movl 0x34(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
addq $0x68, %r13
leaq -0x48(%rbp), %r14
movq 0xe09d(%rip), %r15      # 0x12fd0
movq %r13, %rbx
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0x4fc9
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x9f40
movq %r15, %rdi
movq %r14, %rsi
callq 0x3170
movq %rax, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x30e0
movq %r15, %rdi
leaq 0x720b(%rip), %rsi      # 0xc17e
callq 0x31a0
movq %rax, %r12
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %r12, %rdi
movl %eax, %esi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
movq %r15, %rdi
leaq 0x741a(%rip), %rsi      # 0xc3bb
callq 0x31a0
movq %rax, %r12
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %r12, %rdi
movl %eax, %esi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
jmp 0x4f36
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
addq $0x98, %r12
leaq -0x48(%rbp), %r14
movq 0xdfbe(%rip), %r15      # 0x12fd0
movq %r12, %rbx
movq (%rbx), %rbx
cmpq %r12, %rbx
je 0x5074
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x9f40
movq %r15, %rdi
movq %r14, %rsi
callq 0x3170
movq %rax, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x30e0
movq %r15, %rdi
leaq 0x7355(%rip), %rsi      # 0xc3a3
callq 0x31a0
movq %rax, %r13
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %r13, %rdi
movl %eax, %esi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
jmp 0x5015
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5175
leaq -0x48(%rbp), %r14
movq 0xdf02(%rip), %r15      # 0x12fd0
cmpq %rbx, %r13
je 0x5166
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0x9f40
movq %r15, %rdi
movq %r14, %rsi
callq 0x3170
movq %rax, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x30e0
movq %r15, %rdi
leaq 0x72dd(%rip), %rsi      # 0xc3e5
callq 0x31a0
movq %rax, %r12
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0xa304
movq %r12, %rdi
movq %r14, %rsi
callq 0x3170
movq %r14, %rdi
callq 0x30e0
movq %r15, %rdi
leaq 0x72b3(%rip), %rsi      # 0xc3ec
callq 0x31a0
movq %rax, %r12
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r12, %rdi
movl %eax, %esi
callq 0x3230
movq %rax, %rdi
callq 0x30f0
movq (%r13), %r13
jmp 0x50ce
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xde54(%rip), %rdi      # 0x12fd0
leaq 0x7247(%rip), %rsi      # 0xc3ca
callq 0x31a0
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
jmp 0x51a0
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movl 0x78(%rdi), %esi
movq 0xddcd(%rip), %rdi      # 0x12fd0
callq 0x3230
movq %rax, %rdi
callq 0x30f0
movq %rbx, -0x30(%rbp)
addq $0x68, %rbx
leaq -0x50(%rbp), %r15
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x526a
movq 0x10(%r13), %rsi
movq %r15, %rdi
callq 0x9f40
movq %r15, %rdi
movq %r14, %rsi
callq 0x5ce4
movl %eax, %r12d
movq %r15, %rdi
callq 0x30e0
testb %r12b, %r12b
je 0x521f
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x30(%rbp), %rcx
addl %eax, 0x38(%rcx)
movq 0x10(%r13), %rax
movq %rax, 0x58(%rcx)
jmp 0x5285
movq 0xdd5f(%rip), %rdi      # 0x12fd0
leaq 0x7177(%rip), %rsi      # 0xc3ef
callq 0x31a0
movq %rax, %rdi
callq 0x30f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x50(%rbp), %r15
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x530f
movq 0x10(%r13), %rsi
movq %r15, %rdi
callq 0x9f40
movq %r15, %rdi
movq %r14, %rsi
callq 0x5ce4
movl %eax, %r12d
movq %r15, %rdi
callq 0x30e0
testb %r12b, %r12b
je 0x52c4
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 0x532a
movq 0xdcba(%rip), %rdi      # 0x12fd0
leaq 0x70fe(%rip), %rsi      # 0xc41b
callq 0x31a0
movq %rax, %rdi
callq 0x30f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x50(%rbp), %r15
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x53c5
movq 0x10(%r13), %rsi
movq %r15, %rdi
callq 0x9f40
movq %r15, %rdi
movq %r14, %rsi
callq 0x5ce4
movl %eax, %r12d
movq %r15, %rdi
callq 0x30e0
testb %r12b, %r12b
je 0x5360
movq -0x30(%rbp), %r14
movl 0x34(%r14), %ebx
movq 0x10(%r13), %rdi
callq 0x9cea
cmpl %eax, %ebx
jl 0x53b2
movq 0x10(%r13), %rdi
callq 0x9cea
subl %eax, 0x34(%r14)
movq 0x10(%r13), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdc04(%rip), %rdi      # 0x12fd0
leaq 0x7073(%rip), %rsi      # 0xc446
callq 0x31a0
movq %rax, %rdi
callq 0x30f0
// File: /workspace/github_cpp_makefile_star2_O2/kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::get_attacked(int)
void Hero::get_attacked(int dmg){
    int p = rand()%100;

    if(p <= Agility){
        cout << name << " dodged the Monster's attack!" << endl;
    }else{
        dec_hp(dmg);
        HealthPower += Defense;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x3070
pushq $0x64
popq %rcx
cltd
idivl %ecx
cmpl 0x3c(%rbx), %edx
jle 0x564b
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *(%rax)
movl 0x44(%rbx), %eax
addl %eax, 0x2c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
addq $0x8, %rbx
movq 0xd97a(%rip), %rdi      # 0x12fd0
movq %rbx, %rsi
callq 0x3170
leaq 0x6e6a(%rip), %rsi      # 0xc4cf
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
imull $0x19, %eax, %ecx
addl %ecx, 0x48(%rdi)
imull $0x14, %eax, %ecx
addl 0x4c(%rdi), %ecx
movl %ecx, 0x4c(%rdi)
cmpl 0x50(%rdi), %ecx
jl 0x56b6
incl %eax
movl %eax, 0x28(%rdi)
andl $0x0, 0x4c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2sdl 0x38(%rdi), %xmm0
movsd 0x6a9a(%rip), %xmm1     # 0xc238
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x38(%rdi)
cvtsi2sdl 0x3c(%rdi), %xmm0
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x3c(%rdi)
cvtsi2sdl 0x40(%rdi), %xmm0
movsd 0x6a6e(%rip), %xmm1     # 0xc240
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x40(%rdi)
incl 0x28(%rdi)
movq 0xd7e5(%rip), %rdi      # 0x12fd0
leaq 0x6d1e(%rip), %rsi      # 0xc510
callq 0x31a0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3170
leaq 0x6d13(%rip), %rsi      # 0xc51d
movq %rax, %rdi
callq 0x31a0
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2sdl 0x38(%rdi), %xmm0
movsd 0x692e(%rip), %xmm1     # 0xc240
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x38(%rdi)
cvtsi2sdl 0x3c(%rdi), %xmm0
movsd 0x690a(%rip), %xmm1     # 0xc238
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x3c(%rdi)
cvtsi2sdl 0x40(%rdi), %xmm0
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x40(%rdi)
incl 0x28(%rdi)
movq 0xd671(%rip), %rdi      # 0x12fd0
leaq 0x6bfa(%rip), %rsi      # 0xc560
callq 0x31a0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3170
leaq 0x6b9f(%rip), %rsi      # 0xc51d
movq %rax, %rdi
callq 0x31a0
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2sdl 0x38(%rdi), %xmm0
movsd 0x67b2(%rip), %xmm1     # 0xc238
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x38(%rdi)
cvtsi2sdl 0x3c(%rdi), %xmm0
movsd 0x679a(%rip), %xmm2     # 0xc240
mulsd %xmm0, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x3c(%rdi)
cvtsi2sdl 0x40(%rdi), %xmm0
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x40(%rdi)
incl 0x28(%rdi)
movq 0xd4fd(%rip), %rdi      # 0x12fd0
leaq 0x6ab7(%rip), %rsi      # 0xc591
callq 0x31a0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3170
leaq 0x6a2b(%rip), %rsi      # 0xc51d
movq %rax, %rdi
callq 0x31a0
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rax)
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *0x30(%rax)
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %r15
movq %r15, %rsi
callq 0x31e0
movq %r15, %rdi
callq 0x30e0
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movl %eax, %r14d
leaq 0x60f0(%rip), %rsi      # 0xc5f2
leaq -0x38(%rbp), %rdi
callq 0x5d10
testb %al, %al
je 0x6526
movl 0x34(%rbx), %ecx
imull %ecx, %r14d
pushq $-0x64
popq %rsi
movl %r14d, %eax
cltd
idivl %esi
addl %ecx, %eax
movl %eax, 0x34(%rbx)
jmp 0x6566
leaq 0x60ce(%rip), %rsi      # 0xc5fb
leaq -0x38(%rbp), %rdi
callq 0x5d10
testb %al, %al
je 0x6551
movl 0x38(%rbx), %ecx
imull %ecx, %r14d
pushq $-0x64
popq %rsi
movl %r14d, %eax
cltd
idivl %esi
addl %ecx, %eax
movl %eax, 0x38(%rbx)
jmp 0x6566
movl 0x3c(%rbx), %ecx
imull %ecx, %r14d
pushq $-0x64
popq %rsi
movl %r14d, %eax
cltd
idivl %esi
addl %ecx, %eax
movl %eax, 0x3c(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x30e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x657c
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3070
pushq $0x64
popq %rcx
cltd
idivl %ecx
cmpl 0x3c(%r14), %edx
jle 0x668e
movl 0x38(%r14), %eax
addl %ebx, %eax
subl %eax, 0x2c(%r14)
addq $0x8, %r14
movq 0xc96c(%rip), %rdi      # 0x12fd0
movq %r14, %rsi
callq 0x3170
leaq 0x5bd5(%rip), %rsi      # 0xc248
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3230
leaq 0x5f8d(%rip), %rsi      # 0xc619
jmp 0x66a8
addq $0x8, %r14
movq 0xc937(%rip), %rdi      # 0x12fd0
movq %r14, %rsi
callq 0x3170
leaq 0x5f5d(%rip), %rsi      # 0xc605
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ebc
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x7ede
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x7f00
leaq 0x48(%rbx), %r12
movq %r12, %rdi
callq 0x7f22
leaq 0x60(%rbx), %r13
movq %r13, %rdi
callq 0x7f44
movq %r13, %rdi
callq 0x7f84
movq %r12, %rdi
callq 0x5e38
movq %r15, %rdi
callq 0x5dc2
movq %r14, %rdi
callq 0x5e04
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5e6c