LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: mainMenuSwitch(int&, Cart&, std::vector<Video, std::allocator<Video>>&)
void mainMenuSwitch(int &choiceMain, Cart& newCart, vector<Video> &videoList)
{
	switch (choiceMain) 
	{
		case 1: titleSearchMain(newCart, videoList);
			break;
		case 2: genreSearchMain(newCart, videoList);
			break;
		case 3: directorSearchMain(newCart, videoList);
			break;
		case 4: moviesInCartMain(newCart);
			break;
		case 5: displayPrice(newCart);
			break;
		case 6: checkOutMain(newCart, choiceMain);
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x80(%rbp)
subl $0x5, %eax
ja 0x39f2
movq -0x80(%rbp), %rax
leaq 0x56eb(%rip), %rcx      # 0x9004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a10
jmp 0x39f2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3cf0
jmp 0x39f2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x40d0
jmp 0x39f2
movq -0x10(%rbp), %rdi
callq 0x4460
jmp 0x39f2
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5550
movq -0x88(%rbp), %rdi
callq 0x4610
jmp 0x3988
leaq -0x40(%rbp), %rdi
callq 0x2700
jmp 0x39f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2700
jmp 0x39fb
movq -0x10(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5550
movq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x46a0
jmp 0x39d0
leaq -0x78(%rbp), %rdi
callq 0x2700
jmp 0x39f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2700
jmp 0x39fb
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: checkOutMain(Cart, int&)
void checkOutMain(Cart newCart, int &choiceMain)
{	
	char readyCheckOut;
	std::cout << "Ready to check out? (Y/N)" << endl;
	std::cin >> readyCheckOut;

	while (!cin || (toupper(readyCheckOut) != 'Y' && toupper(readyCheckOut) != 'N'))
	{
		std::cout << "Please enter 'Y' to proceed to check out, "<<
			"or enter 'N' to return to the main menu." << endl;
		std::cin >> readyCheckOut;
	}
	if (toupper(readyCheckOut) == 'N')
	{
		std::cout << "Returning to main menu..." << endl;
	}
	else if (toupper(readyCheckOut) == 'Y')
	{  //if user wants to check out,
		displayCheckOut(newCart);	//normal check out stuff happens,
		choiceMain = 0; //sets choiceMain = 0; sending termination
	}                 	//signal to mainMenu() to exit while loop                
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x8915(%rip), %rdi      # 0xcfd0
leaq 0x50aa(%rip), %rsi      # 0x976c
callq 0x21f0
movq %rax, %rdi
movq 0x88ef(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x8903(%rip), %rdi      # 0xcfe0
leaq -0x11(%rbp), %rsi
callq 0x22b0
movq 0x88f3(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x88e9(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
callq 0x2110
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x59(%rbp)
jne 0x4739
movsbl -0x11(%rbp), %edi
callq 0x2390
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x59, %ecx
movb %al, -0x5a(%rbp)
je 0x4733
movsbl -0x11(%rbp), %edi
callq 0x2390
cmpl $0x4e, %eax
setne %al
movb %al, -0x5a(%rbp)
movb -0x5a(%rbp), %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x4742
jmp 0x4788
movq 0x8887(%rip), %rdi      # 0xcfd0
leaq 0x5036(%rip), %rsi      # 0x9786
callq 0x21f0
movq %rax, %rdi
leaq 0x5052(%rip), %rsi      # 0x97b1
callq 0x21f0
movq %rax, %rdi
movq 0x8852(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x8866(%rip), %rdi      # 0xcfe0
leaq -0x11(%rbp), %rsi
callq 0x22b0
jmp 0x46e6
movsbl -0x11(%rbp), %edi
callq 0x2390
cmpl $0x4e, %eax
jne 0x47ba
movq 0x8833(%rip), %rdi      # 0xcfd0
leaq 0x5036(%rip), %rsi      # 0x97da
callq 0x21f0
movq %rax, %rdi
movq 0x880d(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x4812
movsbl -0x11(%rbp), %edi
callq 0x2390
cmpl $0x59, %eax
jne 0x4810
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5550
movq -0x68(%rbp), %rdi
callq 0x52a0
jmp 0x47e4
leaq -0x40(%rbp), %rdi
callq 0x2700
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x4810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2700
jmp 0x4818
jmp 0x4812
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: displayGenreSearchMenu()
void displayGenreSearchMenu()
{
	cin.clear();				//Clear bad input flag
	cin.ignore(10000, '\n');	//Discard input
	clearScreen();	//Clear screen before displaying menu
	cout << "Search Movies by: Genre\n" << endl;
	cout << "What genre of movie are you interested in watching?\n" << endl;
	cout << "1: Action" << endl;
	cout << "2: Adventure" << endl;  //split Action and Adventure into separate categories
	cout << "3: Comedy" << endl;
	cout << "4: Romance" << endl;
	cout << "5: Horror" << endl;
	cout << "6: Animation" << endl;
	cout << "7: Other" << endl;
	cout << "0: Return to Main Menu\n" << endl;  //changed 8 to 0 for consistency with title search
	cout << "Please enter a choice between 0 and 7" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x84f5(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x84eb(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2320
movq 0x84d9(%rip), %rdi      # 0xcfe0
movl $0x2710, %esi           # imm = 0x2710
movl $0xa, %edx
callq 0x2160
callq 0x2de0
movq 0x84ae(%rip), %rdi      # 0xcfd0
leaq 0x4961(%rip), %rsi      # 0x948a
callq 0x21f0
movq %rax, %rdi
movq 0x8488(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x848c(%rip), %rdi      # 0xcfd0
leaq 0x4958(%rip), %rsi      # 0x94a3
callq 0x21f0
movq %rax, %rdi
movq 0x8466(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x846a(%rip), %rdi      # 0xcfd0
leaq 0x496b(%rip), %rsi      # 0x94d8
callq 0x21f0
movq %rax, %rdi
movq 0x8444(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x8448(%rip), %rdi      # 0xcfd0
leaq 0x4953(%rip), %rsi      # 0x94e2
callq 0x21f0
movq %rax, %rdi
movq 0x8422(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x8426(%rip), %rdi      # 0xcfd0
leaq 0x493e(%rip), %rsi      # 0x94ef
callq 0x21f0
movq %rax, %rdi
movq 0x8400(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x8404(%rip), %rdi      # 0xcfd0
leaq 0x4926(%rip), %rsi      # 0x94f9
callq 0x21f0
movq %rax, %rdi
movq 0x83de(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x83e2(%rip), %rdi      # 0xcfd0
leaq 0x490f(%rip), %rsi      # 0x9504
callq 0x21f0
movq %rax, %rdi
movq 0x83bc(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x83c0(%rip), %rdi      # 0xcfd0
leaq 0x48f7(%rip), %rsi      # 0x950e
callq 0x21f0
movq %rax, %rdi
movq 0x839a(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x839e(%rip), %rdi      # 0xcfd0
leaq 0x48e2(%rip), %rsi      # 0x951b
callq 0x21f0
movq %rax, %rdi
movq 0x8378(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x837c(%rip), %rdi      # 0xcfd0
leaq 0x48c9(%rip), %rsi      # 0x9524
callq 0x21f0
movq %rax, %rdi
movq 0x8356(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x835a(%rip), %rdi      # 0xcfd0
leaq 0x48bf(%rip), %rsi      # 0x953c
callq 0x21f0
movq %rax, %rdi
movq 0x8334(%rip), %rsi      # 0xcfc0
callq 0x2220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: validateGenreMenuChoice(int&)
void validateGenreMenuChoice(int &choiceGenre)
{
	while (!cin || choiceGenre > 7 || choiceGenre < 0)
	{
		cin.clear();
		cin.ignore(10000, '\n');
		cout << "Please enter a choice between 0 and 7" << endl;
		cin >> choiceGenre;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x832d(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x8323(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
callq 0x2110
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x4ced
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x7, (%rcx)
movb %al, -0x9(%rbp)
jg 0x4ced
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
setl %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x4cf6
jmp 0x4d5f
movq 0x82e3(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x82d9(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2320
movq 0x82c7(%rip), %rdi      # 0xcfe0
movl $0x2710, %esi           # imm = 0x2710
movl $0xa, %edx
callq 0x2160
movq 0x82a1(%rip), %rdi      # 0xcfd0
leaq 0x4806(%rip), %rsi      # 0x953c
callq 0x21f0
movq %rax, %rdi
movq 0x827b(%rip), %rsi      # 0xcfc0
callq 0x2220
movq -0x8(%rbp), %rsi
movq 0x828b(%rip), %rdi      # 0xcfe0
callq 0x2140
jmp 0x4cac
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: genreSearchVector(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 genreSearchVector(const vector<Video>& videos, vector<Video>& results, string genreIn)  
//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.getGenre() == genreIn)
    		results.push_back(videos[index]);  //if video is found, add it to results
       	index++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x7aa0
movl $0x0, -0xb4(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5400
movl %eax, -0xb8(%rbp)
movl -0xb4(%rbp), %eax
cmpl -0xb8(%rbp), %eax
jge 0x4e8e
movq -0x8(%rbp), %rdi
movslq -0xb4(%rbp), %rsi
callq 0x56d0
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x56f0
jmp 0x4de6
leaq -0xe8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x7cf0
jmp 0x4dfb
movq -0xf0(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x5780
movb %al, -0xf1(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x2150
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x4e2c
jmp 0x4e7a
movq -0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xb4(%rbp), %rsi
callq 0x56d0
movq -0x100(%rbp), %rdi
movq %rax, %rsi
callq 0x5810
jmp 0x4e58
jmp 0x4e7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2900
jmp 0x4ea3
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x4db3
leaq -0xb0(%rbp), %rdi
callq 0x2900
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x2340
nop
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: displayDirectorSearchMenu()
void displayDirectorSearchMenu()
{
	clearScreen();	//Clear screen before displaying menu
	cout << "Search movies by: Director\n" << endl;
	cout << "Enter the full name of a director,\n"
		<< "or type '0' to return to the main menu." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2de0
movq 0x8110(%rip), %rdi      # 0xcfd0
leaq 0x46da(%rip), %rsi      # 0x95a1
callq 0x21f0
movq %rax, %rdi
movq 0x80ea(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x80ee(%rip), %rdi      # 0xcfd0
leaq 0x46d4(%rip), %rsi      # 0x95bd
callq 0x21f0
movq %rax, %rdi
leaq 0x46e9(%rip), %rsi      # 0x95e1
callq 0x21f0
movq %rax, %rdi
movq 0x80b9(%rip), %rsi      # 0xcfc0
callq 0x2220
popq %rbp
retq
nop
// File: 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
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x7aa0
movl $0x0, -0xb4(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5400
movl %eax, -0xb8(%rbp)
movl -0xb4(%rbp), %eax
cmpl -0xb8(%rbp), %eax
jge 0x502e
movq -0x8(%rbp), %rdi
movslq -0xb4(%rbp), %rsi
callq 0x56d0
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x56f0
jmp 0x4f86
leaq -0xe8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x7d20
jmp 0x4f9b
movq -0xf0(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x5780
movb %al, -0xf1(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x2150
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x4fcc
jmp 0x501a
movq -0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xb4(%rbp), %rsi
callq 0x56d0
movq -0x100(%rbp), %rdi
movq %rax, %rsi
callq 0x5810
jmp 0x4ff8
jmp 0x501a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2900
jmp 0x5043
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x4f53
leaq -0xb0(%rbp), %rdi
callq 0x2900
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x2340
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x82a0
callq 0x2de0
jmp 0x5073
leaq -0x20(%rbp), %rdi
callq 0x5670
testb $0x1, %al
jne 0x5082
jmp 0x50c3
movq 0x7f47(%rip), %rdi      # 0xcfd0
leaq 0x4659(%rip), %rsi      # 0x96e9
callq 0x21f0
movq %rax, -0x58(%rbp)
jmp 0x509b
movq -0x58(%rbp), %rdi
movq 0x7f1a(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x50ad
jmp 0x51b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x51cd
movq 0x7f06(%rip), %rdi      # 0xcfd0
leaq 0x462c(%rip), %rsi      # 0x96fd
callq 0x21f0
movq %rax, -0x60(%rbp)
jmp 0x50dc
movq -0x60(%rbp), %rdi
movq 0x7ed9(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x50ee
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x81f0
movl %eax, -0x64(%rbp)
jmp 0x5109
movl -0x68(%rbp), %eax
movl -0x64(%rbp), %ecx
cmpl %ecx, %eax
jge 0x51b2
movl -0x30(%rbp), %esi
incl %esi
movq 0x7ead(%rip), %rdi      # 0xcfd0
callq 0x2330
movq %rax, -0x70(%rbp)
jmp 0x512e
movq -0x70(%rbp), %rdi
leaq 0x434e(%rip), %rsi      # 0x9487
callq 0x21f0
movq %rax, -0x78(%rbp)
jmp 0x5144
movslq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5430
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x7cc0
jmp 0x515f
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x21e0
movq %rax, -0x80(%rbp)
jmp 0x5172
movq -0x80(%rbp), %rdi
movq 0x7e43(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x5184
leaq -0x50(%rbp), %rdi
callq 0x2150
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x50f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2150
jmp 0x51cd
jmp 0x51b4
callq 0x2e00
jmp 0x51bb
leaq -0x20(%rbp), %rdi
callq 0x26a0
addq $0x80, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x26a0
movq -0x28(%rbp), %rdi
callq 0x2340
nop
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x7dee(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x7de4(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
callq 0x2110
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x5(%rbp)
jne 0x5226
movb $0x1, %al
cmpl $0x4, -0x4(%rbp)
movb %al, -0x5(%rbp)
jg 0x5226
cmpl $0x1, -0x4(%rbp)
setl %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x522f
jmp 0x5298
movq 0x7daa(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x7da0(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2320
movq 0x7d8e(%rip), %rdi      # 0xcfe0
movl $0x2710, %esi           # imm = 0x2710
movl $0xa, %edx
callq 0x2160
movq 0x7d68(%rip), %rdi      # 0xcfd0
leaq 0x44aa(%rip), %rsi      # 0x9719
callq 0x21f0
movq %rax, %rdi
movq 0x7d42(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x7d56(%rip), %rdi      # 0xcfe0
leaq -0x4(%rbp), %rsi
callq 0x2140
jmp 0x51eb
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x7d19(%rip), %rdi      # 0xcfd0
leaq 0x4536(%rip), %rsi      # 0x97f4
callq 0x21f0
movq %rax, %rdi
movq 0x7cf3(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x7cf7(%rip), %rdi      # 0xcfd0
leaq 0x4539(%rip), %rsi      # 0x9819
callq 0x21f0
movq %rax, %rdi
leaq 0x591(%rip), %rsi       # 0x5880
callq 0x20b0
movq %rax, -0x28(%rbp)
movl $0x2, %edi
callq 0x58b0
movq -0x28(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
callq 0x2300
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x8230
movq -0x18(%rbp), %rdi
callq 0x23a0
movq %rax, %rdi
movq 0x7c8f(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x7c93(%rip), %rdi      # 0xcfd0
leaq 0x44ec(%rip), %rsi      # 0x9830
callq 0x21f0
movq %rax, %rdi
movq 0x7c6d(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x7c71(%rip), %rdi      # 0xcfd0
leaq 0x450f(%rip), %rsi      # 0x9875
callq 0x21f0
movq %rax, %rdi
movq 0x7c4b(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x7c4f(%rip), %rdi      # 0xcfd0
leaq 0x4501(%rip), %rsi      # 0x9889
callq 0x21f0
movq %rax, %rdi
movq 0x7c29(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x7c2d(%rip), %rdi      # 0xcfd0
leaq 0x44ed(%rip), %rsi      # 0x9897
callq 0x21f0
movq %rax, %rdi
movq 0x7c07(%rip), %rsi      # 0xcfc0
callq 0x2220
callq 0x2e00
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x22d0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x22d0
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x38(%rbp)
callq 0x22d0
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x30(%rbp)
callq 0x22d0
movq -0x20(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2680
movq -0x20(%rbp), %rdi
leaq 0x1ddc(%rip), %rsi      # 0x98eb
callq 0x22c0
jmp 0x7b16
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
leaq 0x1dca(%rip), %rsi      # 0x98ef
callq 0x22c0
jmp 0x7b2c
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1db0(%rip), %rsi      # 0x98eb
callq 0x22c0
jmp 0x7b42
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
leaq 0x1d9a(%rip), %rsi      # 0x98eb
callq 0x22c0
jmp 0x7b58
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x26a0
movq -0x30(%rbp), %rdi
callq 0x2150
movq -0x38(%rbp), %rdi
callq 0x2150
movq -0x40(%rbp), %rdi
callq 0x2150
movq -0x20(%rbp), %rdi
callq 0x2150
movq -0x10(%rbp), %rdi
callq 0x2340
// File: 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
subq $0x90, %rsp
movq %rsi, -0x40(%rbp)
movq %rdx, -0x88(%rbp)
movq %rcx, -0x80(%rbp)
movq %r8, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x22d0
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x22d0
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x60(%rbp)
callq 0x22d0
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x58(%rbp)
callq 0x22d0
movq -0x48(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x50(%rbp)
callq 0x2680
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2030
jmp 0x7c39
movq -0x88(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x2030
jmp 0x7c4f
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
callq 0x2030
jmp 0x7c62
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x60, %rdi
callq 0x2030
jmp 0x7c75
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x26a0
movq -0x58(%rbp), %rdi
callq 0x2150
movq -0x60(%rbp), %rdi
callq 0x2150
movq -0x68(%rbp), %rdi
callq 0x2150
movq -0x48(%rbp), %rdi
callq 0x2150
movq -0x30(%rbp), %rdi
callq 0x2340
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rsi, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x522f(%rip), %rdi      # 0xcfd0
leaq 0x1b4d(%rip), %rsi      # 0x98f5
callq 0x21f0
movq -0xc0(%rbp), %rsi
movq %rax, -0xb8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x7cc0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x21e0
movq %rax, -0xa8(%rbp)
jmp 0x7de7
movq -0xa8(%rbp), %rdi
movq 0x51cb(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x7dfc
leaq -0x30(%rbp), %rdi
callq 0x2150
movq 0x51c4(%rip), %rdi      # 0xcfd0
leaq 0x1aea(%rip), %rsi      # 0x98fd
callq 0x21f0
movq -0xc0(%rbp), %rsi
movq %rax, -0xd8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x7cf0
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x21e0
movq %rax, -0xc8(%rbp)
jmp 0x7e52
movq -0xc8(%rbp), %rdi
movq 0x5160(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x7e67
leaq -0x60(%rbp), %rdi
callq 0x2150
movq 0x5159(%rip), %rdi      # 0xcfd0
leaq 0x1a87(%rip), %rsi      # 0x9905
callq 0x21f0
movq -0xc0(%rbp), %rsi
movq %rax, -0xf0(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x7d20
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
callq 0x21e0
movq %rax, -0xe0(%rbp)
jmp 0x7ebd
movq -0xe0(%rbp), %rdi
movq 0x50f5(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x7ed2
leaq -0x80(%rbp), %rdi
callq 0x2150
movq 0x50ee(%rip), %rdi      # 0xcfd0
leaq 0x1a27(%rip), %rsi      # 0x9910
callq 0x21f0
movq -0xc0(%rbp), %rsi
movq %rax, -0x108(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x7d50
movq -0x108(%rbp), %rdi
movq -0x100(%rbp), %rsi
callq 0x21e0
movq %rax, -0xf8(%rbp)
jmp 0x7f2b
movq -0xf8(%rbp), %rdi
movq 0x5087(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x7f40
leaq -0xa0(%rbp), %rdi
callq 0x2150
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2150
jmp 0x7fb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2150
jmp 0x7fb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x2150
jmp 0x7fb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2150
movq -0x38(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/Video.cpp
// Function: Video::searchTitle(std::vector<Video, std::allocator<Video>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Video::searchTitle(const std::vector<Video>& videos, std::string titleIn)
{
    Video result, temp;
    int index = 0;
    int size = videos.size();
    bool found = false;
    while(index < size && !found)
    {
       temp = videos[index];
       if(temp.getTitle() == titleIn)
       {
          found = true;
          result = videos[index]; 
       }
       index++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdx, -0x188(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x7aa0
leaq -0x148(%rbp), %rdi
callq 0x7aa0
jmp 0x8028
movl $0x0, -0x158(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5400
movl %eax, -0x15c(%rbp)
movb $0x0, -0x15d(%rbp)
movl -0x158(%rbp), %ecx
xorl %eax, %eax
cmpl -0x15c(%rbp), %ecx
movb %al, -0x189(%rbp)
jge 0x806c
movb -0x15d(%rbp), %al
xorb $-0x1, %al
movb %al, -0x189(%rbp)
movb -0x189(%rbp), %al
testb $0x1, %al
jne 0x807b
jmp 0x8154
movq -0x10(%rbp), %rdi
movslq -0x158(%rbp), %rsi
callq 0x56d0
movq %rax, %rsi
leaq -0x148(%rbp), %rdi
callq 0x56f0
jmp 0x809c
leaq -0x180(%rbp), %rdi
leaq -0x148(%rbp), %rsi
callq 0x7cc0
jmp 0x80b1
movq -0x188(%rbp), %rsi
leaq -0x180(%rbp), %rdi
callq 0x5780
movb %al, -0x18a(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x2150
movb -0x18a(%rbp), %al
testb $0x1, %al
jne 0x80e2
jmp 0x8140
movb $0x1, -0x15d(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x158(%rbp), %rsi
callq 0x56d0
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x56f0
jmp 0x810a
jmp 0x8140
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
jmp 0x8175
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x2900
jmp 0x8175
movl -0x158(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x158(%rbp)
jmp 0x8048
leaq -0x148(%rbp), %rdi
callq 0x2900
leaq -0xb0(%rbp), %rdi
callq 0x2900
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
leaq -0xb0(%rbp), %rdi
callq 0x2900
movq -0x150(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, (%rax)
jne 0x83b4
movq 0x4c9c(%rip), %rdi      # 0xcfd0
movq 0x4c85(%rip), %rsi      # 0xcfc0
callq 0x2220
movq %rax, %rdi
leaq 0x15d6(%rip), %rsi      # 0x9920
callq 0x21f0
movq %rax, %rdi
movq 0x4c67(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x4c7b(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x4c71(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2320
movq 0x4c5f(%rip), %rdi      # 0xcfe0
movl $0x400, %esi            # imm = 0x400
movl $0xa, %edx
callq 0x2160
movq 0x4c39(%rip), %rdi      # 0xcfd0
leaq 0xccd(%rip), %rsi       # 0x906b
callq 0x21f0
movq 0x4c36(%rip), %rdi      # 0xcfe0
callq 0x2270
jmp 0x8472
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x58(%rbp)
callq 0x5400
movq -0x58(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0x5430
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7cc0
movq -0x50(%rbp), %rsi
movq 0x4be1(%rip), %rdi      # 0xcfd0
callq 0x21e0
movq %rax, -0x48(%rbp)
jmp 0x83fa
movq -0x48(%rbp), %rdi
leaq 0x1537(%rip), %rsi      # 0x993c
callq 0x21f0
movq %rax, -0x60(%rbp)
jmp 0x8410
movq -0x60(%rbp), %rdi
movq 0x4ba5(%rip), %rsi      # 0xcfc0
callq 0x2220
jmp 0x8422
leaq -0x28(%rbp), %rdi
callq 0x2150
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
callq 0x8490
movq -0x40(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movsd 0x8(%rax), %xmm0
movsd 0x14c8(%rip), %xmm1     # 0x9918
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x8472
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2150
jmp 0x8478
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x58e0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jne 0x38b7
jmp 0x376f
movq -0x90(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x91(%rbp)
jae 0x3881
movq -0x90(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7250
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x5a40
leaq -0x40(%rbp), %rdi
callq 0x7250
movq -0xa0(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x91(%rbp)
jne 0x3881
movq -0x90(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7270
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x5a40
leaq -0x60(%rbp), %rdi
callq 0x7270
movq -0xa8(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x91(%rbp)
jne 0x3881
movq -0x90(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7290
movl %eax, -0xac(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x5a40
leaq -0x80(%rbp), %rdi
callq 0x7290
movl %eax, %ecx
movl -0xac(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x388d
jmp 0x389e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x376f
movq -0x90(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x38bb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::at(unsigned long, unsigned long) const
const Cellule* Population::at(size_t i, size_t j) const {
  for (size_t k = 0 ; k < alive ; k++) {
    if ((T[k].get_x() == i) && (T[k].get_y() == j)) {
      return T+k;
    }
  }
  return NULL; /* La cellule n'existe pas dans le tableau */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x3994
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7250
cmpq -0x18(%rbp), %rax
jne 0x3984
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7270
cmpq -0x20(%rbp), %rax
jne 0x3984
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x399c
jmp 0x3986
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3924
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::at(unsigned long, unsigned long)
Cellule* Population::at(size_t i, size_t j)  {
  for (size_t k = 0 ; k < alive ; k++) {
    if ((T[k].get_x() == i) && (T[k].get_y() == j)) {
      return T+k;
    }
  }
  return NULL; /* La cellule n'existe pas dans le tableau */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x3a44
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7250
cmpq -0x18(%rbp), %rax
jne 0x3a34
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7270
cmpq -0x20(%rbp), %rax
jne 0x3a34
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x3a4c
jmp 0x3a36
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x39d4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x3a94
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x28(%rcx), %rax
jb 0x3ae2
movq 0xa535(%rip), %rdi      # 0xdfd0
leaq 0x6596(%rip), %rsi      # 0xa038
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x6914(%rip), %rsi      # 0xa3d1
callq 0x3250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x6576(%rip), %rsi      # 0xa04e
callq 0x3250
callq 0x30d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3b8d
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x5, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3b7d
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rax), %rax
movq -0x28(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3b18
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq 0x10(%rdx), %rax
addq $0x1, %rax
movq 0x28(%rdx), %rcx
imulq 0x28(%rdx), %rcx
cmpq %rcx, %rax
jae 0x3cb3
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x3bf2
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x28(%rcx), %rax
jb 0x3c40
movq 0xa3d7(%rip), %rdi      # 0xdfd0
leaq 0x6438(%rip), %rsi      # 0xa038
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x67b6(%rip), %rsi      # 0xa3d1
callq 0x3250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x6418(%rip), %rsi      # 0xa04e
callq 0x3250
callq 0x30d0
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3ca3
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x70a0
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x3d10
jmp 0x3cb1
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x73e0
jmp 0x3cfd
movq 0xa336(%rip), %rdi      # 0xdff0
leaq 0x639f(%rip), %rsi      # 0xa060
callq 0x3250
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x30a0
movq %rax, %rdi
movq 0xa2e0(%rip), %rsi      # 0xdfc0
callq 0x3270
movq 0xa304(%rip), %rdi      # 0xdff0
leaq 0x63b3(%rip), %rsi      # 0xa0a6
callq 0x3250
callq 0x30d0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x3df1
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x74a0
testb $0x1, %al
jne 0x3dd5
jmp 0x3de1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3de3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3da7
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rcx), %rax
cmpq 0x18(%rcx), %rax
jb 0x3f58
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
shlq %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3040
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3ead
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7100
jmp 0x3e98
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x3e89
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x3f33
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3ebd
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3440
jmp 0x3f5e
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x3f4d
movq -0x68(%rbp), %rdi
callq 0x3320
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33f0
nopw (%rax,%rax)
// File: massykezzoul[P]jeu-de-la-vie/population/population.cpp
// Function: Population::update_color()
void Population::update_color() {
	for (size_t k = 0; k < alive; ++k){
		int voisines = nb_voisines(T[k].get_x(),T[k].get_y());
		Couleur c = T[k].get_couleur();
		if(T[k].get_vivante()) {
			if (c == BLEU) {
				//La cellule vient de naitre 
				if ((voisines != 2) && 	(voisines != 3))
					T[k].set_color(JAUNE); // meurent au prochain tour
				else if ((T[k].get_age() > 0)) {
					T[k].set_color(VERT); // Age > 0
				}
			} else if ( (c == VERT) && (voisines != 2) && (voisines != 3) ) {
				//Meurent au prochain tour 
				T[k].set_color(ROUGE);
			}
		}
	}				
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x40e7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7250
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7270
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
movq %rax, %rdx
callq 0x40f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7290
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7130
testb $0x1, %al
jne 0x4035
jmp 0x40d4
cmpl $0x4, -0x18(%rbp)
jne 0x40a2
cmpl $0x2, -0x14(%rbp)
je 0x4065
cmpl $0x3, -0x14(%rbp)
je 0x4065
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl $0x3, %esi
callq 0x7480
jmp 0x40a0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x72a0
cmpq $0x0, %rax
jbe 0x409e
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl $0x2, %esi
callq 0x7480
jmp 0x40a0
jmp 0x40d2
cmpl $0x2, -0x18(%rbp)
jne 0x40d0
cmpl $0x2, -0x14(%rbp)
je 0x40d0
cmpl $0x3, -0x14(%rbp)
je 0x40d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x7480
jmp 0x40d2
jmp 0x40d4
jmp 0x40d6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3f9c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4128
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x4134
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x415b
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x4167
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4180
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x418c
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x41b3
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x41bf
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x4242
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0x4232
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x3900
cmpq $0x0, %rax
je 0x4222
movq -0x10(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x4216
movq -0x18(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x4222
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4224
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x41e1
jmp 0x4234
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x41cf
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movss 0x507b(%rip), %xmm0     # 0xa00c
ucomiss -0xc(%rbp), %xmm0
jb 0x4fb4
movss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x4fb4
movq -0x18(%rbp), %rax
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x20(%rax)
jmp 0x4ff2
movq 0x9035(%rip), %rdi      # 0xdff0
leaq 0x5153(%rip), %rsi      # 0xa115
callq 0x3250
movq %rax, %rdi
movss -0xc(%rbp), %xmm0
callq 0x31c0
movq %rax, %rdi
leaq 0x5140(%rip), %rsi      # 0xa11e
callq 0x3250
movq %rax, %rdi
movq 0x8fd3(%rip), %rsi      # 0xdfc0
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)