LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
leaq -0xf0(%rbp), %rdi
callq 0x666c
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x3, %rax
movabsq $-0x79435e50d79435e5, %r14 # imm = 0x86BCA1AF286BCA1B
imulq %rax, %r14
testl %r14d, %r14d
jle 0x5288
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq -0xf0(%rbp), %rbx
movq (%r15), %r12
leaq (%r12,%r13), %rsi
movq %rbx, %rdi
callq 0x20b0
leaq (%r12,%r13), %rsi
addq $0x20, %rsi
leaq -0xd0(%rbp), %rdi
callq 0x20b0
leaq (%r12,%r13), %rsi
addq $0x40, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x20b0
leaq (%r12,%r13), %rsi
addq $0x60, %rsi
leaq -0x90(%rbp), %rdi
callq 0x20b0
leaq (%r12,%r13), %rsi
addq $0x80, %rsi
leaq -0x70(%rbp), %rdi
callq 0x5b80
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x697c
movq -0x50(%rbp), %rdx
movq -0x30(%rbp), %rax
cmpq 0x8(%rax), %rdx
jne 0x523c
movq -0x58(%rbp), %r12
testq %rdx, %rdx
je 0x5244
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0x2170
testl %eax, %eax
sete %bl
jmp 0x5246
movq -0x58(%rbp), %r12
xorl %ebx, %ebx
jmp 0x5246
movb $0x1, %bl
leaq -0x48(%rbp), %rax
cmpq %rax, %r12
je 0x525e
movq -0x48(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x2160
testb %bl, %bl
leaq -0xf0(%rbp), %rbx
je 0x5278
movq (%r15), %rsi
addq %r13, %rsi
movq -0x38(%rbp), %rdi
callq 0x5952
addq $0x98, %r13
decq %r14
jne 0x51a4
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x2506
movq -0x20(%rbx), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x52ad
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52cc
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0xc0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52eb
movq -0xc0(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0xe0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x530a
movq -0xe0(%rbp), %rsi
incq %rsi
callq 0x2160
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x531e
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x5798
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6fe2
movq 0x5c74(%rip), %rdi      # 0xafd0
leaq 0x2d01(%rip), %rsi      # 0x8064
movl $0xa, %edx
callq 0x2180
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x5476
movq 0x5c4e(%rip), %r14      # 0xafd0
leaq 0x3378(%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 0x5c1c(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
xorl %r14d, %r14d
leaq -0x48(%rbp), %r12
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x6f88
cltq
cmpq %rax, %r15
jge 0x54bc
leal 0x1(%r15), %esi
movq 0x5be7(%rip), %rdi      # 0xafd0
callq 0x2210
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x308b(%rip), %rsi      # 0x848b
callq 0x2180
movq -0x60(%rbp), %rsi
addq %r14, %rsi
movq %r12, %rdi
callq 0x6922
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 0x5467
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2160
addq $0x98, %r14
incq %r15
jmp 0x53cb
movq 0x5b53(%rip), %rbx      # 0xafd0
leaq 0x3269(%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 0x5b21(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
callq 0x2b0a
leaq -0x60(%rbp), %rdi
callq 0x2506
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54dd
jmp 0x54dd
movq %rax, %rbx
jmp 0x54fe
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x54fe
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_O3/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 0x5ab6(%rip), %rbx      # 0xafe0
movq (%rbx), %rcx
movq -0x18(%rcx), %rdi
testb $0x5, 0x20(%rbx,%rdi)
sete %cl
addl $-0x5, %eax
cmpl $-0x4, %eax
setae %al
testb %al, %cl
jne 0x55d7
addq %rbx, %rdi
movq 0x5a7c(%rip), %r14      # 0xafd0
leaq 0x31c2(%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 0x555f
movl -0x24(%rbp), %eax
addl $-0x5, %eax
cmpl $-0x4, %eax
jb 0x555f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x59db(%rip), %rbx      # 0xafd0
leaq 0x31fc(%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 0x31e6(%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 0x6fa8
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 0x318b(%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 0x3195(%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 0x316e(%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 0x3141(%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 0x2b0a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21f7(%rip), %rcx      # 0x88ef
movl $0x3, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movq 0x28(%rbx), %rdx
leaq 0x21e1(%rip), %rcx      # 0x88f3
movl $0x5, %r8d
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x21d0
movq 0x48(%rbx), %rdx
leaq 0x21c1(%rip), %rcx      # 0x88ef
movl $0x3, %r8d
movq %r15, %rdi
xorl %esi, %esi
callq 0x21d0
movq 0x68(%rbx), %rdx
leaq 0x21a6(%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 0x6789
movq (%r14), %rsi
incq %rsi
callq 0x2160
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x679d
movq (%r13), %rsi
incq %rsi
callq 0x2160
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x67b9
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x67d1
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq -0x48(%rbp), %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68ca
movq (%r12), %rsi
incq %rsi
callq 0x2160
movq -0x48(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x68e6
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq -0x50(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x6902
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq (%rbx), %rdi
cmpq -0x40(%rbp), %rdi
je 0x691a
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45df(%rip), %r14      # 0xafd0
leaq 0x1f01(%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 0x5f92
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 0x6a72
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x4557(%rip), %r14      # 0xafd0
leaq 0x1e81(%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 0x5f92
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 0x6af1
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x44d8(%rip), %r14      # 0xafd0
leaq 0x1e0a(%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 0x5f92
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 0x6b70
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x4459(%rip), %r14      # 0xafd0
leaq 0x1d96(%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 0x5f92
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 0x6bef
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c02
jmp 0x6c02
jmp 0x6c02
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6c1a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70fa
movq %rdi, %rbx
movq $-0x98, %rsi
addq 0x18(%rdi), %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x6922
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x3f6a(%rip), %rdi      # 0xafd0
callq 0x2180
movq %rax, %r14
leaq 0x18d7(%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 0x70c6
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2160
movq $-0x98, %rsi
addq 0x18(%rbx), %rsi
movq %rsi, 0x18(%rbx)
movq %r14, %rdi
callq 0x6348
decl (%rbx)
movsd 0x8(%rbx), %xmm0
addsd 0x183c(%rip), %xmm0     # 0x8928
movsd %xmm0, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3ecf(%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 0x17fe(%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 0x3e73(%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 0xed8(%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 0x71d0
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2633
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
testq %rax, %rax
je 0x2636
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x40(%rsp), %r15
xorl %r13d, %r13d
movq (%rbx), %rdi
addq %r12, %rdi
callq 0x50d8
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 0x50d8
cmpq %rax, %rbp
jne 0x2639
movq (%rbx), %rdi
addq %r12, %rdi
callq 0x50de
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 0x50de
cmpq %rax, %rbp
jne 0x2639
movq (%rbx), %rdi
addq %r12, %rdi
callq 0x50e4
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 0x50e4
cmpl %eax, %ebp
jne 0x2639
incq %r13
addq $0x20, %r12
cmpq 0x10(%rbx), %r13
jb 0x2588
jmp 0x2639
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_O3/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 0x26a5
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x50d8
cmpq %r12, %rax
jne 0x2698
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x50de
cmpq %r15, %rax
je 0x26a9
incq %r13
addq $0x20, %rbx
cmpq 0x10(%r14), %r13
jb 0x2678
xorl %ebx, %ebx
jmp 0x26ac
addq (%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/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 0x2705
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x50d8
cmpq %r12, %rax
jne 0x26f8
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x50de
cmpq %r15, %rax
je 0x2709
incq %r13
addq $0x20, %rbx
cmpq 0x10(%r14), %r13
jb 0x26d8
xorl %ebx, %ebx
jmp 0x270c
addq (%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/massykezzoul[P]jeu-de-la-vie/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 0x2797
cmpq %r14, %rax
jbe 0x2797
movq %rdi, %rbx
movq %r15, %rsi
movq %r14, %rdx
callq 0x26ba
testq %rax, %rax
je 0x2791
subq (%rbx), %rax
sarq $0x5, %rax
movq 0x10(%rbx), %rdx
decq %rdx
cmpq %rdx, %rax
jae 0x278d
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 0x2764
movq %rdx, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x8832(%rip), %rdi      # 0xafd0
leaq 0x488b(%rip), %rsi      # 0x7030
callq 0x2190
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
leaq 0x4c0d(%rip), %rsi      # 0x73c9
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x4870(%rip), %rsi      # 0x7046
movq %rax, %rdi
callq 0x2190
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28b1
movq %rsi, %r15
cmpq %rsi, %rax
jbe 0x28e7
cmpq %r14, %rax
jbe 0x28e7
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x26ba
testq %rax, %rax
je 0x2850
movq %rax, %rdi
movl $0x1, %esi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51c0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5072
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x29b2
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 0x8738(%rip), %r14      # 0xaff0
leaq 0x4799(%rip), %rsi      # 0x7058
movq %r14, %rdi
callq 0x2190
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x2060
movq %rax, %rdi
callq 0x20d0
leaq 0x47bc(%rip), %rsi      # 0x709e
movq %r14, %rdi
jmp 0x2929
movq 0x86e2(%rip), %rdi      # 0xafd0
leaq 0x473b(%rip), %rsi      # 0x7030
callq 0x2190
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
leaq 0x4abd(%rip), %rsi      # 0x73c9
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x4720(%rip), %rsi      # 0x7046
movq %rax, %rdi
callq 0x2190
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29a2
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 0x51eb
movzbl %al, %eax
addq %rax, %r15
incq %r13
addq $0x20, %r12
cmpq 0x10(%r14), %r13
jb 0x2980
jmp 0x29a5
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a53
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 0x2a1d
xorl %r12d, %r12d
leaq (%r14,%r12), %rdi
callq 0x5088
addq $0x20, %r12
cmpq %r12, %r13
jne 0x2a07
movq 0x10(%rbx), %r12
movq (%rbx), %rdi
testq %r12, %r12
je 0x2a46
xorl %eax, %eax
movups (%rdi,%rax), %xmm0
movups 0x10(%rdi,%rax), %xmm1
movups %xmm1, 0x10(%r14,%rax)
movups %xmm0, (%r14,%rax)
addq $0x20, %rax
decq %r12
jne 0x2a27
jmp 0x2a4b
testq %rdi, %rdi
je 0x2a50
callq 0x2210
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 0x2320
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b47
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 0x50d8
movq %rax, %r14
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x50de
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2b48
movq %rax, %r14
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x50e4
movl %eax, %ebp
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x509e
testb %al, %al
je 0x2b2e
cmpl $0x4, %ebp
jne 0x2af8
addl $-0x4, %r14d
movq (%rbx), %rdi
addq %r15, %rdi
cmpl $-0x3, %r14d
ja 0x2b14
movl $0x3, %esi
jmp 0x2b29
cmpl $0x2, %ebp
jne 0x2b2e
addl $-0x4, %r14d
cmpl $-0x3, %r14d
ja 0x2b2e
movq (%rbx), %rdi
addq %r15, %rdi
movl $0x1, %esi
jmp 0x2b29
callq 0x50e8
testq %rax, %rax
je 0x2b2e
movq (%rbx), %rdi
addq %r15, %rdi
movl $0x2, %esi
callq 0x51e8
incq %r12
addq $0x20, %r15
cmpq 0x10(%rbx), %r12
jb 0x2a96
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c21
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 0x2c17
movq %rcx, %r12
xorq %rsi, %r12
leaq (%r15,%r14), %rdx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x265a
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 0x2bd5
incq %rcx
cmpq 0x10(%rsp), %rcx
jbe 0x2bc5
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_O3/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 0x388e(%rip), %xmm1     # 0x7008
ucomiss %xmm0, %xmm1
jb 0x378d
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x378d
movss %xmm0, 0x20(%rdi)
retq
pushq %rbx
subq $0x10, %rsp
movq 0x7857(%rip), %rbx      # 0xaff0
leaq 0x396d(%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 0x3948(%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_O3/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 0x3812
movq %rsi, 0x28(%rdi)
retq
pushq %rbx
movq 0x77d6(%rip), %rbx      # 0xaff0
leaq 0x38ec(%rip), %rsi      # 0x710d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x21d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20f0
movq %rax, %rbx
leaq 0x38f5(%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_O3/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 0x3a42
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3997
callq 0x2210
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 %ecx, %ecx
movq %rax, %r12
testq %rbp, %rbp
je 0x39e2
xorl %ebp, %ebp
leaq (%r12,%rbp), %rdi
callq 0x5088
addq $0x20, %rbp
cmpq %rbp, %r13
jne 0x39cc
movq 0x18(%r14), %rcx
movq %r12, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movss 0x20(%r14), %xmm0
movss %xmm0, 0x20(%rbx)
movups 0x28(%r14), %xmm0
movups %xmm0, 0x28(%rbx)
movl 0x38(%r14), %ecx
movl %ecx, 0x38(%rbx)
testq %rax, %rax
je 0x3a42
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 0x3a1d
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_O3/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 0x3a91
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 0x3ab0
cvtsi2ss %rax, %xmm0
jmp 0x3ac5
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 0x352a(%rip), %xmm1     # 0x700c
cvttss2si %xmm1, %r13
sarq $0x3f, %rcx
andq %rcx, %r13
orq %rax, %r13
cmpq %r13, %r12
jae 0x3b3c
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 0x26ba
testq %rax, %rax
jne 0x3af6
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x27e4
incq %r12
cmpq %r13, %r12
jne 0x3af6
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a7a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3880
cmpq $0x0, 0x28(%r14)
je 0x3c25
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2b48
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x26ba
testq %rax, %rax
je 0x3bc7
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x26ba
movq %rax, %rdi
callq 0x50e4
movl %eax, %ecx
andl $-0x3, %ecx
cmpl $0x1, %ecx
jne 0x3bc9
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x271a
jmp 0x3c09
xorl %eax, %eax
testl %eax, %eax
setne %cl
cmpq $0x3, %r13
setne %dl
orb %cl, %dl
jne 0x3be9
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x27e4
jmp 0x3c09
cmpl $0x4, %eax
je 0x3bf3
cmpl $0x2, %eax
jne 0x3c09
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x26ba
movq %rax, %rdi
callq 0x51e2
incq %r12
movq 0x28(%r14), %rax
cmpq %rax, %r12
jb 0x3b73
incq %r15
cmpq %rax, %r15
jb 0x3b70
movq %rbx, %rdi
callq 0x2a7a
incq 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3c40
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3c50
callq 0x2210
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3cfc
movq %rdx, %rbx
movq %rsi, %r14
cmpq %rsi, %rax
jb 0x3d14
testq %r14, %r14
sete %cl
leaq -0x1(%rbx), %rdx
cmpq %rax, %rdx
setae %al
orb %cl, %al
jne 0x3d14
leaq -0x1(%r14), %rsi
callq 0x27e4
movq 0x7326(%rip), %r15      # 0xafd0
leaq 0x34a4(%rip), %rsi      # 0x7155
movl $0x6, %edx
movq %r15, %rdi
callq 0x21d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %r14
leaq 0x36f6(%rip), %rsi      # 0x73c9
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, %rbx
leaq 0x3467(%rip), %rsi      # 0x715c
movl $0xd, %edx
jmp 0x3d6b
movq 0x72ed(%rip), %rbx      # 0xaff0
leaq 0x3460(%rip), %rsi      # 0x716a
movl $0x11, %edx
movq %rbx, %rdi
jmp 0x3d6e
movq 0x72d5(%rip), %r15      # 0xaff0
leaq 0x330e(%rip), %rsi      # 0x7030
movl $0x15, %edx
movq %r15, %rdi
callq 0x21d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %r14
leaq 0x3685(%rip), %rsi      # 0x73c9
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, %rbx
leaq 0x32e0(%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_O3/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 0x7177(%rip), %r14      # 0xafd0
leaq 0x331c(%rip), %rsi      # 0x717c
movl $0x2, %edx
movq %r14, %rdi
callq 0x21d0
cmpq $0x0, 0x28(%rbx)
je 0x3e9e
xorl %r13d, %r13d
movq 0x7152(%rip), %r15      # 0xafd0
leaq 0x32fa(%rip), %r12      # 0x717f
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
incq %r13
cmpq 0x28(%rbx), %r13
jb 0x3e85
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 0x405a
xorl %r15d, %r15d
leaq 0x32a5(%rip), %rbp      # 0x717f
leaq 0x32a4(%rip), %r12      # 0x7185
movq %rbx, (%rsp)
movl $0x2, %edx
movq %r14, %rdi
leaq 0x3290(%rip), %rsi      # 0x7184
callq 0x21d0
cmpq $0x0, 0x28(%rbx)
je 0x3fc8
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x265a
testq %rax, %rax
je 0x3f32
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x265a
movq %rax, %rdi
callq 0x50ee
jmp 0x3fab
movl $0x3, %edx
movq %r14, %rdi
leaq 0x3246(%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 0x3224(%rip), %rsi      # 0x7192
callq 0x21d0
movl $0x3, %edx
movq %rbp, %rdi
leaq 0x3209(%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 0x31e9(%rip), %rsi      # 0x718f
callq 0x21d0
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
incq %r13
cmpq 0x28(%rbx), %r13
jb 0x3f07
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 0x317e(%rip), %rsi      # 0x717c
callq 0x21d0
cmpq $0x0, 0x28(%rbx)
je 0x4026
xorl %r13d, %r13d
movl $0x4, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x21d0
incq %r13
cmpq 0x28(%rbx), %r13
jb 0x400d
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 0x3ee5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42ea
cmpq %rbx, %rax
jbe 0x42ea
movq %rdi, %r15
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x265a
testq %rax, %rax
je 0x42d1
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
jmp 0x42e1
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5072
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x6cdf(%rip), %rdi      # 0xafd0
leaq 0x2d38(%rip), %rsi      # 0x7030
callq 0x2190
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
leaq 0x30ba(%rip), %rsi      # 0x73c9
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2060
leaq 0x2d1d(%rip), %rsi      # 0x7046
movq %rax, %rdi
callq 0x2190
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5056
movl %esi, %eax
leaq 0x247f(%rip), %rcx      # 0x747c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2483(%rip), %rsi      # 0x7490
leaq 0x2480(%rip), %rdx      # 0x7494
jmp 0x5064
leaq 0x2489(%rip), %rsi      # 0x74a6
leaq 0x2486(%rip), %rdx      # 0x74aa
jmp 0x5064
leaq 0x246e(%rip), %rsi      # 0x749b
leaq 0x246b(%rip), %rdx      # 0x749f
jmp 0x5064
leaq 0x2463(%rip), %rsi      # 0x74a0
leaq 0x2461(%rip), %rdx      # 0x74a5
jmp 0x5064
leaq 0x2448(%rip), %rsi      # 0x7495
leaq 0x2446(%rip), %rdx      # 0x749a
jmp 0x5064
leaq 0x244e(%rip), %rsi      # 0x74ab
leaq 0x2452(%rip), %rdx      # 0x74b6
movq %rbx, %rdi
callq 0x4f4c
movq %rbx, %rax
popq %rbx
retq
nop