LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::set_dimension(unsigned long)
void Population::set_dimension(size_t const d) {
	if ((d>0)) {
		dimension = d;
	}
	else
		cerr << "Erreur: " << d << " n'est une dimension valable." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x502d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x506a
movq 0x8fbc(%rip), %rdi      # 0xdff0
leaq 0x50da(%rip), %rsi      # 0xa115
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x50e9(%rip), %rsi      # 0xa13f
callq 0x3250
movq %rax, %rdi
movq 0x8f5b(%rip), %rsi      # 0xdfc0
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::operator=(Population const&)
Population& Population::operator=(Population const& pop) {
	if (this != &pop ) {
        delete[] T;
        T = new Cellule[pop.alloc];
        generation = pop.generation;
        alive = pop.alive;
		alloc = pop.alloc;
        probability = pop.probability;
        dimension = pop.dimension;
        graine = pop.graine;
        speed = pop.speed;

        for(size_t j = 0; j < alive; ++j) {
            T[j] = pop.T[j];
        }
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq -0x10(%rbp), %rax
je 0x53fe
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x529c
movq -0x38(%rbp), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3040
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
cmpq $0x0, %rax
je 0x531c
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7100
jmp 0x5307
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x52f8
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movss 0x20(%rcx), %xmm0
movss %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x38(%rax)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x53fc
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rax), %rax
movq -0x28(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5383
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3440
jmp 0x5408
jmp 0x53fe
movq -0x30(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::init(unsigned long)
void Population::init(size_t g) {
	if (g == 0)
		graine = ( time(NULL) * getpid() );
	else
		graine = g;

	srand(graine);
	size_t i,j;
	size_t nb_a_faire_vivre = (size_t) (probability * dimension * dimension);
	for (size_t k = alive; k < nb_a_faire_vivre ; ++k) {
		do { // Chercher une cellule au hazard tant que cette cellule n'est pas déjà vivante
			i = rand() % dimension;
			j = rand() % dimension;
		} while (at(i,j) != NULL);
		// Une fois la cellule trouvé lui donné la vie
		birth(i,j);
	}
	update_color();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5468
xorl %eax, %eax
movl %eax, %edi
callq 0x3230
movq %rax, -0x40(%rbp)
callq 0x3390
movq -0x40(%rbp), %rcx
movl %eax, %edx
movq -0x38(%rbp), %rax
movslq %edx, %rdx
imulq %rdx, %rcx
movq %rcx, 0x30(%rax)
jmp 0x5474
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rax
movl 0x30(%rax), %edi
callq 0x3240
movq -0x38(%rbp), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movq 0x28(%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x48(%rbp)
testq %rax, %rax
movss %xmm0, -0x44(%rbp)
js 0x54c7
movss -0x48(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x38(%rbp), %rax
movss -0x4c(%rbp), %xmm0
movss -0x44(%rbp), %xmm1
mulss %xmm1, %xmm0
mulss %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttss2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movss 0x4b1c(%rip), %xmm1     # 0xa010
subss %xmm1, %xmm0
cvttss2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x557b
jmp 0x551b
callq 0x30c0
movq -0x38(%rbp), %rcx
cltq
xorl %edx, %edx
divq 0x28(%rcx)
movq %rdx, -0x18(%rbp)
callq 0x30c0
movq -0x38(%rbp), %rcx
cltq
xorl %edx, %edx
divq 0x28(%rcx)
movq %rdx, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x39b0
cmpq $0x0, %rax
jne 0x551b
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3ba0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x550f
movq -0x38(%rbp), %rdi
callq 0x3f80
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::next() const
Population Population::next() const {
	Couleur c;
  	Population POP(*this);
  	for (size_t i = 0 ; i < dimension ; i++) {
    	for (size_t j = 0 ; j < dimension ; j++) {
      		size_t voisin = nb_voisines(i,j);
      		if (POP.at(i,j) != NULL )
      			c = POP.at(i,j)->get_couleur();
      		else 
      			c = NOIR;
      		// Kill && Birth && age++
      		if ((c == ROUGE) || (c == JAUNE)) // Mettre en NOIR
      			POP.kill(i,j);
      		else if ((c == NOIR) && (voisin == 3)) // Mettre en Bleu
      			POP.birth(i,j); // La mise en JAUNE se feras à la fin avec l'appel de la fonction update_color()
      		else if ((c==VERT) || (c == BLEU))
      			POP.at(i,j)->age_pp();
    	}
  	}
  	POP.update_color();
  	POP.generation_pp();
  	return POP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x50a0
movq $0x0, -0x20(%rbp)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x571e
movq $0x0, -0x28(%rbp)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x570b
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x40f0
movq %rax, -0x60(%rbp)
jmp 0x560a
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x39b0
movq %rax, -0x68(%rbp)
jmp 0x5629
movq -0x68(%rbp), %rax
cmpq $0x0, %rax
je 0x567a
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x39b0
movq %rax, -0x70(%rbp)
jmp 0x564a
movq -0x70(%rbp), %rdi
callq 0x7290
movl %eax, -0x74(%rbp)
jmp 0x5658
movl -0x74(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5681
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x5230
jmp 0x5754
movl $0x0, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x568d
cmpl $0x3, -0x14(%rbp)
jne 0x56a2
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3a60
jmp 0x56a0
jmp 0x56f8
cmpl $0x0, -0x14(%rbp)
jne 0x56c4
cmpq $0x3, -0x30(%rbp)
jne 0x56c4
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3ba0
jmp 0x56c2
jmp 0x56f6
cmpl $0x2, -0x14(%rbp)
je 0x56d0
cmpl $0x4, -0x14(%rbp)
jne 0x56f4
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x39b0
movq %rax, -0x80(%rbp)
jmp 0x56e7
movq -0x80(%rbp), %rdi
callq 0x7460
jmp 0x56f2
jmp 0x56f4
jmp 0x56f6
jmp 0x56f8
jmp 0x56fa
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x55e1
jmp 0x570d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x55c7
movq -0x58(%rbp), %rdi
callq 0x3f80
jmp 0x5729
movq -0x58(%rbp), %rdi
callq 0x5760
jmp 0x5734
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x5747
movq -0x58(%rbp), %rdi
callq 0x5230
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::set_cell(unsigned long, unsigned long)
void Population::set_cell(size_t x,size_t y) {
	if (alive+1<dimension) {
		if ( (x <= dimension) && (y <= dimension) && (x >= 1) && (y >= 1)) {
			birth(x-1,y-1);
			/* affichage superful */
			cout << "Cell (" << x << "," << y<<") Est vivante"<< endl; 
		}
		else
			cerr << "Accessing a Cell at (" << x << "," << y << ") out of range..." << endl;
	} else 
		cerr << "Population pleine" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rcx), %rax
addq $0x1, %rax
cmpq 0x28(%rcx), %rax
jae 0x58ad
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x28(%rcx), %rax
ja 0x5853
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x28(%rcx), %rax
ja 0x5853
cmpq $0x1, -0x10(%rbp)
jb 0x5853
cmpq $0x1, -0x18(%rbp)
jb 0x5853
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x3ba0
movq 0x87d0(%rip), %rdi      # 0xdfd0
leaq 0x4956(%rip), %rsi      # 0xa15d
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x4baf(%rip), %rsi      # 0xa3d1
callq 0x3250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x4927(%rip), %rsi      # 0xa164
callq 0x3250
movq %rax, %rdi
movq 0x8774(%rip), %rsi      # 0xdfc0
callq 0x3270
jmp 0x58ab
movq 0x8796(%rip), %rdi      # 0xdff0
leaq 0x47d7(%rip), %rsi      # 0xa038
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x4b55(%rip), %rsi      # 0xa3d1
callq 0x3250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x47b7(%rip), %rsi      # 0xa04e
callq 0x3250
movq %rax, %rdi
movq 0x871a(%rip), %rsi      # 0xdfc0
callq 0x3270
jmp 0x58cf
movq 0x873c(%rip), %rdi      # 0xdff0
leaq 0x48b7(%rip), %rsi      # 0xa172
callq 0x3250
movq %rax, %rdi
movq 0x86f6(%rip), %rsi      # 0xdfc0
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::affiche_matrice() const
void Population::affiche_matrice() const {
	cout << "\t+";
		for (size_t k = 0; k < dimension; ++k)
			cout << "---+";
	cout << endl;
	for (size_t i = 0; i < dimension; ++i){
		cout << "\t|";
		for (size_t j = 0; j < dimension; ++j){
			if (at(i,j) != NULL)
				at(i,j)->print_cell();
			else 
				cout << "\033[3"<<(int)NOIR<<"m"<<"   "<< "\033[0m";
			cout << "|";
		}
		cout << endl;
		cout << "\t+";
		for (size_t k = 0; k < dimension; ++k)
			cout << "---+";
		
		cout << endl;
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8525(%rip), %rdi      # 0xdfd0
leaq 0x46d2(%rip), %rsi      # 0xa184
callq 0x3250
movq $0x0, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x5aee
movq 0x84fc(%rip), %rdi      # 0xdfd0
leaq 0x46ac(%rip), %rsi      # 0xa187
callq 0x3250
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5abf
movq 0x84db(%rip), %rdi      # 0xdfd0
movq 0x84c4(%rip), %rsi      # 0xdfc0
callq 0x3270
movq $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x5c69
movq 0x84ae(%rip), %rdi      # 0xdfd0
leaq 0x4663(%rip), %rsi      # 0xa18c
callq 0x3250
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x5be8
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3900
cmpq $0x0, %rax
je 0x5b7a
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3900
movq %rax, %rdi
callq 0x72c0
jmp 0x5bc4
movq 0x844f(%rip), %rdi      # 0xdfd0
leaq 0x4607(%rip), %rsi      # 0xa18f
callq 0x3250
movq %rax, %rdi
xorl %esi, %esi
callq 0x33e0
movq %rax, %rdi
leaq 0x45f9(%rip), %rsi      # 0xa19a
callq 0x3250
movq %rax, %rdi
leaq 0x45e3(%rip), %rsi      # 0xa193
callq 0x3250
movq %rax, %rdi
leaq 0x45d8(%rip), %rsi      # 0xa197
callq 0x3250
movq 0x8405(%rip), %rdi      # 0xdfd0
leaq 0x45bb(%rip), %rsi      # 0xa18d
callq 0x3250
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5b36
movq 0x83e1(%rip), %rdi      # 0xdfd0
movq 0x83ca(%rip), %rsi      # 0xdfc0
callq 0x3270
movq 0x83ce(%rip), %rdi      # 0xdfd0
leaq 0x457b(%rip), %rsi      # 0xa184
callq 0x3250
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x5c45
movq 0x83a5(%rip), %rdi      # 0xdfd0
leaq 0x4555(%rip), %rsi      # 0xa187
callq 0x3250
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5c16
movq 0x8384(%rip), %rdi      # 0xdfd0
movq 0x836d(%rip), %rsi      # 0xdfc0
callq 0x3270
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5b09
addq $0x30, %rsp
popq %rbp
retq
nop
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::get_cellule(unsigned long, unsigned long) const
Cellule Population::get_cellule(size_t i,size_t j) const {
	VERIFIER_EXISTANCE(i,j);
	const Cellule* ptr = at(i,j);
	if (ptr == NULL)
		return Cellule(false,i,j);
	else
		return *ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x5e8c
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x28(%rcx), %rax
jb 0x5eda
movq 0x813d(%rip), %rdi      # 0xdfd0
leaq 0x419e(%rip), %rsi      # 0xa038
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x451c(%rip), %rsi      # 0xa3d1
callq 0x3250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x417e(%rip), %rsi      # 0xa04e
callq 0x3250
callq 0x30d0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3900
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5f0b
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %esi, %esi
callq 0x70a0
jmp 0x5f31
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/cellule/cellule.cpp
// Function: couleur2string[abi:cxx11](Couleur)
string couleur2string(Couleur couleur) {
	switch(couleur) {
		case NOIR:
			return "NOIR";
			break;
		case ROUGE:
			return "ROUGE";
			break;
		case VERT:
			return "VERT";
			break;
		case JAUNE:
			return "JAUNE";
			break;
		case BLEU:
			return "BLEU";
			break;
		default:
			return "NON_DEFINIT";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x7040
movq -0x30(%rbp), %rax
leaq 0x35be(%rip), %rcx      # 0xa484
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xd(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3400
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x35ad(%rip), %rsi      # 0xa498
callq 0x6a60
jmp 0x6ef2
leaq -0xd(%rbp), %rdi
callq 0x3290
jmp 0x7085
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x3290
jmp 0x708f
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3400
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x3567(%rip), %rsi      # 0xa49d
callq 0x6a60
jmp 0x6f3d
leaq -0x1d(%rbp), %rdi
callq 0x3290
jmp 0x7085
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x3290
jmp 0x708f
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3400
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x3522(%rip), %rsi      # 0xa4a3
callq 0x6a60
jmp 0x6f88
leaq -0x1e(%rbp), %rdi
callq 0x3290
jmp 0x7085
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x3290
jmp 0x708f
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3400
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x34dc(%rip), %rsi      # 0xa4a8
callq 0x6a60
jmp 0x6fd3
leaq -0x1f(%rbp), %rdi
callq 0x3290
jmp 0x7085
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x3290
jmp 0x708f
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3400
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x3497(%rip), %rsi      # 0xa4ae
callq 0x6a60
jmp 0x701e
leaq -0x20(%rbp), %rdi
callq 0x3290
jmp 0x7085
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3290
jmp 0x708f
leaq -0x21(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3400
movq -0x40(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x3457(%rip), %rsi      # 0xa4b3
callq 0x6a60
jmp 0x7063
leaq -0x21(%rbp), %rdi
callq 0x3290
jmp 0x7085
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x3290
jmp 0x708f
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33f0
nopl (%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/cellule/cellule.cpp
// Function: Cellule::Cellule(bool, unsigned long, unsigned long)
Cellule::Cellule(bool b,size_t x,size_t y):x(x),y(y),age(0) {
	if (b)
		couleur = BLEU;
	else 
		couleur = NOIR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
testb $0x1, -0x9(%rbp)
je 0x70ea
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
jmp 0x70f4
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/cellule/cellule.cpp
// Function: Cellule::get_vivante() const
bool Cellule::get_vivante() const{
	if (couleur == NOIR)
		return false;
	else 
		return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x7147
movb $0x0, -0x1(%rbp)
jmp 0x714b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/cellule/cellule.cpp
// Function: Cellule::doit_mourir()
void Cellule::doit_mourir() {
	if (get_age() > 0)
		couleur = ROUGE;
	else 
		couleur = JAUNE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x72a0
cmpq $0x0, %rax
jbe 0x73ab
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x73b5
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/cellule/cellule.cpp
// Function: Cellule::set_vivante(bool)
void Cellule::set_vivante(bool b) {
	if (b)
		couleur = BLEU; // la gestion du JAUNE est implementé dans population.cpp (methode update_color())
	else {
		couleur = NOIR; // NOIR = Morte , age est remit à zero
		age = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x740a
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
jmp 0x741c
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x18(%rax)
popq %rbp
retq
nop
// File: massykezzoul[P]jeu-de-la-vie/configuration/configuration.cpp
// Function: get_chaine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
string get_chaine(string ligne,size_t i) {
	size_t debut,fin;
	debut = i;
	while(ligne[debut] == ' ')
		++debut;

	fin = ligne.find_first_of(" ",debut);
	return ligne.substr(debut,fin-debut);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3460
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x77be
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x779b
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x29c8(%rip), %rsi      # 0xa195
callq 0x3150
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
callq 0x3260
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: massykezzoul[P]jeu-de-la-vie/configuration/configuration.cpp
// Function: decode_cell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&, int&)
bool decode_cell(string valeur,int& x,int& y) {
	unsigned int i= 0;

	if (!isdigit(valeur[0]))
		return false;

	++i;

	while( (i<valeur.size() ) && (isdigit(valeur[i])))
		++i;
	
	x = convert(valeur.substr(0,i));

	if( (valeur[i] != 'X') && (valeur[i] != ',') && (valeur[i] != 'x') && (valeur[i] != ' '))
		return false;
	else {

		y = convert(valeur.substr(++i));

		if (y == -1)
			return false;
		else 
			return true;	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %edi
callq 0x3220
cmpl $0x0, %eax
jne 0x7ac1
movb $0x0, -0x1(%rbp)
jmp 0x7c66
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x80(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x90(%rbp)
callq 0x3190
movq -0x90(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x81(%rbp)
jae 0x7b16
movq -0x80(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %edi
callq 0x3220
cmpl $0x0, %eax
setne %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x7b22
jmp 0x7b2d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7aca
movq -0x80(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3260
movq -0xa0(%rbp), %rdi
callq 0x8160
movl %eax, -0x94(%rbp)
jmp 0x7b5e
movl -0x94(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x48(%rbp), %rdi
callq 0x3160
movq -0x80(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %eax
cmpl $0x58, %eax
je 0x7bee
movq -0x80(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x7bee
movq -0x80(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %eax
cmpl $0x78, %eax
je 0x7bee
movq -0x80(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x7bee
movb $0x0, -0x1(%rbp)
jmp 0x7c66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3160
jmp 0x7c74
movq -0x80(%rbp), %rsi
movl -0x24(%rbp), %eax
incl %eax
movl %eax, -0x24(%rbp)
movl %eax, %edx
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq $-0x1, %rcx
callq 0x3260
movq -0xb0(%rbp), %rdi
callq 0x8160
movl %eax, -0xa4(%rbp)
jmp 0x7c27
movl -0xa4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
leaq -0x78(%rbp), %rdi
callq 0x3160
movq -0x20(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x7c62
movb $0x0, -0x1(%rbp)
jmp 0x7c66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3160
jmp 0x7c74
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x24d2(%rip), %rsi      # 0xa4c9
callq 0x6e60
testb $0x1, %al
jne 0x8002
jmp 0x8033
movq -0x78(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x3100
movq %rax, %rdi
callq 0x3300
movq -0x90(%rbp), %rdi
cvtsd2ss %xmm0, %xmm0
callq 0x4f70
jmp 0x8146
movq -0x80(%rbp), %rdi
leaq 0x2497(%rip), %rsi      # 0xa4d5
callq 0x6e60
testb $0x1, %al
jne 0x8049
jmp 0x80bb
movq -0x78(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3110
movq -0xa0(%rbp), %rdi
callq 0x8160
movl %eax, -0x94(%rbp)
jmp 0x807c
movq -0xa8(%rbp), %rdi
movl -0x94(%rbp), %eax
movslq %eax, %rsi
callq 0x5000
jmp 0x8093
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x8144
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x814f
movq -0x80(%rbp), %rdi
leaq 0x2419(%rip), %rsi      # 0xa4df
callq 0x6e60
testb $0x1, %al
jne 0x80d1
jmp 0x8142
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3110
movq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x7a80
movb %al, -0xa9(%rbp)
jmp 0x8101
leaq -0x70(%rbp), %rdi
callq 0x3160
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x8116
jmp 0x8140
movq -0x8(%rbp), %rdi
movslq -0x48(%rbp), %rsi
movslq -0x4c(%rbp), %rdx
callq 0x5780
jmp 0x8140
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3160
jmp 0x814f
jmp 0x8142
jmp 0x8144
jmp 0x8146
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33f0
nopl (%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/configuration/convert/convert.cpp
// Function: convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int convert(string non_convertie){
	int i = non_convertie.size() -1;
	unsigned int j = 0;
	int r = 0;
	int tmp;

	while (j < non_convertie.size()){
		tmp = convert_char(non_convertie[j]);
		if (tmp == -1)
			return -1;
		else
			r = r + dix_puiss(i) * tmp;
		j++;
		i--;
	}
	return r;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3190
subq $0x1, %rax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x3190
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x8207
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %edi
callq 0x8220
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x81ce
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x820d
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %edi
callq 0x82c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movslq -0x20(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x818a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/configuration/convert/convert.cpp
// Function: convert_char(char)
int convert_char(char c) {
	switch (c) {
		case '0' : return 0;
		break;
		case '1' : return 1;
		break;
		case '2' : return 2;
		break;
		case '3' : return 3;
		break;
		case '4' : return 4;
		break;
		case '5' : return 5;
		break;
		case '6' : return 6;
		break;
		case '7' : return 7;
		break;
		case '8' : return 8;
		break;
		case '9' : return 9;
		break;
		default : return -1;
		break;
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x9, %eax
ja 0x82aa
movq -0x10(%rbp), %rax
leaq 0x22a1(%rip), %rcx      # 0xa4e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x82b1
movl $0x1, -0x4(%rbp)
jmp 0x82b1
movl $0x2, -0x4(%rbp)
jmp 0x82b1
movl $0x3, -0x4(%rbp)
jmp 0x82b1
movl $0x4, -0x4(%rbp)
jmp 0x82b1
movl $0x5, -0x4(%rbp)
jmp 0x82b1
movl $0x6, -0x4(%rbp)
jmp 0x82b1
movl $0x7, -0x4(%rbp)
jmp 0x82b1
movl $0x8, -0x4(%rbp)
jmp 0x82b1
movl $0x9, -0x4(%rbp)
jmp 0x82b1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x82db
movq $-0x1, -0x8(%rbp)
jmp 0x82fe
cmpl $0x0, -0xc(%rbp)
jne 0x82eb
movq $0x1, -0x8(%rbp)
jmp 0x82fe
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x82c0
imulq $0xa, %rax, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0xa, -0x10(%rbp)
jae 0x832c
movl $0x1, -0x4(%rbp)
jmp 0x8348
movq -0x10(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
callq 0x8310
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
movl $0x8, %edx
callq 0x33d0
movq -0x1b0(%rbp), %rdi
leaq 0xe8(%rip), %rsi        # 0x8480
callq 0x33c0
movq %rax, -0x1a8(%rbp)
jmp 0x83a6
movq -0x1a8(%rbp), %rdi
leaq -0x18c(%rbp), %rsi
callq 0x3080
jmp 0x83bb
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x188(%rbp,%rax), %rdi
callq 0x3430
movb %al, -0x1b1(%rbp)
jmp 0x83db
movb -0x1b1(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1b2(%rbp)
jne 0x83f0
jmp 0x841e
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x188(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x1b3(%rbp)
jmp 0x8410
movb -0x1b3(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1b2(%rbp)
movb -0x1b2(%rbp), %al
movb %al, -0x1b4(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3140
movb -0x1b4(%rbp), %al
andb $0x1, %al
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3140
movq -0x198(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option::Option(Option const&)
Option::Option(Option const &copy) {
		identifiant = copy.get_identifiant();
		nom = (copy.get_nom());
		racourci = (copy.get_racourci());
		argument = (copy.get_argument());
		description = (copy.get_description());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x3350
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x70(%rbp)
callq 0x3350
movq -0x10(%rbp), %rdi
callq 0x8730
movl %eax, -0x64(%rbp)
jmp 0x8657
movq -0x78(%rbp), %rax
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8740
jmp 0x866f
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0x32e0
movq -0x90(%rbp), %rdi
callq 0x3160
movq -0x10(%rbp), %rdi
callq 0x8770
movb %al, -0x81(%rbp)
jmp 0x86a4
movq -0x78(%rbp), %rax
movb -0x81(%rbp), %cl
movb %cl, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x8790
movl %eax, -0x94(%rbp)
jmp 0x86c2
movq -0x78(%rbp), %rax
movl -0x94(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x87b0
jmp 0x86de
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
leaq -0x60(%rbp), %rsi
callq 0x32e0
leaq -0x60(%rbp), %rdi
callq 0x3160
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3160
movq -0x80(%rbp), %rdi
callq 0x3160
movq -0x18(%rbp), %rdi
callq 0x33f0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x57d5(%rip), %rdi      # 0xdfd0
leaq 0x1d0e(%rip), %rsi      # 0xa510
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x33e0
movq %rax, %rdi
movq 0x57a1(%rip), %rsi      # 0xdfc0
callq 0x3270
movq %rax, %rdi
leaq 0x1cf1(%rip), %rsi      # 0xa51f
callq 0x3250
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x3210
movq %rax, %rdi
movq 0x5773(%rip), %rsi      # 0xdfc0
callq 0x3270
movq %rax, %rdi
leaq 0x1cca(%rip), %rsi      # 0xa526
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rax
movsbl 0x28(%rax), %esi
callq 0x32c0
movq %rax, %rdi
movq 0x5745(%rip), %rsi      # 0xdfc0
callq 0x3270
movq %rax, %rdi
leaq 0x1ca8(%rip), %rsi      # 0xa532
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x33e0
movq %rax, %rdi
movq 0x5718(%rip), %rsi      # 0xdfc0
callq 0x3270
movq %rax, %rdi
leaq 0x1c8f(%rip), %rsi      # 0xa546
callq 0x3250
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0x3210
movq %rax, %rdi
movq 0x56ea(%rip), %rsi      # 0xdfc0
callq 0x3270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq -0x18(%rbp), %rax
je 0x8a64
movq -0x18(%rbp), %rdi
callq 0x8730
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8740
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x32e0
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x18(%rbp), %rdi
callq 0x8770
movb %al, %cl
movq -0x60(%rbp), %rax
movb %cl, 0x28(%rax)
movq -0x18(%rbp), %rdi
callq 0x8790
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x87b0
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
leaq -0x58(%rbp), %rsi
callq 0x32e0
leaq -0x58(%rbp), %rdi
callq 0x3160
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x8610
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8730
movq -0x68(%rbp), %rdi
movl %eax, %esi
callq 0x93e0
cmpl $-0x1, %eax
jne 0x93a9
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rdx
movq %rax, %rsi
addq $0x8, %rsi
imulq $0x50, (%rax), %rax
addq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x89b0
leaq -0x60(%rbp), %rdi
callq 0x6b90
movq -0x68(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x93da
movq 0x4c40(%rip), %rdi      # 0xdff0
leaq 0x12e5(%rip), %rsi      # 0xa69c
callq 0x3250
movq %rax, %rdi
movq 0x4bfa(%rip), %rsi      # 0xdfc0
callq 0x3270
movq %rax, %rdi
movq 0x4beb(%rip), %rsi      # 0xdfc0
callq 0x3270
addq $0x70, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jae 0x943b
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8730
cmpl -0x14(%rbp), %eax
jne 0x9430
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9453
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x93fe
movq -0x20(%rbp), %rcx
movslq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jne 0x9451
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9453
ud2
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rcx
movslq -0x1c(%rbp), %rax
cmpq (%rcx), %rax
jae 0x9564
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
movslq -0x1c(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x8740
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9980
movb %al, -0x49(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3160
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x953a
jmp 0x9557
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8730
movl %eax, -0x4(%rbp)
jmp 0x956b
jmp 0x9559
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x94ef
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jae 0x95fb
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8770
movsbl %al, %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x95ee
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8730
movl %eax, -0x4(%rbp)
jmp 0x9602
jmp 0x95f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x95a1
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::is_nom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Option_tab::is_nom(std::string arg) const {
	if ((arg[0] == '-') && (arg[1] == '-') && (cherche(&arg[2]) != Option::NB_ID) )
		return true;
	else 
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %ecx
movb $0x0, -0x3a(%rbp)
movb $0x0, -0x4d(%rbp)
xorl %eax, %eax
cmpl $0x2d, %ecx
movb %al, -0x4e(%rbp)
jne 0x96cb
movq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x3460
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2d, %ecx
movb %al, -0x4e(%rbp)
jne 0x96cb
movq -0x60(%rbp), %rdi
movl $0x2, %esi
callq 0x3460
movq %rax, -0x78(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3400
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movb $0x1, -0x3a(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6a60
jmp 0x96a9
movq -0x58(%rbp), %rdi
movb $0x1, -0x4d(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x94d0
movl %eax, -0x7c(%rbp)
jmp 0x96bf
movl -0x7c(%rbp), %eax
cmpl $0x6, %eax
setne %al
movb %al, -0x4e(%rbp)
movb -0x4e(%rbp), %al
movb %al, -0x7d(%rbp)
testb $0x1, -0x4d(%rbp)
jne 0x96d9
jmp 0x96e2
leaq -0x38(%rbp), %rdi
callq 0x3160
testb $0x1, -0x3a(%rbp)
jne 0x96ea
jmp 0x96f3
leaq -0x39(%rbp), %rdi
callq 0x3290
movb -0x7d(%rbp), %al
testb $0x1, %al
jne 0x96fc
jmp 0x9742
movb $0x1, -0x1(%rbp)
jmp 0x9746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x972f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x4d(%rbp)
jne 0x9724
jmp 0x972d
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x972f
testb $0x1, -0x3a(%rbp)
jne 0x9737
jmp 0x9740
leaq -0x39(%rbp), %rdi
callq 0x3290
jmp 0x9754
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::is_raccourci(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Option_tab::is_raccourci(std::string arg) const {
	if ((arg[0] == '-') && (cherche(arg[1]) != Option::NB_ID) )
		return true;
	else 
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3460
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x97bd
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x3460
movq -0x20(%rbp), %rdi
movsbl (%rax), %esi
callq 0x9580
cmpl $0x6, %eax
je 0x97bd
movb $0x1, -0x1(%rbp)
jmp 0x97c1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rcx
movslq -0x1c(%rbp), %rax
cmpq (%rcx), %rax
jae 0x9864
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
movslq -0x1c(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x8740
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9980
movb %al, -0x49(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3160
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x983a
jmp 0x9857
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8790
movl %eax, -0x4(%rbp)
jmp 0x986b
jmp 0x9859
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x97ef
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jae 0x98f2
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8730
cmpl -0x14(%rbp), %eax
jne 0x98e5
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8790
movl %eax, -0x4(%rbp)
jmp 0x98f9
jmp 0x98e7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x989e
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/option/option.cpp
// Function: Option_tab::get_option(int)
Option const &Option_tab::get_option(int index) {
	if ((index >= 0) && (index < nb))
		return tab[index];
	else 
		std::cerr << "L'option n'a pas été trouvé" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x9953
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq (%rcx), %rax
jae 0x9953
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0xc(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
movq 0x4696(%rip), %rdi      # 0xdff0
leaq 0xd68(%rip), %rsi       # 0xa6c9
callq 0x3250
movq %rax, %rdi
movq 0x4650(%rip), %rsi      # 0xdfc0
callq 0x3270
ud2
nopw (%rax,%rax)