LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::est_egal(Population const&) const
bool Population::est_egal(Population const& pop) const {
	size_t k = 0;
	if (alive == pop.get_vivante()) {
		while ((k < alive) && 
			(T[k].get_x() == pop.get_cellule(k).get_x() ) && 
			(T[k].get_y() == pop.get_cellule(k).get_y() ) && 
			(T[k].get_couleur() == pop.get_cellule(k).get_couleur())) 
				++k;
		return (k == alive);  
	} else {
		return false;
	}
}

// Assembly:
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x2606
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
leaq 0x40(%rsp), %r15
xorl %r12d, %r12d
cmpq %rax, %r12
jae 0x25f0
movq (%rbx), %rdi
addq %r13, %rdi
callq 0x44ac
movq %rax, %rbp
movq (%r14), %rax
movups (%rax,%r13), %xmm0
movups 0x10(%rax,%r13), %xmm1
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movq %r15, %rdi
callq 0x44ac
cmpq %rax, %rbp
jne 0x25f0
movq (%rbx), %rdi
addq %r13, %rdi
callq 0x44b2
movq %rax, %rbp
movq (%r14), %rax
movups (%rax,%r13), %xmm0
movups 0x10(%rax,%r13), %xmm1
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x44b2
cmpq %rax, %rbp
jne 0x25f0
movq (%rbx), %rdi
addq %r13, %rdi
callq 0x44b8
movl %eax, %ebp
movq (%r14), %rax
movups (%rax,%r13), %xmm0
movups 0x10(%rax,%r13), %xmm1
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
movq %rsp, %rdi
callq 0x44b8
cmpl %eax, %ebp
jne 0x25f0
incq %r12
movq 0x10(%rbx), %rax
addq $0x20, %r13
jmp 0x253f
cmpq %r12, 0x10(%rbx)
sete %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::at(unsigned long, unsigned long) const
const Cellule* Population::at(size_t i, size_t j) const {
  for (size_t k = 0 ; k < alive ; k++) {
    if ((T[k].get_x() == i) && (T[k].get_y() == j)) {
      return T+k;
    }
  }
  return NULL; /* La cellule n'existe pas dans le tableau */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq 0x10(%r14), %rbp
jae 0x2664
movq (%r14), %rdi
addq %r13, %rdi
callq 0x44ac
cmpq %r12, %rax
jne 0x2655
movq (%r14), %rdi
addq %r13, %rdi
callq 0x44b2
cmpq %r15, %rax
je 0x265e
incq %rbp
addq $0x20, %r13
jmp 0x262f
addq (%r14), %r13
movq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::at(unsigned long, unsigned long)
Cellule* Population::at(size_t i, size_t j)  {
  for (size_t k = 0 ; k < alive ; k++) {
    if ((T[k].get_x() == i) && (T[k].get_y() == j)) {
      return T+k;
    }
  }
  return NULL; /* La cellule n'existe pas dans le tableau */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq 0x10(%r14), %rbp
jae 0x26c6
movq (%r14), %rdi
addq %r13, %rdi
callq 0x44ac
cmpq %r12, %rax
jne 0x26b7
movq (%r14), %rdi
addq %r13, %rdi
callq 0x44b2
cmpq %r15, %rax
je 0x26c0
incq %rbp
addq $0x20, %r13
jmp 0x2691
addq (%r14), %r13
movq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::kill(unsigned long, unsigned long)
void Population::kill(size_t i,size_t j) {
	VERIFIER_EXISTANCE(i,j);
	Cellule* ptr=at(i,j);
	if (ptr!=NULL) {
    	size_t k=ptr-T; // retrouve la position de la cellule dans le tableau
		for ( ; k < alive - 1 ; k++) {
			T[k]=T[k+1]; // Decale la position des cellules
		}
		alive--;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x28(%rdi), %rax
cmpq %rsi, %rax
jbe 0x2743
cmpq %r14, %rax
jbe 0x2743
movq %rdi, %rbx
movq %r15, %rsi
movq %r14, %rdx
callq 0x2676
testq %rax, %rax
je 0x273d
subq (%rbx), %rax
movq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %rax
movq 0x10(%rbx), %rdx
decq %rdx
cmpq %rdx, %rcx
jae 0x2739
movq (%rbx), %rdx
incq %rcx
movups (%rdx,%rax), %xmm0
movups 0x10(%rdx,%rax), %xmm1
movups %xmm1, -0x10(%rdx,%rax)
movups %xmm0, -0x20(%rdx,%rax)
jmp 0x270e
movq %rdx, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x7886(%rip), %rdi      # 0x9fd0
leaq 0x38df(%rip), %rsi      # 0x6030
callq 0x21d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
leaq 0x3c61(%rip), %rsi      # 0x63c9
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x38c4(%rip), %rsi      # 0x6046
movq %rax, %rdi
callq 0x21d0
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::birth(unsigned long, unsigned long)
void Population::birth(size_t i,size_t j) {
	if (alive+1< dimension * dimension){
		VERIFIER_EXISTANCE(i,j);
		Cellule* ptr=at(i,j);
		if (ptr==NULL) {
			//la cellule n'existe pas dans le tableau
			push_back(Cellule(true,i,j));
		}
		else{
			// La cellule existe dans le tableau
			ptr->set_vivante(true);
		}
  	}
 	else {
		cerr<<"Population: Erreur -> trop de cellule vivante pour une dimension de ="<<dimension<<endl;
		cerr<<"aborting...\n";
		terminate();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rax
incq %rcx
movq %rax, %rdx
imulq %rax, %rdx
cmpq %rdx, %rcx
jae 0x2859
movq %rsi, %r15
cmpq %rsi, %rax
jbe 0x288f
cmpq %r14, %rax
jbe 0x288f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2676
testq %rax, %rax
je 0x27fa
pushq $0x1
popq %rsi
movq %rax, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4560
leaq 0x28(%rsp), %r12
pushq $0x1
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x444e
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2950
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
shlq $0x5, %rcx
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
incq 0x10(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x7790(%rip), %r14      # 0x9ff0
leaq 0x37f1(%rip), %rsi      # 0x6058
movq %r14, %rdi
callq 0x21d0
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x2060
movq %rax, %rdi
callq 0x2100
leaq 0x3814(%rip), %rsi      # 0x609e
movq %r14, %rdi
jmp 0x28d1
movq 0x773a(%rip), %rdi      # 0x9fd0
leaq 0x3793(%rip), %rsi      # 0x6030
callq 0x21d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
leaq 0x3b15(%rip), %rsi      # 0x63c9
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x3778(%rip), %rsi      # 0x6046
movq %rax, %rdi
callq 0x21d0
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::nb_cellule(Couleur) const
size_t Population::nb_cellule(Couleur c) const {
	size_t cpt=0;
  for (size_t i = 0 ; i < alive ; i++) {
      if (CelluleEstDeLaCouleur(T[i],c)) {
		cpt++;
      }    
  }
  return cpt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq 0x10(%r14), %r13
jae 0x2943
movq (%r14), %rdi
addq %r12, %rdi
movl %ebx, %esi
callq 0x4589
movzbl %al, %eax
addq %rax, %r15
incq %r13
addq $0x20, %r12
jmp 0x2921
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::extend()
void Population::extend() {
	if (alive >= alloc){
		alloc *= 2;
		Cellule* tmp = new Cellule[alloc];
		for(size_t i = 0; i < alive; i++) {
			tmp[i] = T[i];
		}
		delete[] T;
		T = tmp;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %r13
cmpq %r13, %r12
jb 0x29ed
movq %rdi, %rbx
leaq (,%r13,2), %rbp
movq %rbp, 0x18(%rdi)
movq %rbp, %rax
shrq $0x3b, %rax
shlq $0x6, %r13
xorl %r15d, %r15d
negq %rax
sbbq %r15, %r15
orq %r13, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r14
testq %rbp, %rbp
je 0x29bb
xorl %r12d, %r12d
leaq (%r14,%r12), %rdi
callq 0x4462
addq $0x20, %r12
cmpq %r12, %r13
jne 0x29a5
movq 0x10(%rbx), %r12
movq (%rbx), %rdi
xorl %eax, %eax
subq $0x1, %r12
jb 0x29e0
movups (%rdi,%rax), %xmm0
movups 0x10(%rdi,%rax), %xmm1
movups %xmm1, 0x10(%r14,%rax)
movups %xmm0, (%r14,%rax)
addq $0x20, %rax
jmp 0x29c0
testq %rdi, %rdi
je 0x29ea
callq 0x2230
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2300
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::update_color()
void Population::update_color() {
	for (size_t k = 0; k < alive; ++k){
		int voisines = nb_voisines(T[k].get_x(),T[k].get_y());
		Couleur c = T[k].get_couleur();
		if(T[k].get_vivante()) {
			if (c == BLEU) {
				//La cellule vient de naitre 
				if ((voisines != 2) && 	(voisines != 3))
					T[k].set_color(JAUNE); // meurent au prochain tour
				else if ((T[k].get_age() > 0)) {
					T[k].set_color(VERT); // Age > 0
				}
			} else if ( (c == VERT) && (voisines != 2) && (voisines != 3) ) {
				//Meurent au prochain tour 
				T[k].set_color(ROUGE);
			}
		}
	}				
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x1
popq %r15
xorl %ebp, %ebp
cmpq 0x10(%rbx), %rbp
jae 0x2ad5
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x44ac
movq %rax, %r12
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x44b2
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2ae4
movq %rax, %r12
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x44b8
movl %eax, %r13d
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x4472
testb %al, %al
je 0x2ac9
cmpl $0x4, %r13d
jne 0x2a96
addl $-0x4, %r12d
movq (%rbx), %rdi
addq %r14, %rdi
cmpl $-0x3, %r12d
ja 0x2ab1
pushq $0x3
jmp 0x2ac3
cmpl $0x2, %r13d
jne 0x2ac9
addl $-0x4, %r12d
cmpl $-0x3, %r12d
ja 0x2ac9
movq (%rbx), %rdi
addq %r14, %rdi
movl %r15d, %esi
jmp 0x2ac4
callq 0x44bc
testq %rax, %rax
je 0x2ac9
movq (%rbx), %rdi
addq %r14, %rdi
pushq $0x2
popq %rsi
callq 0x4586
incq %rbp
addq $0x20, %r14
jmp 0x2a2b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::nb_voisines(unsigned long, unsigned long) const
size_t Population::nb_voisines(size_t i,size_t j) const {
	size_t nb = 0;
	size_t m_min = i==0?i:i-1;
	size_t m_max = i==(dimension-1) ?i:i+1;
	size_t n_min = j==0?j:j-1;;
	size_t n_max = j==(dimension-1) ?j:j+1;
		for (size_t m = m_min; m <= m_max; ++m){
			for (size_t k = n_min; k <= n_max; ++k){
				if ( ( at(m,k) != NULL ) && ( (i!=m) || (j!=k))) {
					nb++;
				}
			}
		}
	return nb;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %r15d, %r15d
movq %rsi, %rbx
subq $0x1, %rbx
cmovbq %r15, %rbx
movq %rdi, 0x18(%rsp)
movq 0x28(%rdi), %rax
decq %rax
xorl %ecx, %ecx
cmpq %rsi, %rax
setne %cl
movq %rsi, 0x20(%rsp)
addq %rsi, %rcx
movq %rcx, 0x10(%rsp)
xorl %ebp, %ebp
cmpq %rdx, %rax
setne %bpl
addq %rdx, %rbp
cmpq $0x1, %rdx
pushq $0x1
popq %rax
movq %rdx, %r13
cmovbq %rdx, %rax
negq %rax
movq %rax, 0x8(%rsp)
cmpq 0x10(%rsp), %rbx
ja 0x2b8b
movq 0x8(%rsp), %r14
leaq (%r14,%r13), %rdx
cmpq %rbp, %rdx
ja 0x2b86
movq %rbx, %r12
xorq 0x20(%rsp), %r12
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2614
testq %rax, %rax
setne %al
orq %r14, %r12
setne %cl
andb %al, %cl
movzbl %cl, %eax
addq %rax, %r15
incq %r14
jmp 0x2b4f
incq %rbx
jmp 0x2b43
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::set_probability(float)
void Population::set_probability(float const p) {
	if ((p <= 1) && (p >= 0)){
		probability = p;
	} else 
		cerr << "Erreur: " << p << " n'est une probabilité valable." << endl;
}

// Assembly:
movss 0x2ddc(%rip), %xmm1     # 0x6008
ucomiss %xmm0, %xmm1
jb 0x323f
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x323f
movss %xmm0, 0x20(%rdi)
retq
pushq %rax
movq 0x6da9(%rip), %rdi      # 0x9ff0
leaq 0x2ebf(%rip), %rsi      # 0x610d
movss %xmm0, 0x4(%rsp)
callq 0x21d0
movq %rax, %rdi
movss 0x4(%rsp), %xmm0
callq 0x2160
leaq 0x2ea8(%rip), %rsi      # 0x6116
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
popq %rax
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x328a
movq %rsi, 0x28(%rdi)
retq
pushq %rax
movq 0x6d5e(%rip), %rdi      # 0x9ff0
leaq 0x2e74(%rip), %rsi      # 0x610d
callq 0x21d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x2130
leaq 0x2e88(%rip), %rsi      # 0x6137
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
popq %rax
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x348a
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x33df
callq 0x2230
movq 0x18(%r14), %rbp
movq %rbp, %rax
shrq $0x3b, %rax
movq %rbp, %r13
shlq $0x5, %r13
negq %rax
movl $0x0, %r15d
sbbq %r15, %r15
orq %r13, %r15
movq %r15, %rdi
callq 0x2030
xorl %edx, %edx
movq %rax, %r12
testq %rbp, %rbp
je 0x342a
xorl %ebp, %ebp
leaq (%r12,%rbp), %rdi
callq 0x4462
addq $0x20, %rbp
cmpq %rbp, %r13
jne 0x3414
movq 0x18(%r14), %rdx
movq %r12, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movss 0x20(%r14), %xmm0
movss %xmm0, 0x20(%rbx)
movups 0x28(%r14), %xmm0
movups %xmm0, 0x28(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
xorl %eax, %eax
xorl %edx, %edx
cmpq %rcx, %rdx
jae 0x348a
movq (%r14), %rcx
movq (%rbx), %rsi
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movups %xmm1, 0x10(%rsi,%rax)
movups %xmm0, (%rsi,%rax)
incq %rdx
movq 0x10(%rbx), %rcx
addq $0x20, %rax
jmp 0x3460
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2300
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x34d9
xorl %edi, %edi
callq 0x21b0
movq %rax, %r14
callq 0x2280
movslq %eax, %rsi
imulq %r14, %rsi
movq %rsi, 0x30(%rbx)
movl %esi, %edi
callq 0x21c0
movq 0x28(%rbx), %rax
testq %rax, %rax
js 0x34f4
cvtsi2ss %rax, %xmm0
jmp 0x3509
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movq 0x10(%rbx), %r12
movss 0x20(%rbx), %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x2ade(%rip), %xmm1     # 0x600c
cvttss2si %xmm1, %r13
andq %rcx, %r13
orq %rax, %r13
cmpq %r13, %r12
jae 0x3581
callq 0x2080
cltq
xorl %edx, %edx
divq 0x28(%rbx)
movq %rdx, %r14
callq 0x2080
cltq
xorl %edx, %edx
divq 0x28(%rbx)
movq %rdx, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2676
testq %rax, %rax
jne 0x353e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2790
incq %r12
jmp 0x3539
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a14
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x32c8
movq 0x28(%r14), %rax
xorl %r15d, %r15d
cmpq %rax, %r15
jae 0x366c
xorl %r12d, %r12d
cmpq %rax, %r12
jae 0x3664
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2ae4
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2676
testq %rax, %rax
je 0x3616
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2676
movq %rax, %rdi
callq 0x44b8
movl %eax, %ecx
andl $-0x3, %ecx
cmpl $0x1, %ecx
jne 0x3618
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x26d8
jmp 0x3658
xorl %eax, %eax
testl %eax, %eax
setne %cl
cmpq $0x3, %r13
setne %dl
orb %cl, %dl
jne 0x3638
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2790
jmp 0x3658
cmpl $0x4, %eax
je 0x3642
cmpl $0x2, %eax
jne 0x3658
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2676
movq %rax, %rdi
callq 0x4580
incq %r12
movq 0x28(%r14), %rax
jmp 0x35b9
incq %r15
jmp 0x35ad
movq %rbx, %rdi
callq 0x2a14
incq 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3687
movq %rax, %r14
movq %rbx, %rdi
callq 0x33aa
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rax
incq %rcx
cmpq %rax, %rcx
jae 0x371d
movq %rdx, %rbx
movq %rsi, %r14
cmpq %rsi, %rax
jb 0x372d
testq %r14, %r14
sete %cl
leaq -0x1(%rbx), %rdx
cmpq %rax, %rdx
setae %al
orb %cl, %al
jne 0x372d
leaq -0x1(%r14), %rsi
callq 0x2790
movq 0x68ed(%rip), %rdi      # 0x9fd0
leaq 0x2a6b(%rip), %rsi      # 0x6155
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
leaq 0x2cc8(%rip), %rsi      # 0x63c9
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
leaq 0x2a41(%rip), %rsi      # 0x615c
jmp 0x376c
movq 0x68cc(%rip), %rdi      # 0x9ff0
leaq 0x2a3f(%rip), %rsi      # 0x616a
jmp 0x376f
movq 0x68bc(%rip), %rdi      # 0x9ff0
leaq 0x28f5(%rip), %rsi      # 0x6030
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
leaq 0x2c77(%rip), %rsi      # 0x63c9
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
leaq 0x28da(%rip), %rsi      # 0x6046
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x679b(%rip), %r14      # 0x9fd0
leaq 0x2940(%rip), %rsi      # 0x617c
movq %r14, %rdi
callq 0x21d0
xorl %r12d, %r12d
leaq 0x2931(%rip), %r15      # 0x617f
cmpq 0x28(%rbx), %r12
jae 0x3864
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
incq %r12
jmp 0x384e
movq 0x6765(%rip), %r14      # 0x9fd0
movq %r14, %rdi
callq 0x2100
xorl %r15d, %r15d
leaq 0x2908(%rip), %rbp      # 0x6185
leaq 0x28fb(%rip), %r12      # 0x617f
cmpq 0x28(%rbx), %r15
jae 0x396e
movq %r14, %rdi
leaq 0x28ec(%rip), %rsi      # 0x6184
callq 0x21d0
xorl %r13d, %r13d
cmpq 0x28(%rbx), %r13
jae 0x392e
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2614
testq %rax, %rax
je 0x38d5
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2614
movq %rax, %rdi
callq 0x44c2
jmp 0x391b
movq %r14, %rdi
leaq 0x28a8(%rip), %rsi      # 0x6187
callq 0x21d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x22b0
movq %rax, %rdi
leaq 0x289a(%rip), %rsi      # 0x6192
callq 0x21d0
movq %rax, %rdi
leaq 0x2884(%rip), %rsi      # 0x618b
callq 0x21d0
movq %rax, %rdi
leaq 0x2879(%rip), %rsi      # 0x618f
callq 0x21d0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x21d0
incq %r13
jmp 0x38a0
movq %r14, %rdi
callq 0x2100
movq %r14, %rdi
leaq 0x283c(%rip), %rsi      # 0x617c
callq 0x21d0
xorl %r13d, %r13d
cmpq 0x28(%rbx), %r13
jae 0x395e
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
incq %r13
jmp 0x3948
movq %r14, %rdi
callq 0x2100
incq %r15
jmp 0x3884
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x28(%rsi), %rax
cmpq %rdx, %rax
jbe 0x3b36
cmpq %rbx, %rax
jbe 0x3b36
movq %rdi, %r15
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2614
testq %rax, %rax
je 0x3b1d
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
jmp 0x3b2d
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x444e
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x6493(%rip), %rdi      # 0x9fd0
leaq 0x24ec(%rip), %rsi      # 0x6030
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x286e(%rip), %rsi      # 0x63c9
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2060
leaq 0x24d1(%rip), %rsi      # 0x6046
movq %rax, %rdi
callq 0x21d0
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x4, %esi
ja 0x4431
movl %esi, %eax
leaq 0x209a(%rip), %rcx      # 0x647c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x209e(%rip), %rsi      # 0x6490
leaq 0xf(%rsp), %rdx
jmp 0x443d
leaq 0x20a6(%rip), %rsi      # 0x64a6
leaq 0xb(%rsp), %rdx
jmp 0x443d
leaq 0x208d(%rip), %rsi      # 0x649b
leaq 0xd(%rsp), %rdx
jmp 0x443d
leaq 0x2084(%rip), %rsi      # 0x64a0
leaq 0xc(%rsp), %rdx
jmp 0x443d
leaq 0x206b(%rip), %rsi      # 0x6495
leaq 0xe(%rsp), %rdx
jmp 0x443d
leaq 0x2073(%rip), %rsi      # 0x64ab
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x42a2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/cellule/cellule.cpp
// Function: Cellule::est_voisine(Cellule) const
bool Cellule::get_vivante() const{
	if (couleur == NOIR)
		return false;
	else 
		return true;
}

// Assembly:
cmpl $0x0, 0x8(%rsp)
je 0x44a9
leaq 0x8(%rsp), %rax
movq 0x8(%rdi), %rcx
subq 0x8(%rax), %rcx
movq 0x10(%rdi), %rdx
imulq %rcx, %rcx
subq 0x10(%rax), %rdx
imulq %rdx, %rdx
addq %rcx, %rdx
cmpq $0x3, %rdx
setb %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x2250
leaq 0x1cc4(%rip), %rsi      # 0x626e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2110
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21e0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %r14, %rdi
callq 0x20e0
pushq $0x1
popq %r14
movq (%rbx), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0x45f2
cmpl $0x20, %eax
jne 0x4601
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2050
jmp 0x45e2
pushq $0x1
popq %r12
pushq $0x1
popq %r14
movl %r12d, %r15d
decl %r12d
cmpq %r15, 0x8(%rbx)
jbe 0x464d
movq (%rbx), %rax
movzbl (%rax,%r15), %ecx
cmpl $0x9, %ecx
je 0x463e
cmpl $0x20, %ecx
jne 0x4645
cmpb $0x20, (%rax,%r12)
jne 0x4645
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2050
jmp 0x460f
movb $0x20, (%rax,%r15)
jmp 0x460f
incl %r15d
movl %r15d, %r12d
jmp 0x4609
pushq $0x1
popq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movzbl -0x1(%rax,%rsi), %eax
cmpl $0x20, %eax
je 0x4667
cmpl $0x9, %eax
jne 0x4677
decq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2050
jmp 0x4651
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x468c
jmp 0x468c
jmp 0x468c
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
decq %r15
cmpb $0x20, 0x1(%rax,%r15)
leaq 0x1(%r15), %r15
je 0x46b3
leaq 0x1ac7(%rip), %rsi      # 0x618d
movq %r14, %rdi
movq %r15, %rdx
callq 0x2110
subq %r15, %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x21e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1dba(%rip), %rsi      # 0x64c1
callq 0x43bf
testb %al, %al
je 0x4741
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2250
movq %r15, %rdi
callq 0x4c8e
movl %eax, %r12d
leaq 0x50(%rsp), %rdi
callq 0x20e0
movb $0x1, %bpl
testb %r12b, %r12b
jne 0x47c6
leaq 0x1d85(%rip), %rsi      # 0x64cd
movq %r14, %rdi
callq 0x43bf
testb %al, %al
je 0x4781
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2250
movq %r15, %rdi
callq 0x4bdc
movl %eax, %r12d
leaq 0x30(%rsp), %rdi
callq 0x20e0
movb $0x1, %bpl
testl %r12d, %r12d
jg 0x47c6
leaq 0x1d4f(%rip), %rsi      # 0x64d7
movq %r14, %rdi
callq 0x43bf
testb %al, %al
je 0x47c4
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2250
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x47ec
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x20e0
jmp 0x47c6
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x47d9
jmp 0x47d9
movq %rax, %rbx
movq %r15, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/massykezzoul[P]jeu-de-la-vie/configuration/configuration.cpp
// Function: extraire_cle_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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool extraire_cle_valeur(string ligne,string& cle,string& valeur) {
	ligne = nettoyer_ligne(ligne);
	/* trouver la clé */
	cle = get_chaine(ligne);
	/* Il faut vérifié que la clé est conforme */
	/* trouver les deux points */
	if (get_chaine(ligne,cle.size()) != ":") {
		cle = "";
		valeur = "";
		return false;
	} else {
		int debut = cle.size()+ 3;
		valeur = ligne.substr(debut,ligne.find_first_of(debut)-debut);
		/* il faut verifier que la valeur est correcte par rapport à la clé */
		if (verif_valeur(cle,valeur)) {
			return true;
		} else {
			cle = "";
			valeur = "";
			return false;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2250
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x4590
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x20e0
leaq 0xa8(%rsp), %rdi
callq 0x20e0
leaq 0x88(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2250
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x469f
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x20e0
leaq 0x88(%rsp), %rdi
callq 0x20e0
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2250
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x469f
leaq 0x1b32(%rip), %rsi      # 0x64dc
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x42dd
movl %eax, %ebp
movq %r12, %rdi
callq 0x20e0
leaq 0x68(%rsp), %rdi
callq 0x20e0
testb %bpl, %bpl
jne 0x4a5e
movl 0x8(%r14), %eax
addl $0x3, %eax
movslq %eax, %r12
movsbl %r12b, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x2240
subq %r12, %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x21e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2210
movq %r13, %rdi
callq 0x20e0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x2250
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x2250
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x46ee
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0x48(%rsp), %rdi
callq 0x20e0
movb $0x1, %al
testb %bpl, %bpl
jne 0x4a7d
leaq 0x1645(%rip), %r15      # 0x60aa
movq %r14, %rdi
movq %r15, %rsi
callq 0x22f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22f0
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
jmp 0x4aa1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x4aca
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x4aca
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x4aca
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19d0(%rip), %rsi      # 0x64c1
movq %r15, %rdi
callq 0x43bf
testb %al, %al
je 0x4b1b
movq (%r14), %rdi
callq 0x2220
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3224
leaq 0x19ab(%rip), %rsi      # 0x64cd
movq %r15, %rdi
callq 0x43bf
testb %al, %al
je 0x4b5d
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2250
movq %r15, %rdi
callq 0x4bdc
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x3280
leaq 0x28(%rsp), %rdi
callq 0x20e0
jmp 0x4bb2
leaq 0x1973(%rip), %rsi      # 0x64d7
movq %r15, %rdi
callq 0x43bf
testb %al, %al
je 0x4bb2
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2250
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
movq %r15, %rdi
callq 0x47ec
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x20e0
testb %bpl, %bpl
je 0x4bb2
movslq 0x4(%rsp), %rsi
movslq (%rsp), %rdx
movq %rbx, %rdi
callq 0x36a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x4bcf
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
leal -0x1(%r12), %r14d
xorl %r13d, %r13d
xorl %ebp, %ebp
movl %r13d, %r13d
cmpq %r13, %r12
jbe 0x4c2f
movq (%rbx), %rax
movsbl (%rax,%r13), %edi
callq 0x4c40
cmpl $-0x1, %eax
je 0x4c2c
movl %eax, %r15d
movl %r14d, %edi
callq 0x4c53
imull %eax, %r15d
addl %r15d, %ebp
incl %r13d
decl %r14d
jmp 0x4bf8
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1
popq %rdx
pushq $-0x1
popq %rax
movq %rdx, %rcx
testl %edi, %edi
js 0x4c6e
subl $0x1, %edi
jb 0x4c6b
imulq $0xa, %rcx, %rcx
jmp 0x4c5c
movq %rdx, %rax
imulq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x22a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x28(%rsp,%rax) # imm = 0xFFFFEFFF
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x2310
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
sete %bl
callq 0x20f0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movb %al, 0x40(%rdi)
movl (%rsi), %eax
movl %eax, (%rdi)
addq $0x8, %rsi
movq %rsp, %rdi
callq 0x2250
movq %rsp, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2210
movq %r13, %rdi
callq 0x20e0
movb 0x28(%r15), %al
movb %al, 0x28(%r12)
movl 0x2c(%r15), %eax
movl %eax, 0x2c(%r12)
addq $0x30, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2250
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4e2c
movq %rax, %r15
movq %r14, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x514d(%rip), %rdi      # 0x9fd0
leaq 0x1654(%rip), %rsi      # 0x64de
callq 0x21d0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x2100
leaq 0x1645(%rip), %rsi      # 0x64ed
movq %rax, %rdi
callq 0x21d0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x2100
leaq 0x1629(%rip), %rsi      # 0x64f4
movq %rax, %rdi
callq 0x21d0
movsbl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2100
leaq 0x1612(%rip), %rsi      # 0x6500
movq %rax, %rdi
callq 0x21d0
movl 0x2c(%rbx), %esi
movq %rax, %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x2100
leaq 0x1604(%rip), %rsi      # 0x6514
movq %rax, %rdi
callq 0x21d0
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21a0
movq %rax, %rdi
popq %rbx
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x4fcd
movq %rdx, %r15
movl (%rdx), %eax
movl %eax, (%r14)
leaq 0x8(%rdx), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2250
leaq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x20e0
movb 0x28(%r15), %al
movb %al, 0x28(%r14)
movl 0x2c(%r15), %eax
movl %eax, 0x2c(%r14)
addq $0x30, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2250
leaq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d82
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x554c
cmpl $-0x1, %eax
je 0x551d
movq 0x4af8(%rip), %rdi      # 0x9ff0
leaq 0x116b(%rip), %rsi      # 0x666a
callq 0x21d0
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2100
imulq $0x50, (%rbx), %rax
leaq (%rbx,%rax), %rsi
addq $0x8, %rsi
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x4f52
movq %r15, %rdi
callq 0x4310
incq (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x8, %rdi
xorl %edx, %edx
pushq $-0x1
popq %rax
cmpq %rdx, %rcx
je 0x556c
cmpl %esi, (%rdi)
je 0x556a
incq %rdx
addq $0x50, %rdi
jmp 0x5558
movl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %rsi
pushq $-0x1
popq %r13
leaq 0x8(%rsp), %r12
incq %r13
cmpq %r13, (%r15)
jbe 0x5609
leaq 0x50(%rsi), %rbx
movq %r12, %rdi
callq 0x2250
movq %r12, %rdi
movq %r14, %rsi
callq 0x578d
movl %eax, %ebp
movq %r12, %rdi
callq 0x20e0
movq %rbx, %rsi
testb %bpl, %bpl
je 0x55d3
movl -0x58(%rbx), %eax
jmp 0x560c
pushq $0x6
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
incq %rcx
addq $0x30, %rdi
pushq $0x6
popq %rax
decq %rcx
je 0x563d
leaq 0x50(%rdi), %rdx
cmpb %sil, (%rdi)
movq %rdx, %rdi
jne 0x5629
movl -0x78(%rdx), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %rsi
pushq $-0x1
popq %r13
leaq 0x8(%rsp), %r12
incq %r13
cmpq %r13, (%r15)
jbe 0x5725
leaq 0x50(%rsi), %rbx
movq %r12, %rdi
callq 0x2250
movq %r12, %rdi
movq %r14, %rsi
callq 0x578d
movl %eax, %ebp
movq %r12, %rdi
callq 0x20e0
movq %rbx, %rsi
testb %bpl, %bpl
je 0x56ef
movl -0x2c(%rbx), %eax
jmp 0x5728
pushq $0x5
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x8, %rdi
incq %rcx
pushq $0x5
popq %rax
decq %rcx
je 0x5758
leaq 0x50(%rdi), %rdx
cmpl %esi, (%rdi)
movq %rdx, %rdi
jne 0x5745
movl -0x24(%rdx), %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %esi, %esi
js 0x5771
movl %esi, %eax
cmpq %rax, (%rdi)
jbe 0x5771
imulq $0x50, %rax, %rax
addq %rdi, %rax
addq $0x8, %rax
retq
pushq %rax
movq 0x4877(%rip), %rdi      # 0x9ff0
leaq 0xf17(%rip), %rsi       # 0x6697
callq 0x21d0
movq %rax, %rdi
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c04
movq %rbx, %rdi
xorl %esi, %esi
callq 0x34b2
movq %rsp, %rdi
callq 0x3b82
movq 0x47d2(%rip), %rdi      # 0x9fd0
callq 0x2100
leaq 0xeac(%rip), %rsi       # 0x66b6
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2100
movq %rsp, %rdi
callq 0x33aa
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x33aa
movq %rbx, %rdi
callq 0x22c0