LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: directorSearchVector(std::vector<Video, std::allocator<Video>> const&, std::vector<Video, std::allocator<Video>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void directorSearchVector(const vector<Video>& videos, vector<Video>& results, string directorIn)  
//takes a const vector of movies to search, a vector of videos to add results to, and a search term.
{
    Video temp;  //creates a temporary video to hold values as we process vector
    int index = 0;
    int size = videos.size();
    while(index < size)
    {
       	temp = videos[index];  //set temp equal to the video at [index]
       	if(temp.getDirector() == directorIn)
    		results.push_back(videos[index]);  //if video is found, add it to results
       	index++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
leaq -0xe8(%rbp), %rdi
callq 0x656c
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x3, %rax
movabsq $-0x79435e50d79435e5, %r12 # imm = 0x86BCA1AF286BCA1B
imulq %rax, %r12
testl %r12d, %r12d
jle 0x51bc
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq (%r15), %r13
leaq (%r14,%r13), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x20b0
leaq (%r14,%r13), %rsi
addq $0x20, %rsi
leaq -0xc8(%rbp), %rdi
callq 0x20b0
leaq (%r14,%r13), %rsi
addq $0x40, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x20b0
leaq (%r14,%r13), %rsi
addq $0x60, %rsi
leaq -0x88(%rbp), %rdi
callq 0x20b0
leaq (%r14,%r13), %rsi
addq $0x80, %rsi
leaq -0x68(%rbp), %rdi
callq 0x5aae
leaq -0x50(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x687c
movq -0x48(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x5177
testq %rdx, %rdx
je 0x517c
movq (%rbx), %rsi
movq -0x50(%rbp), %rdi
callq 0x2170
testl %eax, %eax
sete %r13b
jmp 0x517f
xorl %r13d, %r13d
jmp 0x517f
movb $0x1, %r13b
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5198
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2160
testb %r13b, %r13b
je 0x51ac
movq (%r15), %rsi
addq %r14, %rsi
movq -0x30(%rbp), %rdi
callq 0x5880
addq $0x98, %r14
decq %r12
jne 0x50e1
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x2506
movq -0x20(%rbx), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x51e1
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5200
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0xb8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x521f
movq -0xb8(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0xd8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x523e
movq -0xd8(%rbp), %rsi
incq %rsi
callq 0x2160
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5252
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x56c6
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: displayMoviesInCart(Cart&)
void displayMoviesInCart(Cart& current)
{
	vector<Video> temp = current.getVideos();  //creates a temporary vector and sets it equal to the cart
	clearScreen();	//Clear screen before displaying menu
	if(temp.empty())
		cout << "Your cart is empty!" << endl;
	else
	{
		cout << "Here's what's in your cart:" << endl;
		for (int i = 0; i < current.getNumCart(); i++)  //iterates through cart, displaying the title of each movie
		{
			cout << i+1 << ". " << temp[i].getTitle() << endl;
		}
	}
	//TODO: Show what's in the user's cart
	systemPause();	//Wait for user input
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x6ede
movq 0x5d40(%rip), %rdi      # 0xafd0
leaq 0x2dcd(%rip), %rsi      # 0x8064
movl $0xa, %edx
callq 0x2180
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x53aa
movq 0x5d1a(%rip), %r14      # 0xafd0
leaq 0x3444(%rip), %rsi      # 0x8701
movl $0x1b, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0x5ce8(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
xorl %r14d, %r14d
leaq -0x48(%rbp), %r12
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x6e84
cltq
cmpq %rax, %r15
jge 0x53f0
leal 0x1(%r15), %esi
movq 0x5cb3(%rip), %rdi      # 0xafd0
callq 0x2210
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x3157(%rip), %rsi      # 0x848b
callq 0x2180
movq -0x60(%rbp), %rsi
addq %r14, %rsi
movq %r12, %rdi
callq 0x6822
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r13, %rdi
callq 0x2180
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x539b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2160
addq $0x98, %r14
incq %r15
jmp 0x52ff
movq 0x5c1f(%rip), %rbx      # 0xafd0
leaq 0x3335(%rip), %rsi      # 0x86ed
movl $0x13, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0x5bed(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
callq 0x2b0d
leaq -0x60(%rbp), %rdi
callq 0x2506
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5411
jmp 0x5411
movq %rax, %rbx
jmp 0x5432
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5432
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0x60(%rbp), %rdi
callq 0x2506
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: validateCartChoice(int)
void validateCartChoice(int choice)
{
	while (!cin || choice > 4 || choice < 1)
	{
		cin.clear(); //clear bad input flag
		cin.ignore(10000, '\n'); //Discard input
		cout << "Please enter a number between 1 and 5" << endl;
		cin >> choice;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %eax
movl %edi, -0x24(%rbp)
movq 0x5b82(%rip), %rbx      # 0xafe0
movq (%rbx), %rcx
movq -0x18(%rcx), %rdi
testb $0x5, 0x20(%rbx,%rdi)
jne 0x5478
addl $-0x5, %eax
cmpl $-0x5, %eax
ja 0x5505
addq %rbx, %rdi
movq 0x5b4e(%rip), %r14      # 0xafd0
leaq 0x3294(%rip), %r15      # 0x871d
leaq -0x24(%rbp), %r12
xorl %esi, %esi
callq 0x2200
movl $0x2710, %esi           # imm = 0x2710
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20d0
movl $0x25, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
testb $0x5, 0x20(%rbx,%rax)
jne 0x548d
movl -0x24(%rbp), %eax
addl $-0x5, %eax
cmpl $-0x4, %eax
jb 0x548d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: displayCheckOut(Cart)
void displayCheckOut(Cart newCart)
{
	cout << "\nThank you for choosing BawkBuster!\n" << endl;
	cout << "Your total price is: $" << std::fixed << std::setprecision(2) 
	<< newCart.getTPrice() << endl;
	cout << "\nAs a Thank You, the Charge Will Be Removed So Your Movies Are Free!" << endl;
	cout << "\nEnjoy Your Movies!" << endl;
	cout << "And Remember!" << endl;
	cout << "Be Kind, Rewind" << endl;
	systemPause();	//Waits for user input
			//before exiting program.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x5aad(%rip), %rbx      # 0xafd0
leaq 0x32ce(%rip), %rsi      # 0x87f8
movl $0x24, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x32b8(%rip), %rsi      # 0x881d
movl $0x16, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%rbx,%rax)
movq %r14, %rdi
callq 0x6ea4
movq %rbx, %rdi
callq 0x21e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x325d(%rip), %rsi      # 0x8834
movl $0x44, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x3267(%rip), %rsi      # 0x8879
movl $0x13, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x3240(%rip), %rsi      # 0x888d
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x3213(%rip), %rsi      # 0x889b
movl $0xf, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
popq %rbx
popq %r14
popq %rbp
jmp 0x2b0d
nop
// File: /workspace/github_cpp_makefile_star2_O1/KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/Video.cpp
// Function: Video::Video()
Video::Video()  //default constructor with junk values
{
    title = "AAA";
    genre = "OTHER";
    director = "AAA";
    actor = "AAA";
    //price = -100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x40(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r15
leaq 0x50(%rdi), %r13
movq %r13, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r12
leaq 0x70(%rdi), %r14
movq %r14, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0x80(%rdi), %rcx
movq %rcx, -0x50(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
movq %rax, 0x90(%rdi)
leaq 0x22f7(%rip), %rcx      # 0x88ef
movl $0x3, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movq 0x28(%rbx), %rdx
leaq 0x22e1(%rip), %rcx      # 0x88f3
movl $0x5, %r8d
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x21d0
movq 0x48(%rbx), %rdx
leaq 0x22c1(%rip), %rcx      # 0x88ef
movl $0x3, %r8d
movq %r15, %rdi
xorl %esi, %esi
callq 0x21d0
movq 0x68(%rbx), %rdx
leaq 0x22a6(%rip), %rcx      # 0x88ef
movl $0x3, %r8d
movq %r12, %rdi
xorl %esi, %esi
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2506
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x6689
movq (%r14), %rsi
incq %rsi
callq 0x2160
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x669d
movq (%r13), %rsi
incq %rsi
callq 0x2160
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x66b9
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x66d1
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq -0x48(%rbp), %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/Video.cpp
// Function: Video::Video(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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Video::Video(std::string titleIn, std::string genreIn, std::string directorIn, std::string actorIn)
{
    title = titleIn;
    genre = genreIn;
    director = directorIn;
    actor = actorIn;
    //price = PRICE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x60(%rbp)
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x50(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, -0x48(%rbp)
leaq 0x50(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r13
leaq 0x70(%rdi), %r12
movq %r12, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
movq %rax, 0x90(%rdi)
leaq 0x80(%rdi), %rax
movq %rax, -0x58(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
callq 0x20b0
movq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x20b0
movq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x20b0
movq %r13, %rdi
movq -0x60(%rbp), %rsi
callq 0x20b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
callq 0x2506
movq (%r13), %rdi
cmpq %r12, %rdi
je 0x67ca
movq (%r12), %rsi
incq %rsi
callq 0x2160
movq -0x48(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x67e6
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq -0x50(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x6802
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq (%rbx), %rdi
cmpq -0x40(%rbp), %rdi
je 0x681a
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/Video.cpp
// Function: Video::printInfo(Video)
void Video::printInfo(Video videoIn)
{
    std::cout << "Title: " << videoIn.getTitle() << std::endl;
    std::cout << "Genre: " << videoIn.getGenre() << std::endl;
    std::cout << "Director: " << videoIn.getDirector() << std::endl;
    std::cout << "Actor: " << videoIn.getActor() << std::endl;
    //std::cout << "Price: " << videoIn.getPrice() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x46df(%rip), %r14      # 0xafd0
leaq 0x2001(%rip), %rsi      # 0x88f9
movl $0x7, %edx
movq %r14, %rdi
callq 0x2180
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x5e9e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6972
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x4657(%rip), %r14      # 0xafd0
leaq 0x1f81(%rip), %rsi      # 0x8901
movl $0x7, %edx
movq %r14, %rdi
callq 0x2180
movq %r12, (%r15)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x5e9e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x69f1
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x45d8(%rip), %r14      # 0xafd0
leaq 0x1f0a(%rip), %rsi      # 0x8909
movl $0xa, %edx
movq %r14, %rdi
callq 0x2180
movq %r12, (%r15)
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x5e9e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6a70
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x4559(%rip), %r14      # 0xafd0
leaq 0x1e96(%rip), %rsi      # 0x8914
movl $0x7, %edx
movq %r14, %rdi
callq 0x2180
movq %r12, (%r15)
movq 0x60(%rbx), %rsi
movq 0x68(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x5e9e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2180
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6aef
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b02
jmp 0x6b02
jmp 0x6b02
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6b1a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/Cart.cpp
// Function: Cart::unAddToCart()
void Cart::unAddToCart()
{
	if(numCart == 0)
	{
		std::cout << std::endl <<"Your cart is already empty!" << std::endl;
		std::cin.clear();
		std::cin.ignore(1024, '\n');	// Discart old input
		std::cout << "Press enter to continue...";
		std::cin.get();			// Proceed after new input from user
	}
	else
	{
		std::cout << vidVector[vidVector.size() - 1].getTitle() << " has been removed from your cart." << std::endl;
		vidVector.pop_back();
		numCart--;
		totalPrice -= PRICE;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, (%rdi)
je 0x6ff6
movq %rdi, %rbx
movq $-0x98, %rsi
addq 0x18(%rdi), %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x6822
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x406e(%rip), %rdi      # 0xafd0
callq 0x2180
movq %rax, %r14
leaq 0x19db(%rip), %rsi      # 0x894c
movl $0x21, %edx
movq %rax, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x10(%rbx), %r14
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6fc2
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2160
movq $-0x98, %rsi
addq 0x18(%rbx), %rsi
movq %rsi, 0x18(%rbx)
movq %r14, %rdi
callq 0x624c
decl (%rbx)
movsd 0x8(%rbx), %xmm0
addsd 0x1940(%rip), %xmm0     # 0x8928
movsd %xmm0, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3fd3(%rip), %rbx      # 0xafd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %rax, %r14
leaq 0x1902(%rip), %rsi      # 0x8930
movl $0x1b, %edx
movq %rax, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x3f77(%rip), %r14      # 0xafe0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x2200
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movl $0xa, %edx
callq 0x20d0
leaq 0xfdc(%rip), %rsi       # 0x806f
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x2180
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2190
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70cc
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2635
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x2638
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x40(%rsp), %r15
xorl %r13d, %r13d
movq (%rbx), %rdi
addq %r12, %rdi
callq 0x50bc
movq %rax, %rbp
movq (%r14), %rax
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movq %r15, %rdi
callq 0x50bc
cmpq %rax, %rbp
jne 0x263b
movq (%rbx), %rdi
addq %r12, %rdi
callq 0x50c2
movq %rax, %rbp
movq (%r14), %rax
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x50c2
cmpq %rax, %rbp
jne 0x263b
movq (%rbx), %rdi
addq %r12, %rdi
callq 0x50c8
movl %eax, %ebp
movq (%r14), %rax
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
movq %rsp, %rdi
callq 0x50c8
cmpl %eax, %ebp
jne 0x263b
incq %r13
addq $0x20, %r12
cmpq 0x10(%rbx), %r13
jb 0x258a
jmp 0x263b
xorl %eax, %eax
retq
xorl %r13d, %r13d
cmpq 0x10(%rbx), %r13
sete %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x26a7
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x50bc
cmpq %r12, %rax
jne 0x269a
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x50c2
cmpq %r15, %rax
je 0x26ab
incq %r13
addq $0x20, %rbx
cmpq 0x10(%r14), %r13
jb 0x267a
xorl %ebx, %ebx
jmp 0x26ae
addq (%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x2707
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x50bc
cmpq %r12, %rax
jne 0x26fa
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x50c2
cmpq %r15, %rax
je 0x270b
incq %r13
addq $0x20, %rbx
cmpq 0x10(%r14), %r13
jb 0x26da
xorl %ebx, %ebx
jmp 0x270e
addq (%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2799
cmpq %r14, %rax
jbe 0x2799
movq %rdi, %rbx
movq %r15, %rsi
movq %r14, %rdx
callq 0x26bc
testq %rax, %rax
je 0x2793
subq (%rbx), %rax
sarq $0x5, %rax
movq 0x10(%rbx), %rdx
decq %rdx
cmpq %rdx, %rax
jae 0x278f
movq %rax, %rcx
shlq $0x5, %rcx
addq $0x20, %rcx
movq (%rbx), %rdx
incq %rax
movups (%rdx,%rcx), %xmm0
movups 0x10(%rdx,%rcx), %xmm1
movups %xmm1, -0x10(%rdx,%rcx)
movups %xmm0, -0x20(%rdx,%rcx)
movq 0x10(%rbx), %rdx
decq %rdx
addq $0x20, %rcx
cmpq %rdx, %rax
jb 0x2766
movq %rdx, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x8830(%rip), %rdi      # 0xafd0
leaq 0x4889(%rip), %rsi      # 0x7030
callq 0x2190
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
leaq 0x4c0b(%rip), %rsi      # 0x73c9
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x486e(%rip), %rsi      # 0x7046
movq %rax, %rdi
callq 0x2190
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28b3
movq %rsi, %r15
cmpq %rsi, %rax
jbe 0x28e9
cmpq %r14, %rax
jbe 0x28e9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x26bc
testq %rax, %rax
je 0x2852
movq %rax, %rdi
movl $0x1, %esi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51a4
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5056
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x29b4
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 0x8736(%rip), %r14      # 0xaff0
leaq 0x4797(%rip), %rsi      # 0x7058
movq %r14, %rdi
callq 0x2190
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x2060
movq %rax, %rdi
callq 0x20d0
leaq 0x47ba(%rip), %rsi      # 0x709e
movq %r14, %rdi
jmp 0x292b
movq 0x86e0(%rip), %rdi      # 0xafd0
leaq 0x4739(%rip), %rsi      # 0x7030
callq 0x2190
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
leaq 0x4abb(%rip), %rsi      # 0x73c9
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x471e(%rip), %rsi      # 0x7046
movq %rax, %rdi
callq 0x2190
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x10(%rdi)
je 0x29a4
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
movq (%r14), %rdi
addq %r12, %rdi
movl %ebx, %esi
callq 0x51d3
movzbl %al, %eax
addq %rax, %r15
incq %r13
addq $0x20, %r12
cmpq 0x10(%r14), %r13
jb 0x2982
jmp 0x29a7
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%rdi), %r12
cmpq %r12, 0x10(%rdi)
jb 0x2a4d
movq %rdi, %rbx
leaq (%r12,%r12), %r13
movq %r13, 0x18(%rdi)
movq %r13, %rax
shrq $0x3b, %rax
shlq $0x6, %r12
xorl %r15d, %r15d
negq %rax
sbbq %r15, %r15
orq %r12, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r14
testq %r13, %r13
je 0x2a12
xorl %r13d, %r13d
leaq (%r14,%r13), %rdi
callq 0x506c
addq $0x20, %r13
cmpq %r13, %r12
jne 0x2a00
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x2a3d
movq (%rbx), %rcx
xorl %edx, %edx
movups (%rcx,%rdx), %xmm0
movups 0x10(%rcx,%rdx), %xmm1
movups %xmm1, 0x10(%r14,%rdx)
movups %xmm0, (%r14,%rdx)
addq $0x20, %rdx
decq %rax
jne 0x2a20
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2a4a
callq 0x2210
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2320
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x0, 0x10(%rdi)
je 0x2b3d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x50bc
movq %rax, %r14
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x50c2
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2b3e
movq %rax, %r14
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x50c8
movl %eax, %ebp
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x5082
testb %al, %al
je 0x2b24
cmpl $0x4, %ebp
jne 0x2aee
addl $-0x4, %r14d
movq (%rbx), %rdi
addq %r15, %rdi
cmpl $-0x3, %r14d
ja 0x2b0a
movl $0x3, %esi
jmp 0x2b1f
cmpl $0x2, %ebp
jne 0x2b24
addl $-0x4, %r14d
cmpl $-0x3, %r14d
ja 0x2b24
movq (%rbx), %rdi
addq %r15, %rdi
movl $0x1, %esi
jmp 0x2b1f
callq 0x50cc
testq %rax, %rax
je 0x2b24
movq (%rbx), %rdi
addq %r15, %rdi
movl $0x2, %esi
callq 0x51d0
incq %r12
addq $0x20, %r15
cmpq 0x10(%rbx), %r12
jb 0x2a8c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %ebp, %ebp
movq %rsi, %rcx
subq $0x1, %rcx
cmovbq %rbp, %rcx
movq 0x28(%rdi), %rax
decq %rax
xorl %r8d, %r8d
cmpq %rsi, %rax
setne %r8b
addq %rsi, %r8
movq %rdx, %r9
subq $0x1, %r9
cmovbq %rbp, %r9
movq %r9, 0x8(%rsp)
xorl %r13d, %r13d
cmpq %rdx, %rax
setne %al
movq %r8, 0x10(%rsp)
cmpq %r8, %rcx
ja 0x2c17
movq %rdx, %r15
movq %rdi, %rbx
movb %al, %r13b
addq %rdx, %r13
cmpq $0x1, %rdx
movl $0x1, %eax
cmovbq %rdx, %rax
negq %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
movq %rsi, 0x18(%rsp)
movq (%rsp), %r14
cmpq %r13, 0x8(%rsp)
movq %rcx, 0x20(%rsp)
ja 0x2c0d
movq %rcx, %r12
xorq %rsi, %r12
leaq (%r15,%r14), %rdx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x265c
movq 0x18(%rsp), %rsi
testq %rax, %rax
setne %al
orq %r14, %r12
setne %cl
andb %al, %cl
movzbl %cl, %eax
movq 0x20(%rsp), %rcx
addq %rax, %rbp
leaq (%r15,%r14), %rax
incq %rax
incq %r14
cmpq %r13, %rax
jbe 0x2bcb
incq %rcx
cmpq 0x10(%rsp), %rcx
jbe 0x2bbb
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38c8(%rip), %xmm1     # 0x7008
ucomiss %xmm0, %xmm1
jb 0x3753
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x3753
movss %xmm0, 0x20(%rdi)
retq
pushq %rbx
subq $0x10, %rsp
movq 0x7891(%rip), %rbx      # 0xaff0
leaq 0x39a7(%rip), %rsi      # 0x710d
movl $0x8, %edx
movq %rbx, %rdi
movss %xmm0, 0xc(%rsp)
callq 0x21d0
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %rbx
leaq 0x3982(%rip), %rsi      # 0x7116
movl $0x20, %edx
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37d8
movq %rsi, 0x28(%rdi)
retq
pushq %rbx
movq 0x7810(%rip), %rbx      # 0xaff0
leaq 0x3926(%rip), %rsi      # 0x710d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x21d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20f0
movq %rax, %rbx
leaq 0x392f(%rip), %rsi      # 0x7137
movl $0x1d, %edx
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a0c
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x395f
callq 0x2210
movq 0x18(%r14), %rbp
movq %rbp, %rax
shrq $0x3b, %rax
movq %rbp, %r13
shlq $0x5, %r13
xorl %r15d, %r15d
negq %rax
sbbq %r15, %r15
orq %r13, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
testq %rbp, %rbp
je 0x39a1
xorl %ebp, %ebp
leaq (%r12,%rbp), %rdi
callq 0x506c
addq $0x20, %rbp
cmpq %rbp, %r13
jne 0x398f
movq %r12, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rcx
movq %rcx, 0x18(%rbx)
movss 0x20(%r14), %xmm0
movss %xmm0, 0x20(%rbx)
movq 0x28(%r14), %rcx
movq %rcx, 0x28(%rbx)
movq 0x30(%r14), %rcx
movq %rcx, 0x30(%rbx)
movl 0x38(%r14), %ecx
movl %ecx, 0x38(%rbx)
testq %rax, %rax
je 0x3a0c
xorl %eax, %eax
xorl %ecx, %ecx
movq (%r14), %rdx
movq (%rbx), %rsi
movups (%rdx,%rax), %xmm0
movups 0x10(%rdx,%rax), %xmm1
movups %xmm1, 0x10(%rsi,%rax)
movups %xmm0, (%rsi,%rax)
incq %rcx
addq $0x20, %rax
cmpq 0x10(%rbx), %rcx
jb 0x39e7
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 0x2320
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a5b
xorl %edi, %edi
callq 0x2160
movq %rax, %r14
callq 0x2260
movslq %eax, %rsi
imulq %r14, %rsi
movq %rsi, 0x30(%rbx)
movl %esi, %edi
callq 0x2170
movq 0x10(%rbx), %r12
movq 0x28(%rbx), %rax
testq %rax, %rax
js 0x3a7a
cvtsi2ss %rax, %xmm0
jmp 0x3a8f
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movss 0x20(%rbx), %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %rax
movq %rax, %rcx
subss 0x3560(%rip), %xmm1     # 0x700c
cvttss2si %xmm1, %r13
sarq $0x3f, %rcx
andq %rcx, %r13
orq %rax, %r13
cmpq %r13, %r12
jae 0x3b06
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 0x26bc
testq %rax, %rax
jne 0x3ac0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x27e6
incq %r12
cmpq %r13, %r12
jne 0x3ac0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3846
cmpq $0x0, 0x28(%r14)
je 0x3bfa
xorl %r15d, %r15d
cmpq $0x0, 0x28(%r14)
je 0x3bed
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2b3e
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x26bc
testq %rax, %rax
je 0x3b84
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x26bc
movq %rax, %rdi
callq 0x50c8
jmp 0x3b86
xorl %eax, %eax
movl %eax, %ecx
andl $-0x3, %ecx
cmpl $0x1, %ecx
jne 0x3ba0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x271c
jmp 0x3be0
testl %eax, %eax
setne %cl
cmpq $0x3, %r13
setne %dl
orb %cl, %dl
jne 0x3bc0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x27e6
jmp 0x3be0
cmpl $0x4, %eax
je 0x3bca
cmpl $0x2, %eax
jne 0x3be0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x26bc
movq %rax, %rdi
callq 0x51ca
incq %r12
cmpq 0x28(%r14), %r12
jb 0x3b48
incq %r15
cmpq 0x28(%r14), %r15
jb 0x3b3a
movq %rbx, %rdi
callq 0x2a70
incq 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3c15
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3c25
callq 0x2210
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rax
incq %rcx
cmpq %rax, %rcx
jae 0x3cd2
movq %rdx, %rbx
movq %rsi, %r14
cmpq %rsi, %rax
jb 0x3cea
testq %r14, %r14
sete %cl
leaq -0x1(%rbx), %rdx
cmpq %rax, %rdx
setae %al
orb %cl, %al
jne 0x3cea
leaq -0x1(%r14), %rsi
callq 0x27e6
movq 0x7350(%rip), %r15      # 0xafd0
leaq 0x34ce(%rip), %rsi      # 0x7155
movl $0x6, %edx
movq %r15, %rdi
callq 0x21d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %r14
leaq 0x3720(%rip), %rsi      # 0x73c9
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, %rbx
leaq 0x3491(%rip), %rsi      # 0x715c
movl $0xd, %edx
jmp 0x3d41
movq 0x7317(%rip), %rbx      # 0xaff0
leaq 0x348a(%rip), %rsi      # 0x716a
movl $0x11, %edx
movq %rbx, %rdi
jmp 0x3d44
movq 0x72ff(%rip), %r15      # 0xaff0
leaq 0x3338(%rip), %rsi      # 0x7030
movl $0x15, %edx
movq %r15, %rdi
callq 0x21d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %r14
leaq 0x36af(%rip), %rsi      # 0x73c9
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, %rbx
leaq 0x330a(%rip), %rsi      # 0x7046
movl $0x11, %edx
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x71a1(%rip), %r14      # 0xafd0
leaq 0x3346(%rip), %rsi      # 0x717c
movl $0x2, %edx
movq %r14, %rdi
callq 0x21d0
cmpq $0x0, 0x28(%rbx)
je 0x3e74
xorl %r13d, %r13d
movq 0x717c(%rip), %r15      # 0xafd0
leaq 0x3324(%rip), %r12      # 0x717f
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
incq %r13
cmpq 0x28(%rbx), %r13
jb 0x3e5b
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
cmpq $0x0, 0x28(%rbx)
je 0x4030
xorl %r15d, %r15d
leaq 0x32cf(%rip), %rbp      # 0x717f
leaq 0x32ce(%rip), %r12      # 0x7185
movq %rbx, (%rsp)
movl $0x2, %edx
movq %r14, %rdi
leaq 0x32ba(%rip), %rsi      # 0x7184
callq 0x21d0
cmpq $0x0, 0x28(%rbx)
je 0x3f9e
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x265c
testq %rax, %rax
je 0x3f08
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x265c
movq %rax, %rdi
callq 0x50d2
jmp 0x3f81
movl $0x3, %edx
movq %r14, %rdi
leaq 0x3270(%rip), %rsi      # 0x7187
callq 0x21d0
movq %r14, %rdi
xorl %esi, %esi
callq 0x22d0
movq %r15, %rbx
movq %r14, %r15
movq %r12, %r14
movq %rbp, %r12
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x324e(%rip), %rsi      # 0x7192
callq 0x21d0
movl $0x3, %edx
movq %rbp, %rdi
leaq 0x3233(%rip), %rsi      # 0x718b
callq 0x21d0
movl $0x4, %edx
movq %rbp, %rdi
movq %r12, %rbp
movq %r14, %r12
movq %r15, %r14
movq %rbx, %r15
movq (%rsp), %rbx
leaq 0x3213(%rip), %rsi      # 0x718f
callq 0x21d0
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
incq %r13
cmpq 0x28(%rbx), %r13
jb 0x3edd
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movl $0x2, %edx
movq %r14, %rdi
leaq 0x31a8(%rip), %rsi      # 0x717c
callq 0x21d0
cmpq $0x0, 0x28(%rbx)
je 0x3ffc
xorl %r13d, %r13d
movl $0x4, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x21d0
incq %r13
cmpq 0x28(%rbx), %r13
jb 0x3fe3
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
incq %r15
cmpq 0x28(%rbx), %r15
jb 0x3ebb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42c0
cmpq %rbx, %rax
jbe 0x42c0
movq %rdi, %r15
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x265c
testq %rax, %rax
je 0x42a7
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
jmp 0x42b7
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5056
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x6d09(%rip), %rdi      # 0xafd0
leaq 0x2d62(%rip), %rsi      # 0x7030
callq 0x2190
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x30e4(%rip), %rsi      # 0x73c9
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2060
leaq 0x2d47(%rip), %rsi      # 0x7046
movq %rax, %rdi
callq 0x2190
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x4, %esi
ja 0x503a
movl %esi, %eax
leaq 0x249b(%rip), %rcx      # 0x747c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x249f(%rip), %rsi      # 0x7490
leaq 0x249c(%rip), %rdx      # 0x7494
jmp 0x5048
leaq 0x24a5(%rip), %rsi      # 0x74a6
leaq 0x24a2(%rip), %rdx      # 0x74aa
jmp 0x5048
leaq 0x248a(%rip), %rsi      # 0x749b
leaq 0x2487(%rip), %rdx      # 0x749f
jmp 0x5048
leaq 0x247f(%rip), %rsi      # 0x74a0
leaq 0x247d(%rip), %rdx      # 0x74a5
jmp 0x5048
leaq 0x2464(%rip), %rsi      # 0x7495
leaq 0x2462(%rip), %rdx      # 0x749a
jmp 0x5048
leaq 0x246a(%rip), %rsi      # 0x74ab
leaq 0x246e(%rip), %rdx      # 0x74b6
movq %rbx, %rdi
callq 0x4f36
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50b9
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_O1/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:
testl %esi, %esi
je 0x51af
movl $0x4, (%rdi)
retq
movl $0x0, (%rdi)
movq $0x0, 0x18(%rdi)
retq