LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/configuration/configuration.cpp
// Function: nettoyer_ligne(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string nettoyer_ligne(string ligne) {
	string sans_comment = ligne;
	// Suppression des commentairess
	sans_comment = sans_comment.substr(0,sans_comment.find_first_of("#"));

	//supprimer les espaces en plus el tes tabulations
	//supprimer les espaces et les tabulations en debut de chaine
	while ((sans_comment[0] == ' ') || (sans_comment[0] == '\t'))
		sans_comment.erase(0,1);

	//supprimer les espaces et les tabulations en mileux de chaine
	unsigned int i = 1;
	while (i < sans_comment.size()) {
		if ((sans_comment[i] == ' ') && (sans_comment[i-1] == ' '))
			sans_comment.erase(i,1);
		else if (sans_comment[i] == '\t') // remplace les tabulation au milieu par un espace
			sans_comment[i] = ' ';
		else
			++i;
	}

	//suprimer les espaces et les tabulations en fin de chaine 
	while ((sans_comment[sans_comment.size()-1] == ' ') || (sans_comment[sans_comment.size()-1] == '\t'))
		sans_comment.erase(sans_comment.size()-1,1);

	return sans_comment;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4eb6
leaq 0x204e(%rip), %rsi      # 0x726e
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2270
movq %rsp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21c0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5267
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movq (%rbx), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0x5277
cmpl $0x20, %eax
jne 0x5288
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2050
jmp 0x5267
cmpq $0x2, 0x8(%rbx)
jb 0x52d6
movl $0x1, %r14d
movl $0x1, %esi
movq (%rbx), %rax
movzbl (%rax,%rsi), %ecx
cmpl $0x9, %ecx
je 0x52c9
cmpl $0x20, %ecx
jne 0x52c4
leal -0x1(%r14), %ecx
cmpb $0x20, (%rax,%rcx)
jne 0x52c4
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2050
jmp 0x52cd
incl %r14d
jmp 0x52cd
movb $0x20, (%rax,%rsi)
movl %r14d, %esi
cmpq %rsi, 0x8(%rbx)
ja 0x529a
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movzbl -0x1(%rax,%rsi), %eax
cmpl $0x20, %eax
je 0x52ec
cmpl $0x9, %eax
jne 0x52fe
decq %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2050
jmp 0x52d6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5311
jmp 0x5311
jmp 0x5311
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5327
movq (%r15), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/configuration/configuration.cpp
// Function: verif_valeur(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool verif_valeur(string cle,string valeur) {
	int x,y;
	if ((cle == "Probability") && (isFloat(valeur)))
		return true;
	else if ((cle == "Dimension" && (convert(valeur) > 0)))
		return true;
	else if ((cle == "Cell" && (decode_cell(valeur,x,y))))
		return true;
	else 
		return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2125(%rip), %rsi      # 0x74c1
callq 0x20a0
testl %eax, %eax
jne 0x53f4
leaq 0x60(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x4eb6
movq %r15, %rdi
callq 0x5c7d
movl %eax, %r15d
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x53e8
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21a0
movb $0x1, %bpl
testb %r15b, %r15b
jne 0x54ba
leaq 0x20d2(%rip), %rsi      # 0x74cd
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0x5421
leaq 0x20c9(%rip), %rsi      # 0x74d7
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0x546e
xorl %ebp, %ebp
jmp 0x54ba
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x4eb6
movq %r15, %rdi
callq 0x5ae8
movl %eax, %r15d
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x5464
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
movb $0x1, %bpl
testl %r15d, %r15d
jg 0x54ba
jmp 0x5407
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x4eb6
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x54fe
movl %eax, %ebp
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x54ba
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x54e5
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x54e5
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x54f6
movq (%r12), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/configuration/configuration.cpp
// Function: set_cle_valeur(Population&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void set_cle_valeur(Population& pop,string const cle,string const valeur) {
	if (cle == "Probability")
		pop.set_probability(atof(valeur.c_str()));
	else if (cle == "Dimension")
		pop.set_dimension(convert(valeur));
	else if (cle == "Cell") {
		int x,y;
		if (decode_cell(valeur,x,y))
			pop.set_cell(x,y);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1b23(%rip), %rsi      # 0x74c1
movq %r15, %rdi
callq 0x20a0
testl %eax, %eax
je 0x5a3d
leaq 0x1b18(%rip), %rsi      # 0x74cd
movq %r15, %rdi
callq 0x20a0
testl %eax, %eax
je 0x5a5b
leaq 0x1b0b(%rip), %rsi      # 0x74d7
movq %r15, %rdi
callq 0x20a0
testl %eax, %eax
jne 0x5aa5
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4eb6
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x54fe
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5a25
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testb %bpl, %bpl
je 0x5aa5
movslq 0x4(%rsp), %rsi
movslq (%rsp), %rdx
movq %rbx, %rdi
callq 0x3c5e
jmp 0x5aa5
movq (%r14), %rdi
callq 0x2200
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3772
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x4eb6
movq %r14, %rdi
callq 0x5ae8
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x3808
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5aa5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5ade
movq 0x18(%rsp), %rsi
jmp 0x5ad6
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5ade
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/configuration/convert/convert.cpp
// Function: dix_puiss(int)
size_t dix_puiss(int n) {
	if(n<0)
		return -1; /* ERREUR */
	else {
		if (n == 0)
			return 1;
		else 
			return 10*dix_puiss(n-1);
	}
}

// Assembly:
testl %edi, %edi
js 0x5c48
movl $0x1, %eax
je 0x5c47
addq %rax, %rax
leaq (%rax,%rax,4), %rax
decl %edi
jne 0x5c3c
retq
movq $-0x1, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/configuration/convert/convert.cpp
// Function: nbr_char(unsigned long)
int nbr_char(size_t n) {
	if (n < 10)
		return 1;
	else 
		return nbr_char(n / 10) + 1 ;
}

// Assembly:
movl $0x1, %ecx
cmpq $0xa, %rdi
jb 0x5c7a
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %rsi
shrq $0x3, %rdx
incl %ecx
cmpq $0x63, %rdi
movq %rdx, %rdi
ja 0x5c65
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/configuration/convert/convert.cpp
// Function: isFloat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isFloat( string myString ) {
    istringstream iss(myString);
    float f;
    iss >> noskipws >> f; // noskipws considers leading whitespace invalid
    // Check the entire string was consumed and if either failbit or badbit is set
    return iss.eof() && !iss.fail(); 
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x22b0
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x28(%rsp,%rax) # imm = 0xFFFFEFFF
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x2330
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
sete %bl
movq 0x52f2(%rip), %rsi      # 0xafc8
callq 0x2250
leaq 0x88(%rsp), %rdi
callq 0x20b0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x52cb(%rip), %rsi      # 0xafc8
leaq 0x10(%rsp), %rdi
callq 0x2250
leaq 0x88(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option::print() const
void Option::print() const {
		std::cout << "Identifiant : " << identifiant << std::endl
			<< "Nom : " << nom << std::endl
			<< "Racourci : " << racourci << std::endl
			<< "Type d'argumment : "<< argument << std::endl
			<< "Description : "<< description << std::endl;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x506e(%rip), %r14      # 0xafd0
leaq 0x15b7(%rip), %rsi      # 0x7520
movl $0xe, %edx
movq %r14, %rdi
callq 0x21d0
movl (%rbx), %esi
movq %r14, %rdi
callq 0x22d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movq %rax, %r14
leaq 0x157b(%rip), %rsi      # 0x752f
movl $0x6, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x21d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movq %rax, %r14
leaq 0x1531(%rip), %rsi      # 0x7536
movl $0xb, %edx
movq %rax, %rdi
callq 0x21d0
movb 0x28(%rbx), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x21d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movq %rax, %r14
leaq 0x14e5(%rip), %rsi      # 0x7542
movl $0x13, %edx
movq %rax, %rdi
callq 0x21d0
movl 0x2c(%rbx), %esi
movq %r14, %rdi
callq 0x22d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movq %rax, %r14
leaq 0x14ad(%rip), %rsi      # 0x7556
movl $0xe, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x21d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option::operator=(Option const&)
Option Option::operator=(Option const& copy) {
		if (this != &copy) {
			identifiant = copy.get_identifiant();
			nom = (copy.get_nom());
			racourci = (copy.get_racourci());
			argument = (copy.get_argument());
			description = (copy.get_description());
		}

		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x61cb
movq %rdx, %r15
movl (%rdx), %eax
movl %eax, (%r14)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x4eb6
leaq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x21f0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x617f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movb 0x28(%r15), %al
movb %al, 0x28(%r14)
movl 0x2c(%r15), %eax
movl %eax, 0x2c(%r14)
movq %rsp, %r12
movq %r13, (%r12)
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4eb6
leaq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x21f0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x61cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5dcc
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::add(Option const&)
void Option_tab::add(const Option &opt){
	// Vérifit si l'option n'existe pas déja dans le tableau
	if (get_option(opt.get_identifiant()) == -1) {	
		tab[nb] = opt;
		nb++;
	}
	else 
		std::cerr << "Identifiant déjà existant dans le tableau." <<std::endl<< std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x6a48
movl (%rdx), %ecx
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
negq %rdi
xorl %r8d, %r8d
cmpl %ecx, (%rsi)
je 0x6a42
decq %r8
addq $0x50, %rsi
cmpq %r8, %rdi
jne 0x6a30
jmp 0x6a48
cmpq $0x1, %r8
jne 0x6aa6
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x611a
movq 0x30(%r14), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x6a80
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a9b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
incq (%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x4543(%rip), %rbx      # 0xaff0
leaq 0xbf8(%rip), %rsi       # 0x76ac
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::get_option(Option::Id)
int Option_tab::get_option(const Option::Id id){
	int i = 0;
	while (i < nb) {
		if (tab[i].get_identifiant() == id)
			return i;
	++i;
	}
	if (i == nb)
		return -1;
}

// Assembly:
movq (%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x6b3d
addq $0x8, %rdi
xorl %edx, %edx
cmpl %esi, (%rdi)
je 0x6b3e
incq %rdx
addq $0x50, %rdi
cmpq %rdx, %rcx
jne 0x6b2d
retq
movl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::cherche(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Option::Id Option_tab::cherche(const std::string &nom) const{
	for (int i = 0; i < nb; ++i) {
		if (tab[i].get_nom() == nom)
			return tab[i].get_identifiant();
	}
	return Option::NB_ID;
}

// Assembly:
movl $0x6, %eax
cmpq $0x0, (%rdi)
je 0x6c65
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbp
xorl %r12d, %r12d
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq -0x8(%rbp), %rsi
movq (%rbp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x4eb6
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x6c18
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0x6c21
movq (%r14), %rsi
movq %r13, %rdi
callq 0x21b0
testl %eax, %eax
sete %bl
jmp 0x6c23
movq 0x8(%rsp), %r13
xorl %ebx, %ebx
jmp 0x6c23
movb $0x1, %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0x6c3d
movq 0x18(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x21a0
testb %bl, %bl
jne 0x6c54
incq %r12
addq $0x50, %rbp
cmpq %r12, (%r15)
ja 0x6bd2
movl $0x6, %eax
jmp 0x6c57
movl -0x10(%rbp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::cherche(char) const
Option::Id Option_tab::cherche(const char rac) const{
	for (int i = 0; i < nb; ++i) {
		if (tab[i].get_racourci() == rac)
			return tab[i].get_identifiant();
	}
	return Option::NB_ID;
}

// Assembly:
movq (%rdi), %rcx
movl $0x6, %eax
testq %rcx, %rcx
je 0x6c85
addq $0x30, %rdi
cmpb %sil, (%rdi)
je 0x6c86
addq $0x50, %rdi
decq %rcx
jne 0x6c77
retq
movl -0x28(%rdi), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::get_argument(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Option::Arg Option_tab::get_argument(const std::string &nom) const{
	for (int i = 0; i < nb; ++i) {
		if (tab[i].get_nom() == nom)
			return tab[i].get_argument();
	}
	return Option::NB_ARG;
}

// Assembly:
movl $0x5, %eax
cmpq $0x0, (%rdi)
je 0x6e21
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %rbp
xorl %r12d, %r12d
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x4eb6
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x6dd4
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0x6ddd
movq (%r14), %rsi
movq %r13, %rdi
callq 0x21b0
testl %eax, %eax
sete %bl
jmp 0x6ddf
movq 0x8(%rsp), %r13
xorl %ebx, %ebx
jmp 0x6ddf
movb $0x1, %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0x6df9
movq 0x18(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x21a0
testb %bl, %bl
jne 0x6e10
incq %r12
addq $0x50, %rbp
cmpq %r12, (%r15)
ja 0x6d8e
movl $0x5, %eax
jmp 0x6e13
movl 0x24(%rbp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::get_argument(Option::Id) const
Option::Arg Option_tab::get_argument(const Option::Id  id) const{
	for (int i = 0; i < nb; ++i) {
		if (tab[i].get_identifiant() == id)
			return tab[i].get_argument();
	}
	return Option::NB_ARG;
}

// Assembly:
movq (%rdi), %rcx
movl $0x5, %eax
testq %rcx, %rcx
je 0x6e41
addq $0x34, %rdi
cmpl %esi, -0x2c(%rdi)
je 0x6e42
addq $0x50, %rdi
decq %rcx
jne 0x6e33
retq
movl (%rdi), %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/main.cpp
// Function: main
int main(int argc, char const *argv[])
{
	// Initialisé le jeu selon les arguments donnée en paramétre
	Population jeu(argc,argv);
	jeu.init();
	/*
	jeu.affiche_matrice_bw();
	jeu.affiche_dynamique();

	jeu = jeu.next();

	jeu.affiche_matrice_bw();
	jeu.affiche_dynamique();

	jeu = jeu.next();

	jeu.affiche_matrice();
	jeu.affiche_dynamique();
	*/

	simulation(jeu);

	/* Mode Statistique à regler*/
	//fstream stat("vie.stat",ios::out | ios::app);
	//jeu.begin(stat);

	cout << endl << "############################# END OF PROG #############################" << endl;
	
	return 0;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rdx
movl %edi, %esi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2ca0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3a6a
movq %rsp, %rdi
callq 0x4336
movq 0x4102(%rip), %rdi      # 0xafd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq 0x40e7(%rip), %rdi      # 0xafd0
callq 0x2040
movq %rax, %rdi
callq 0x2100
movq %rax, %rbx
leaq 0x7f8(%rip), %rsi       # 0x76f8
movl $0x47, %edx
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movq %rsp, %rdi
callq 0x3962
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3962
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/vecStrings2.cc
// Function: main
int main()
{
	vector<string> text;     // holds the input

	string s;
	while (getline(cin, s))  // read the entire input file
		text.push_back(s);   // storing each line as an element in text
	cout << "text.size: " << text.size() << endl;

	// print each line in text up to the first blank line
	for (auto it = text.cbegin(); 
	     it != text.cend() && !(*it).empty(); ++it) 
		cout << *it << endl;

	// equivalent loop using arrow to dereference it and call empty
	for (auto it = text.cbegin(); 
	     it != text.cend() && !it->empty(); ++it) 
		cout << *it << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq 0x2cdb(%rip), %r14      # 0x3fe0
leaq -0x60(%rbp), %r15
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1346
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14ca
jmp 0x1309
movq 0x2c83(%rip), %rdi      # 0x3fd0
leaq 0xcb0(%rip), %rsi       # 0x2004
movl $0xb, %edx
callq 0x1110
movq -0x38(%rbp), %rsi
subq -0x40(%rbp), %rsi
sarq $0x5, %rsi
movq 0x2c5f(%rip), %rdi      # 0x3fd0
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %rax
cmpq %rax, %r15
je 0x146e
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x1416
addq $0x20, %r15
movq 0x2c0b(%rip), %rbx      # 0x3fd0
movq -0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x1110
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq -0x38(%rbp), %rax
cmpq %rax, %r15
je 0x1413
movq 0x8(%r15), %rdx
addq $0x20, %r15
testq %rdx, %rdx
jne 0x13c5
jmp 0x1416
movq %r15, %rax
movq -0x40(%rbp), %r15
cmpq %rax, %r15
je 0x146e
movq 0x2baa(%rip), %rbx      # 0x3fd0
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x146e
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x1110
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
addq $0x20, %r15
cmpq -0x38(%rbp), %r15
jne 0x1426
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x1483
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x1100
leaq -0x40(%rbp), %rdi
callq 0x1516
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14a1
jmp 0x14a1
jmp 0x14a1
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x14b9
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x1100
leaq -0x40(%rbp), %rdi
callq 0x1516
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/vividvilla[P]hackerrank/src/pairs.cpp
// Function: main
int main() {
    int N, K, x;
    cin >> N >> K;

    vector<int> v;
    for (int i = 0; i < N; i++) {
        cin >> x;
        v.push_back(x);
    }

    cout << getPairs(v, K) << endl;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2c17(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x1090
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1090
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, (%rbx)
jle 0x1447
xorl %ebp, %ebp
movq 0x2bde(%rip), %rbx      # 0x3fe0
leaq 0x4(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1090
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x1434
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x143f
movq %r15, %rdi
movq %r14, %rdx
callq 0x1702
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x140c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1518
movl 0x8(%rsp), %esi
leaq 0x30(%rsp), %rdi
callq 0x129c
movq 0x2b65(%rip), %rdi      # 0x3fd0
movl %eax, %esi
callq 0x1140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x14b3
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14ca
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14f5
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x14f8
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
jmp 0x14f8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x150f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::createFilePartialBWT()
int BCRexternalBWT::createFilePartialBWT() {
	//Creates one file (partial BWT) for each letter in the alphabet. From 1 to sizeAlpha-1
	static FILE *OutFileBWT;                  // output and input file BWT;
	char *filenameOut = new char[120];
	char *filename1 = new char[100];
	for (dataTypedimAlpha i = 0; i < sizeAlpha; i++) {
		sprintf (filename1, "bwt_%d", i);
		sprintf (filenameOut,"%s%s",filename1,ext);

		OutFileBWT = fopen(filenameOut, "wb");
		if (OutFileBWT==NULL) {
			std::cerr << "BWT file " << (unsigned int)i <<" : Error opening " << std::endl;
			exit (EXIT_FAILURE);
		}
		fclose(OutFileBWT);
	}
	delete [] filename1;
	delete [] filenameOut;



	//std::cerr << "\nPartial File name for input: " << fileOut <<" \n\n";
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x78, %edi
callq 0x3040
movq %rax, %rbx
movl $0x64, %edi
callq 0x3040
movq %rax, %r15
cmpb $0x0, 0x148(%r14)
je 0x6d51
leaq 0x5d66(%rip), %r12      # 0xca57
leaq 0x5e11(%rip), %r13      # 0xcb09
xorl %ebp, %ebp
movq %r15, %rdi
leaq 0x62c4(%rip), %rsi      # 0xcfc8
movl %ebp, %edx
xorl %eax, %eax
callq 0x3070
movq %rbx, %rdi
leaq 0x5ded(%rip), %rsi      # 0xcb04
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3070
movq %rbx, %rdi
movq %r13, %rsi
callq 0x32e0
movq %rax, 0xa5aa(%rip)      # 0x112e0
testq %rax, %rax
je 0x6d75
movq %rax, %rdi
callq 0x32a0
incl %ebp
movzbl 0x148(%r14), %eax
cmpl %eax, %ebp
jb 0x6cfa
movq %r15, %rdi
callq 0x3330
movq %rbx, %rdi
callq 0x3330
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa274(%rip), %rdi      # 0x10ff0
leaq 0x5ead(%rip), %rsi      # 0xcc30
callq 0x3290
movq %rax, %rdi
movl %ebp, %esi
callq 0x3350
leaq 0x5bc5(%rip), %rsi      # 0xc95e
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
callq 0x3140
movl $0x1, %edi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::openWriteFilePartialBWT_0()
FILE * BCRexternalBWT::openWriteFilePartialBWT_0( ) {
	static FILE *OutFileBWT;                  // output and input file BWT;
	char *filenameOut = new char[120];
	char *filename = new char[100];

	sprintf (filename, "bwt_%d",0);
	sprintf (filenameOut,"%s%s",filename,ext);

	OutFileBWT = fopen(filenameOut, "wb");
	if (OutFileBWT==NULL) {
		std::cerr << "BWT file $: Error opening: " << filenameOut << std::endl;
		exit (EXIT_FAILURE);
	}
	delete [] filenameOut;
	delete [] filename;

	return OutFileBWT;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x78, %edi
callq 0x3040
movq %rax, %rbx
movl $0x64, %edi
callq 0x3040
movq %rax, %r14
leaq 0x61ef(%rip), %rsi      # 0xcfc8
movq %rax, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3070
leaq 0x5d18(%rip), %rsi      # 0xcb04
leaq 0x5c64(%rip), %rcx      # 0xca57
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3070
leaq 0x5d02(%rip), %rsi      # 0xcb09
movq %rbx, %rdi
callq 0x32e0
movq %rax, 0xa4d2(%rip)      # 0x112e8
testq %rax, %rax
je 0x6e3a
movq %rbx, %rdi
callq 0x3330
movq %r14, %rdi
callq 0x3330
movq 0xa4b6(%rip), %rax      # 0x112e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa1af(%rip), %rdi      # 0x10ff0
leaq 0x613b(%rip), %rsi      # 0xcf83
callq 0x3290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3290
movq %rax, %rdi
callq 0x3140
movl $0x1, %edi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::openFilePartialIn(unsigned char)
FILE * BCRexternalBWT::openFilePartialIn(dataTypedimAlpha currentPile) {
	static FILE *inFile;
	char *filenameIn = new char[120];
	char *filename = new char[100];
	sprintf (filename, "bwt_%d", currentPile);
	sprintf (filenameIn,"%s%s",filename,ext);
	inFile = fopen(filenameIn, "rb");
	if (inFile==NULL) {
		std::cerr << "openFilePartialIn: file currentPile=" << (unsigned int)currentPile << ": Error opening: " << filenameIn << std::endl;
		exit (EXIT_FAILURE);
	}
	delete [] filenameIn;
	delete [] filename;
	return inFile;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl $0x78, %edi
callq 0x3040
movq %rax, %rbx
movl $0x64, %edi
callq 0x3040
movq %rax, %r14
leaq 0x6121(%rip), %rsi      # 0xcfc8
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3070
leaq 0x5c4a(%rip), %rsi      # 0xcb04
leaq 0x5b96(%rip), %rcx      # 0xca57
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3070
leaq 0x5a7e(%rip), %rsi      # 0xc953
movq %rbx, %rdi
callq 0x32e0
movq %rax, 0xa40c(%rip)      # 0x112f0
testq %rax, %rax
je 0x6f05
movq %rbx, %rdi
callq 0x3330
movq %r14, %rdi
callq 0x3330
movq 0xa3f0(%rip), %rax      # 0x112f0
popq %rbx
popq %r14
popq %rbp
retq
movq 0xa0e4(%rip), %rdi      # 0x10ff0
leaq 0x608c(%rip), %rsi      # 0xcf9f
callq 0x3290
movq %rax, %rdi
movl %ebp, %esi
callq 0x3350
leaq 0x6064(%rip), %rsi      # 0xcf8d
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3290
movq %rax, %rdi
callq 0x3140
movl $0x1, %edi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::openFilePartialOut(unsigned char)
FILE * BCRexternalBWT::openFilePartialOut(dataTypedimAlpha currentPile) {
	static FILE *outFile;
	char *filenameOut = new char[120];
	char *filename = new char[100];
	sprintf (filename, "new_bwt_%d", currentPile);
	sprintf (filenameOut,"%s%s",filename,ext);
	outFile = fopen(filenameOut, "ab");
	if (outFile==NULL) {
		std::cerr << "openFilePartialOut: file currentPile= " << (unsigned int)currentPile << ": Error opening: " << filenameOut << std::endl;
		exit (EXIT_FAILURE);
	}
	delete [] filenameOut;
	delete [] filename;
	return outFile;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl $0x78, %edi
callq 0x3040
movq %rax, %rbx
movl $0x64, %edi
callq 0x3040
movq %rax, %r14
leaq 0x603f(%rip), %rsi      # 0xcfc4
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3070
leaq 0x5b6c(%rip), %rsi      # 0xcb04
leaq 0x5ab8(%rip), %rcx      # 0xca57
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3070
leaq 0x601c(%rip), %rsi      # 0xcfcf
movq %rbx, %rdi
callq 0x32e0
movq %rax, 0xa336(%rip)      # 0x112f8
testq %rax, %rax
je 0x6fe3
movq %rbx, %rdi
callq 0x3330
movq %r14, %rdi
callq 0x3330
movq 0xa31a(%rip), %rax      # 0x112f8
popq %rbx
popq %r14
popq %rbp
retq
movq 0xa006(%rip), %rdi      # 0x10ff0
leaq 0x5fe1(%rip), %rsi      # 0xcfd2
callq 0x3290
movq %rax, %rdi
movl %ebp, %esi
callq 0x3350
leaq 0x5f86(%rip), %rsi      # 0xcf8d
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3290
movq %rax, %rdi
callq 0x3140
movl $0x1, %edi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::renameFilePartial(unsigned char)
int BCRexternalBWT::renameFilePartial(dataTypedimAlpha currentPile) {
	char *filenameOut = new char[120];
	char *filenameIn = new char[120];
	char *filename = new char[100];
	
	sprintf (filename, "bwt_%d", currentPile);
	sprintf (filenameIn,"%s%s",filename,ext);
	sprintf (filenameOut,"new_%s%s",filename,ext);
	//std::cerr << "Renaming - Filenames:" << filenameIn << "\t" <<filenameOut << std::endl;
	if (remove(filenameIn)!=0)
		std::cerr << filenameIn <<": Error deleting file" << std::endl;
	else
		if(rename(filenameOut,filenameIn))
			std::cerr << filenameOut <<": Error renaming " << std::endl;
	
	delete [] filenameIn;
	delete [] filename;
	delete [] filenameOut;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movl $0x78, %edi
callq 0x3040
movq %rax, %rbx
movl $0x78, %edi
callq 0x3040
movq %rax, %r14
movl $0x64, %edi
callq 0x3040
movq %rax, %r15
leaq 0x5f64(%rip), %rsi      # 0xcfc8
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3070
leaq 0x5a8d(%rip), %rsi      # 0xcb04
leaq 0x59d9(%rip), %r12      # 0xca57
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3070
leaq 0x5a6b(%rip), %rsi      # 0xcb00
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3070
movq %r14, %rdi
callq 0x3480
testl %eax, %eax
je 0x70dc
movq %r14, %rdi
callq 0x3120
movq 0x9f30(%rip), %r12      # 0x10ff0
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x32d0
leaq 0x5f24(%rip), %rsi      # 0xcff9
movl $0x15, %edx
jmp 0x7114
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3190
testl %eax, %eax
je 0x714b
movq %rbx, %rdi
callq 0x3120
movq 0x9ef6(%rip), %r12      # 0x10ff0
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x32d0
leaq 0x5f00(%rip), %rsi      # 0xd00f
movl $0x11, %edx
movq %r12, %rdi
callq 0x32d0
movq 0x9ecd(%rip), %r12      # 0x10ff0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r12, %rdi
callq 0x3050
movq %rax, %rdi
callq 0x31e0
movq %r14, %rdi
callq 0x3330
movq %r15, %rdi
callq 0x3330
movq %rbx, %rdi
callq 0x3330
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/Tools.cpp
// Function: Tools::MakeTable()
unsigned * Tools::MakeTable()
{
    unsigned *table = new unsigned[512];
    for(unsigned i = 0; i < 9; i++)
    {
        if (i == 0)
           table[i] = 0;
        if (i >= 1 && i < (1 << 1 )) 
           table[i] = 1;
        if (i >= (1 << 1 ) && i < (1 << 2 ))
           table[i] = 2;
        if (i >= (1 << 2 ) && i < (1 << 3 ))
           table[i] = 3;
        if (i >= (1 << 3 ) && i < (1 << 4 ))
           table[i] = 4;
        if (i >= (1 << 4 ) && i < (1 << 5 ))
           table[i] = 5;
        if (i >= (1 << 5 ) && i < (1 << 6 ))
           table[i] = 6;
        if (i >= (1 << 6 ) && i < (1 << 7 ))
           table[i] = 6;
        if (i >= (1 << 7 ) && i < (1 << 8 ))
           table[i] = 7;
        if (i >= (1 << 8 ) && i < (1 << 9 ))
           table[i] = 8;
    }
        return table;
}

// Assembly:
pushq %rax
movl $0x800, %edi            # imm = 0x800
callq 0x3040
xorl %ecx, %ecx
cmpl $0x1, %ecx
je 0x7af6
testl %ecx, %ecx
jne 0x7aff
movl $0x0, (%rax)
jmp 0x7b2d
movl $0x1, (%rax,%rcx,4)
jmp 0x7b2d
movl %ecx, %edx
andl $0xe, %edx
cmpl $0x2, %edx
jne 0x7b10
movl $0x2, (%rax,%rcx,4)
leal -0x2(%rcx), %edx
cmpl $0x2, %edx
jb 0x7b2d
cmpl $0x8, %ecx
jne 0x7b26
movl $0x4, 0x20(%rax)
jmp 0x7b2d
movl $0x3, (%rax,%rcx,4)
incq %rcx
cmpq $0x9, %rcx
jne 0x7ae5
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/Tools.cpp
// Function: Tools::FastFloorLog2(unsigned int)
unsigned Tools::FastFloorLog2(unsigned i)
{
    unsigned *table = MakeTable(); unsigned u;
    if (i >> 24)    u = 22 + table[ i >> 24] ;
    if (i >> 16)    u = 14 + table[ i >> 16] ;
    if (i >> 8)     u = 6 + table[ i >> 8] ;
    u =  table[i] - 1;
    delete [] table;
    return u;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x7ad8
movl %ebx, %ecx
movl (%rax,%rcx,4), %ebx
movq %rax, %rdi
callq 0x3330
decl %ebx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/Tools.cpp
// Function: Tools::GetFileContents(char*, unsigned long)
uchar * Tools::GetFileContents(char *filename, ulong maxSize)
{
    std::ifstream::pos_type posSize;
    std::ifstream file ((char *)filename, std::ios::in|std::ios::binary|std::ios::ate);
    if (file.is_open())
    {
        posSize = file.tellg();
        ulong size = posSize;
        if (maxSize != 0 && size > maxSize)
            size = maxSize;
        char *memblock = new char [size + 1];
        file.seekg (0, std::ios::beg);
        file.read (memblock, size);
        memblock[size] = '\0';
        file.close();
	return (uchar *)memblock;
    }
    else
        return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %rdi
movl $0xe, %edx
callq 0x3490
leaq 0x78(%rsp), %rdi
callq 0x3090
testb %al, %al
je 0x7c07
movq %rsp, %rdi
callq 0x3450
cmpq %rbx, %rax
movq %rbx, %r14
cmovbq %rax, %r14
testq %rbx, %rbx
cmoveq %rax, %r14
leaq 0x1(%r14), %rdi
callq 0x3040
movq %rax, %rbx
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3360
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3320
movb $0x0, (%rbx,%r14)
movq %rsp, %rdi
callq 0x3080
jmp 0x7c09
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0x7c21
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/giovannarosone[P]BCR_LCP_GSA/TransposeFasta.cpp
// Function: TransposeFasta::readln(char*, int, _IO_FILE*)
ulong TransposeFasta::readln(char* s, int n, FILE* iop) {

  register long c=0;
  register char* cs;
  register long z = 0; // count characters
  cs=s;
  while (--n > 0 && (c = getc(iop)) != EOF) {
	  //std::cerr << "n= " << n << " c= " << c << " ";
	  //printf ("%c\n", c);
	  if ((*cs++ = c) == '\n')
		break;
	z++;
  }
  if (c == EOF && z==0)
	  z = 0; // signify end of file
  *cs = '\0';
  return z;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpl $0x2, %edx
jl 0x98c3
movq %rcx, %r15
movl %edx, %r12d
movl %edx, %r13d
decq %r13
decl %r12d
xorl %eax, %eax
movq %rax, %r14
movq %r15, %rdi
callq 0x30c0
cmpl $-0x1, %eax
je 0x98c8
movb %al, (%rbx,%r14)
cmpb $0xa, %al
je 0x98cd
leaq 0x1(%r14), %rax
cmpq %rax, %r12
jne 0x98a0
jmp 0x98d0
xorl %r14d, %r14d
jmp 0x98d9
addq %r14, %rbx
jmp 0x98d9
movq %r14, %r13
addq %r14, %rbx
incq %rbx
movq %r13, %r14
movb $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: demo04::Screen::operator new(unsigned long)
void *Screen::operator new(size_t size)
{
	Screen *p;
	if (!freeStore) {
		//linked list 是空的，所以获取一大块memory
		//以下调用的是global operator new
		size_t chunk = screenChunk*size;
		freeStore = p = reinterpret_cast<Screen *>(new char[chunk]);
		//将分配得来的一大块memory，当做linked list将小块小块串联起来
		for (; p != &freeStore[screenChunk-1]; ++p) {
			p->next = p+1;
		}
		p->next = NULL;
	}
	p = freeStore;
	freeStore = freeStore->next;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x57dd(%rip), %rax      # 0x8168
testq %rax, %rax
jne 0x29c9
shlq $0x3, %rdi
leaq (%rdi,%rdi,2), %rdi
callq 0x2030
movq %rax, 0x57c4(%rip)      # 0x8168
movq %rax, %rcx
addq $0x10, %rcx
movl $0x170, %edx            # imm = 0x170
movq %rcx, -0x10(%rcx)
addq $0x10, %rcx
addq $-0x10, %rdx
jne 0x29b0
movq $0x0, 0x170(%rax)
movq (%rax), %rcx
movq %rcx, 0x5795(%rip)      # 0x8168
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: demo04::test_per_class_allocator_1()
void test_per_class_allocator_1()
{
	cout << "\ntest_per_class_allocator_1()................ \n";
	cout << sizeof(Screen) << endl;
	//pi 下N太大会造成crash
	size_t const N = 20;
	Screen *p[N];
	for (int i=0; i<N; ++i) {
		p[i] = new Screen(i);
	}
	
	//输出前10个pointers，用以比较其间隔
	for (int i=0; i<10; ++i) {
		cout << p[i] << endl;
	}
	//result: 间隔为8，中间没有cookie
		//0x114010
		//0x114018
		//0x114020
		//0x114028
		//0x114030
		//0x114038
		//0x114040
		//0x114048
		//0x114050
		//0x114058

	for (int i=0; i<N; ++i) {
		delete p[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq 0x55b4(%rip), %rbx      # 0x7fd0
leaq 0x26a8(%rip), %rsi      # 0x50cb
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x21a0
movl $0x10, %esi
movq %rbx, %rdi
callq 0x20c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
xorl %ebx, %ebx
movl $0x10, %edi
callq 0x2980
movl %ebx, 0x8(%rax)
movq %rax, -0xc0(%rbp,%rbx,8)
incq %rbx
cmpq $0x14, %rbx
jne 0x2a69
xorl %r15d, %r15d
movq 0x553f(%rip), %rbx      # 0x7fd0
movq -0xc0(%rbp,%r15,8), %rsi
movq %rbx, %rdi
callq 0x2100
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r15
cmpq $0xa, %r15
jne 0x2a91
movq 0x568d(%rip), %rcx      # 0x8168
xorl %eax, %eax
movq -0xc0(%rbp,%rax,8), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x5679(%rip)      # 0x8168
incq %rax
movq %rdx, %rcx
cmpq $0x14, %rax
jne 0x2add
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: demo05::AirPlane::operator delete(void*, unsigned long)
void AirPlane::operator delete(void *deadObject, size_t size)
{
	if (NULL == deadObject) { return; }

	if (size != sizeof(AirPlane)) {
		::operator delete(deadObject);
		return;
	}

	//插入headOfFreeList之前，回收内存
	AirPlane *plane = static_cast<AirPlane *>(deadObject);
	plane->next = headOfFreeList;
	headOfFreeList = plane;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2b7e
cmpq $0x10, %rsi
jne 0x2b80
movq 0x55fc(%rip), %rax      # 0x8170
movq %rax, (%rdi)
movq %rdi, 0x55f2(%rip)      # 0x8170
popq %rbp
retq
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: global_new_delete::test_global_new_delete()
void test_global_new_delete()
{
	Foo *foo = new Foo();
	delete foo;
	foo = NULL;

	Foo *arrayfoo = new Foo[10];
	delete []arrayfoo;
	arrayfoo = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %edi
callq 0x2180
movq %rax, %rbx
movq %rax, %rdi
callq 0x4254
movq %rbx, %rdi
callq 0x42b2
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2190
movl $0x12, %edi
callq 0x2030
movq %rax, %rbx
movq $0xa, (%rax)
leaq 0x8(%rax), %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x4254
decq %r15
incq %r14
cmpq $-0xa, %r15
jne 0x3729
movq (%rbx), %r14
testq %r14, %r14
je 0x375d
movq %rbx, %r15
addq $0x7, %r15
movq %r14, %r12
leaq (%r15,%r12), %rdi
callq 0x42b2
decq %r12
jne 0x374f
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2270
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2190
jmp 0x37b3
movq %rax, %r14
testq %r15, %r15
je 0x37a6
negq %r15
movq %rbx, %r12
addq $0x7, %r12
leaq (%r12,%r15), %rdi
callq 0x42b2
decq %r15
jne 0x3798
movl $0x12, %esi
movq %rbx, %rdi
callq 0x2270
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: ext_pool_allocator::test_pool_alloc()
void test_pool_alloc()
	{
		std::cout << sizeof(__gnu_cxx::__pool_alloc<int>) << std::endl;
		cookie_test(__gnu_cxx::__pool_alloc<double>(), 1);

		std::cout << sizeof(std::allocator<int>) << std::endl;
		cookie_test(std::allocator<double>(), 1);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x463b(%rip), %rbx      # 0x7fd0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x20c0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
leaq -0x12(%rbp), %rdi
movl $0x1, %esi
callq 0x4448
movl $0x1, %esi
movq %rbx, %rdi
callq 0x20c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
leaq -0x11(%rbp), %rdi
movl $0x1, %esi
callq 0x4594
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: void ext_pool_allocator::cookie_test<__gnu_cxx::__pool_alloc<double>>(__gnu_cxx::__pool_alloc<double>, unsigned long)
void cookie_test(Alloc alloc, size_t n)
	{
		typename Alloc::value_type *p1, *p2, *p3;

		p1 = alloc.allocate(n);
		p2 = alloc.allocate(n);
		p3 = alloc.allocate(n);

		std::cout << "p1=" << p1 << "\t" << "p2=" << p2 << "\t" << "p3=" << p3 << "\t" << std::endl;

		alloc.deallocate(p1, sizeof(typename Alloc::value_type));
		alloc.deallocate(p2, sizeof(typename Alloc::value_type));
		alloc.deallocate(p3, sizeof(typename Alloc::value_type));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorl %edx, %edx
callq 0x47d2
movq %rax, %r14
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x47d2
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x47d2
movq %rax, %r15
movq 0x3b3f(%rip), %r13      # 0x7fd0
leaq 0x103d(%rip), %rsi      # 0x54d5
movl $0x3, %edx
movq %r13, %rdi
callq 0x21a0
movq %r13, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %r14
leaq 0x101f(%rip), %r13      # 0x54d9
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
leaq 0x100a(%rip), %rsi      # 0x54db
movl $0x3, %edx
movq %r14, %rdi
callq 0x21a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2100
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
leaq 0xfdc(%rip), %rsi       # 0x54df
movl $0x3, %edx
movq %r14, %rdi
callq 0x21a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0x8, %edx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
callq 0x4920
movl $0x8, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4920
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4920
// File: /workspace/github_cpp_makefile_star2_O3/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: custom_allocator::allocator::alloc(unsigned long)
void *alloc(const size_t size)
	{
		object *p = NULL;
		if (NULL == freeHead) {
			p = freeHead = (object *)malloc(chunksize*size);
			for (int i=0; i<chunksize-1; ++i) {
				p->next = (object *)((char *)p+size);
				p = p->next;
			}
			p->next = NULL; //last
		}
		p = freeHead;
		freeHead = freeHead->next;
		return p;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x4721
movq %rsi, %r14
movslq (%rbx), %r15
movq %r15, %rdi
imulq %rsi, %rdi
callq 0x21e0
movq %rax, %rcx
cmpq $0x2, %r15
jl 0x471a
decl %r15d
movq %rax, %rdx
leaq (%rdx,%r14), %rcx
movq %rcx, (%rdx)
movq %rcx, %rdx
decl %r15d
jne 0x470b
movq $0x0, (%rcx)
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop