LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/add_item.cc
// Function: main
int main() 
{
    Sales_item item1, item2;

    std::cin >> item1 >> item2;   //read a pair of transactions
    std::cout << item1 + item2 << std::endl; //print their sum

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x16b0
leaq -0x68(%rbp), %rdi
callq 0x16b0
movq -0xb8(%rbp), %rsi
movq 0x2a77(%rip), %rdi      # 0x3fe0
callq 0x1320
movq %rax, -0xb0(%rbp)
jmp 0x1577
movq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1320
jmp 0x1589
leaq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x12c0
jmp 0x159f
movq 0x2a2a(%rip), %rdi      # 0x3fd0
leaq -0xa8(%rbp), %rsi
callq 0x13d0
movq %rax, -0xc0(%rbp)
jmp 0x15bb
movq -0xc0(%rbp), %rdi
movq 0x29f7(%rip), %rsi      # 0x3fc0
callq 0x10b0
jmp 0x15d0
leaq -0xa8(%rbp), %rdi
callq 0x1690
movl $0x0, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1690
leaq -0x38(%rbp), %rdi
callq 0x1690
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1627
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1690
leaq -0x68(%rbp), %rdi
callq 0x1690
leaq -0x38(%rbp), %rdi
callq 0x1690
movq -0x70(%rbp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/test10.cpp
// Function: main
int main()
{
	char *argv5[] = {"Foo", 0};
	const char *argv6[] = {"Foo", 0};
	const char * const argv7[] = {"Foo", 0};
	char **argv1 = argv5;
	const char **argv2 = argv6;
	const char * const * argv3 = argv7;
	const char * const * const argv4 = argv7;

	CmdLine cmd("Command description message", ' ', "0.9");
	cmd.parse(0, argv1);
	cmd.parse(0, argv2);
	cmd.parse(0, argv3);
	cmd.parse(0, argv4);
	cmd.parse(0, argv5);
	cmd.parse(0, argv6);
	cmd.parse(0, argv7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movaps 0x1435e(%rip), %xmm0    # 0x18930
movaps %xmm0, -0x10(%rbp)
movaps 0x14363(%rip), %xmm0    # 0x18940
movaps %xmm0, -0x20(%rbp)
movaps 0x14368(%rip), %xmm0    # 0x18950
movaps %xmm0, -0x30(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x151(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x43f0
movq -0x198(%rbp), %rdx
leaq 0xca0d(%rip), %rsi      # 0x11036
leaq -0x150(%rbp), %rdi
callq 0x4df0
jmp 0x4637
leaq -0x189(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x43f0
movq -0x1a0(%rbp), %rdx
leaq 0xc9fa(%rip), %rsi      # 0x11052
leaq -0x188(%rbp), %rdi
callq 0x4df0
jmp 0x4666
leaq -0x130(%rbp), %rdi
leaq -0x150(%rbp), %rsi
movl $0x20, %edx
leaq -0x188(%rbp), %rcx
movl $0x1, %r8d
callq 0x63a0
jmp 0x468d
leaq -0x188(%rbp), %rdi
callq 0x4488
leaq -0x189(%rbp), %rdi
callq 0x4280
leaq -0x150(%rbp), %rdi
callq 0x4488
leaq -0x151(%rbp), %rdi
callq 0x4280
movq -0x38(%rbp), %rdx
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
callq 0x6570
jmp 0x46d1
movq -0x40(%rbp), %rdx
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
callq 0x6570
jmp 0x46e5
movq -0x48(%rbp), %rdx
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
callq 0x6570
jmp 0x46f9
movq -0x50(%rbp), %rdx
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
callq 0x6570
jmp 0x470d
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
leaq -0x10(%rbp), %rdx
callq 0x6570
jmp 0x4721
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
leaq -0x20(%rbp), %rdx
callq 0x6570
jmp 0x4735
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
leaq -0x30(%rbp), %rdx
callq 0x6570
jmp 0x4749
leaq -0x130(%rbp), %rdi
callq 0x62a0
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
jmp 0x47be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
jmp 0x47a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4488
leaq -0x189(%rbp), %rdi
callq 0x4280
leaq -0x150(%rbp), %rdi
callq 0x4488
leaq -0x151(%rbp), %rdi
callq 0x4280
jmp 0x47ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x62a0
movq -0x160(%rbp), %rdi
callq 0x43e0
nopw %cs:(%rax,%rax)
// File: parth-shel[P]xpac/client.cpp
// Function: xpac_init()
static void xpac_init(){
	//Handling the xpac directory:
	xpac_dir_handler(xpac_dir);
	//Handling the metadata directory:
	xpac_dir_handler(metadata_dir);
	//Getting the latest updates from xpac:
	update_file_handler();
	//Handling the base package:
	base_handler();
	//Parsing the universe:
	parse_universe_of_packages(universe_file);
	//Calculating the users' packages:
	calculate_users_packages();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x16b8e(%rip), %rsi     # 0x1e430
leaq -0x20(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x41d0
movq -0x78(%rbp), %rdi
callq 0x8c90
jmp 0x78ba
leaq -0x20(%rbp), %rdi
callq 0x47e8
leaq 0x16b86(%rip), %rsi     # 0x1e450
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x41d0
movq -0x80(%rbp), %rdi
callq 0x8c90
jmp 0x78e2
leaq -0x50(%rbp), %rdi
callq 0x47e8
callq 0x8d20
callq 0x8d40
leaq 0x16b74(%rip), %rsi     # 0x1e470
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x41d0
movq -0x88(%rbp), %rdi
callq 0x120e0
jmp 0x791a
leaq -0x70(%rbp), %rdi
callq 0x47e8
callq 0x12710
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x47e8
jmp 0x7974
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x47e8
jmp 0x7974
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x47e8
movq -0x28(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: parth-shel[P]xpac/client.cpp
// Function: xpac_dir_handler(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static inline void xpac_dir_handler(std::string filepath){
	DIR* dir = opendir(filepath.c_str());
	if (dir)
	{
		closedir(dir);  //Directory exists and we don't need to so anything
	}
	else if (ENOENT == errno)
	{
		//Directory does not exist. So we need to create it
		std::cout<<"Creating the directory: "<<filepath<<std::endl;
		mkdir(filepath.c_str(),0775);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x41c0
movq %rax, %rdi
callq 0x45f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8cc3
movq -0x10(%rbp), %rdi
callq 0x4640
jmp 0x8d1a
callq 0x4060
movq %rax, %rcx
movl $0x2, %eax
cmpl (%rcx), %eax
jne 0x8d18
movq 0x152f5(%rip), %rdi     # 0x1dfd0
leaq 0xc8e8(%rip), %rsi      # 0x155ca
callq 0x4400
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x43d0
movq %rax, %rdi
movq 0x152bb(%rip), %rsi     # 0x1dfb8
callq 0x4440
movq -0x18(%rbp), %rdi
callq 0x41c0
movq %rax, %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x4220
jmp 0x8d1a
addq $0x20, %rsp
popq %rbp
retq
// File: parth-shel[P]xpac/client_socket.cpp
// Function: client_driver(char*, char*)
int client_driver(char * command, char * ip) {
 	int sock_fd;
 	struct sockaddr_in srv_addr;
 	
	memset(&srv_addr, 0, sizeof(srv_addr));

 	// create a client socket
 	sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 	srv_addr.sin_family = AF_INET; // internet address

	// DNS lookup
	char * IP = (char *) malloc(128 * sizeof(char));
	if( hostname_to_ip(ip, IP) < 0 ) {
		printf("DNS lookup failure\n");
		exit(EXIT_FAILURE);
	}

 	// convert command line argument to numeric IP
 	if ( inet_pton(AF_INET, IP, &(srv_addr.sin_addr)) < 1 ) {
 		printf("invalid IP address\n");
		exit(EXIT_FAILURE);
 	}

 	// use specified port number or default otherwise
	// TODO: WORK ON PORT SELECTION
 	srv_addr.sin_port = htons(SRV_PORT);

 	if( connect(sock_fd, (struct sockaddr*) &srv_addr, sizeof(srv_addr)) < 0 ) {
 		perror("connect error");
 		exit(EXIT_FAILURE);
 	}
 	else {
 		printf("connected to:%s:%d ..\n",ip,SRV_PORT);
 	}
 
	if( recv_file(sock_fd, command) < 0 ) { // command
		//perror("receive error\n");
		//exit(EXIT_FAILURE);
		return -1;
	}
 	
	// close socket
 	if(close(sock_fd) < 0) {
 		perror("socket close error");
 		exit(EXIT_FAILURE);
 	}
 
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4280
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x4120
movl %eax, -0x1c(%rbp)
movw $0x2, -0x2c(%rbp)
movl $0x80, %edi
callq 0x4550
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x10e20
cmpl $0x0, %eax
jge 0x10d45
leaq 0x49b5(%rip), %rdi      # 0x156e9
movb $0x0, %al
callq 0x4070
movl $0x1, %edi
callq 0x44c0
movq -0x38(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x4760
cmpl $0x1, %eax
jge 0x10d78
leaq 0x4996(%rip), %rdi      # 0x156fd
movb $0x0, %al
callq 0x4070
movl $0x1, %edi
callq 0x44c0
movl $0x13f4, %edi           # imm = 0x13F4
callq 0x4090
movw %ax, -0x2a(%rbp)
movl -0x1c(%rbp), %edi
leaq -0x2c(%rbp), %rsi
movl $0x10, %edx
callq 0x4370
cmpl $0x0, %eax
jge 0x10db2
leaq 0x496e(%rip), %rdi      # 0x15711
callq 0x4380
movl $0x1, %edi
callq 0x44c0
movq -0x18(%rbp), %rsi
leaq 0x4962(%rip), %rdi      # 0x1571f
movl $0x13f4, %edx           # imm = 0x13F4
movb $0x0, %al
callq 0x4070
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x10ec0
cmpl $0x0, %eax
jge 0x10de3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10e0d
movl -0x1c(%rbp), %edi
callq 0x47a0
cmpl $0x0, %eax
jge 0x10e06
leaq 0x493f(%rip), %rdi      # 0x15736
callq 0x4380
movl $0x1, %edi
callq 0x44c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: parth-shel[P]xpac/client_socket.cpp
// Function: hostname_to_ip(char*, char*)
int hostname_to_ip(char * hostname, char * ip) {
	struct hostent *ptrh;
    	struct in_addr **addr_list;
         
    	// get host info
	if ( (ptrh = gethostbyname( hostname ) ) == NULL) {
       	 	perror("gethostbyname error\n");
        	return -1;
    	}
 
    	addr_list = (struct in_addr **) ptrh->h_addr_list;
     
    	for(int i = 0; addr_list[i] != NULL; i++) {
        	strcpy(ip , inet_ntoa(*addr_list[i]) );
        	return 0;
    	}
     
    	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4490
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x10e58
leaq 0x48ff(%rip), %rdi      # 0x15749
callq 0x4380
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10eb7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x10eb0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %edi
callq 0x4200
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x43e0
movl $0x0, -0x4(%rbp)
jmp 0x10eb7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: parth-shel[P]xpac/metadata.cpp
// Function: metadata::metadata(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
metadata::metadata(std::string pkg_name,std::string pkg_ver){
	this->pkg_name = pkg_name;
	this->pkg_ver = pkg_ver;
	this->str_hash = new std::hash<std::string>;
	pkg_id = std::to_string((*str_hash)(this->pkg_name + this->pkg_ver));
	dep_list = new std::vector<std::string>;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x70(%rbp)
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
callq 0x4580
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x88(%rbp)
callq 0x4580
movq -0x78(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x80(%rbp)
callq 0x4580
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x4050
jmp 0x113bd
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
addq $0x40, %rdi
callq 0x4050
jmp 0x113d6
movl $0x1, %edi
callq 0x4410
movq %rax, -0xa0(%rbp)
jmp 0x113e9
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rax
movq %rax, 0x68(%rsi)
movq 0x68(%rsi), %rax
movq %rax, -0xa8(%rbp)
movq %rsi, %rdx
addq $0x40, %rdx
leaq -0x68(%rbp), %rdi
callq 0x11e90
jmp 0x11418
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb2f0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0xb210
jmp 0x11436
movq -0x90(%rbp), %rdi
addq $0x20, %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x44d0
movq -0xb8(%rbp), %rdi
callq 0x47e8
leaq -0x68(%rbp), %rdi
callq 0x47e8
movl $0x18, %edi
callq 0x4410
movq %rax, -0xb0(%rbp)
jmp 0x11479
movq -0xb0(%rbp), %rdi
callq 0x9360
movq -0xb0(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x60(%rax)
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x114c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x47e8
movq -0x80(%rbp), %rdi
callq 0x47e8
movq -0x88(%rbp), %rdi
callq 0x47e8
movq -0x78(%rbp), %rdi
callq 0x47e8
movq -0x20(%rbp), %rdi
callq 0x46d0
nopw (%rax,%rax)
// File: parth-shel[P]xpac/installed_packages_modules.cpp
// Function: calculate_users_packages()
void calculate_users_packages(){
	std::ifstream file;
	file.open(installed_file);
	std::string next_installed;
	while (getline(file,next_installed)) {
		int index = next_installed.find(" ");
		std::string name = next_installed.substr(0,index);
		std::string version = next_installed.substr(index+1, std::string::npos);
		user_installed_list.insert(std::make_pair(name,version));
	}
	file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
leaq -0x208(%rbp), %rdi
movq %rdi, -0x2d8(%rbp)
callq 0x4480
movq -0x2d8(%rbp), %rdi
leaq 0xbf14(%rip), %rsi      # 0x1e650
movl $0x8, %edx
callq 0x43b0
jmp 0x12748
leaq -0x238(%rbp), %rdi
callq 0x4580
leaq -0x208(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x40e0
movq %rax, -0x2e0(%rbp)
jmp 0x12770
movq -0x2e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4500
movb %al, -0x2e1(%rbp)
jmp 0x1278e
movb -0x2e1(%rbp), %al
testb $0x1, %al
jne 0x1279d
jmp 0x12921
leaq 0x2d65(%rip), %rsi      # 0x15509
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x2f0(%rbp)
leaq -0x238(%rbp), %rdi
movq %rdi, -0x2f8(%rbp)
callq 0x47c0
movq -0x2f8(%rbp), %rsi
movq -0x2f0(%rbp), %rdx
movl %eax, -0x23c(%rbp)
movslq -0x23c(%rbp), %rcx
leaq -0x260(%rbp), %rdi
callq 0x4420
jmp 0x127eb
movl -0x23c(%rbp), %eax
incl %eax
movslq %eax, %rdx
leaq -0x280(%rbp), %rdi
leaq -0x238(%rbp), %rsi
movq $-0x1, %rcx
callq 0x4420
jmp 0x12812
leaq -0x2c0(%rbp), %rdi
leaq -0x260(%rbp), %rsi
leaq -0x280(%rbp), %rdx
callq 0x124a0
jmp 0x1282e
leaq 0xbe3b(%rip), %rdi      # 0x1e670
leaq -0x2c0(%rbp), %rsi
callq 0x97a0
movb %dl, -0x301(%rbp)
movq %rax, -0x300(%rbp)
jmp 0x12850
movb -0x301(%rbp), %al
movq -0x300(%rbp), %rcx
movq %rcx, -0x2d0(%rbp)
movb %al, -0x2c8(%rbp)
leaq -0x2c0(%rbp), %rdi
callq 0x9850
leaq -0x280(%rbp), %rdi
callq 0x47e8
leaq -0x260(%rbp), %rdi
callq 0x47e8
jmp 0x12754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x1295c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x12950
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x12913
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x12907
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x2c0(%rbp), %rdi
callq 0x9850
leaq -0x280(%rbp), %rdi
callq 0x47e8
leaq -0x260(%rbp), %rdi
callq 0x47e8
jmp 0x12950
leaq -0x208(%rbp), %rdi
callq 0x4100
jmp 0x1292f
leaq -0x238(%rbp), %rdi
callq 0x47e8
leaq -0x208(%rbp), %rdi
callq 0x4140
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
leaq -0x238(%rbp), %rdi
callq 0x47e8
leaq -0x208(%rbp), %rdi
callq 0x4140
movq -0x210(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: parth-shel[P]xpac/installed_packages_modules.cpp
// Function: add_to_install_list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void add_to_install_list(std::string name, std::string version) {
	std::fstream file;
	file.open(installed_file, std::ios::out | std::ios::app);

	// Simply appending to file
	file << name << " " << version <<"\n";

	file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x240(%rbp)
movq %rsi, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x44b0
movl $0x10, %edi
movl $0x1, %esi
callq 0x95c0
movl %eax, -0x230(%rbp)
jmp 0x129c4
movl -0x230(%rbp), %edx
leaq 0xbc7f(%rip), %rsi      # 0x1e650
leaq -0x220(%rbp), %rdi
callq 0x4570
jmp 0x129df
movq -0x240(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x43d0
movq %rax, -0x248(%rbp)
jmp 0x129fb
movq -0x248(%rbp), %rdi
leaq 0x2b00(%rip), %rsi      # 0x15509
callq 0x4400
movq %rax, -0x250(%rbp)
jmp 0x12a17
movq -0x238(%rbp), %rsi
movq -0x250(%rbp), %rdi
callq 0x43d0
movq %rax, -0x258(%rbp)
jmp 0x12a33
movq -0x258(%rbp), %rdi
leaq 0x2dc1(%rip), %rsi      # 0x15802
callq 0x4400
jmp 0x12a48
leaq -0x220(%rbp), %rdi
callq 0x40a0
jmp 0x12a56
leaq -0x220(%rbp), %rdi
callq 0x4110
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x4110
movq -0x228(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: parth-shel[P]xpac/installed_packages_modules.cpp
// Function: rewrite_installed_packages()
void rewrite_installed_packages(){
	std::fstream file;
	file.open(installed_file, std::ios::out | std::ios::trunc);

	for(auto itr = user_installed_list.begin(); itr!=user_installed_list.end(); itr++) {
		file << itr->first << " " << itr->second << "\n";
	}

	file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
leaq -0x210(%rbp), %rdi
callq 0x44b0
movl $0x10, %edi
movl $0x20, %esi
callq 0x95c0
movl %eax, -0x23c(%rbp)
jmp 0x12ace
movl -0x23c(%rbp), %edx
leaq 0xbb75(%rip), %rsi      # 0x1e650
leaq -0x210(%rbp), %rdi
callq 0x4570
jmp 0x12ae9
leaq 0xbb80(%rip), %rdi      # 0x1e670
callq 0x9380
movq %rax, -0x228(%rbp)
leaq 0xbb6d(%rip), %rdi      # 0x1e670
callq 0x93e0
movq %rax, -0x230(%rbp)
leaq -0x228(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x93b0
testb $0x1, %al
jne 0x12b2b
jmp 0x12bf2
leaq -0x200(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x9410
movq -0x250(%rbp), %rdi
movq %rax, %rsi
callq 0x43d0
movq %rax, -0x248(%rbp)
jmp 0x12b5d
movq -0x248(%rbp), %rdi
leaq 0x299e(%rip), %rsi      # 0x15509
callq 0x4400
movq %rax, -0x258(%rbp)
jmp 0x12b79
leaq -0x228(%rbp), %rdi
callq 0x9410
movq -0x258(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x43d0
movq %rax, -0x260(%rbp)
jmp 0x12ba1
movq -0x260(%rbp), %rdi
leaq 0x2c53(%rip), %rsi      # 0x15802
callq 0x4400
jmp 0x12bb6
jmp 0x12bb8
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
callq 0x9580
movq %rax, -0x238(%rbp)
jmp 0x12afc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x4110
jmp 0x12c15
leaq -0x210(%rbp), %rdi
callq 0x40a0
jmp 0x12c00
leaq -0x210(%rbp), %rdi
callq 0x4110
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: parth-shel[P]xpac/cleanup_directory.cpp
// Function: cleanup_directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void cleanup_directory(std::string dir_name){
	dir_name = get_current_dir_name() + std::string("/") + dir_name;
	int ret = fork();
	if(ret == 0) {
		execl("/bin/rm", "rm", "-rf", dir_name.c_str(), NULL);
		exit(1);
	} else {
		waitpid( ret, NULL, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4750
movq %rax, -0x90(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x46e0
movq -0x88(%rbp), %rdx
leaq 0x23ae(%rip), %rsi      # 0x1501e
leaq -0x68(%rbp), %rdi
callq 0x4560
jmp 0x12c7b
movq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x12d90
jmp 0x12c91
movq -0x98(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x94c0
jmp 0x12ca7
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x44d0
leaq -0x28(%rbp), %rdi
callq 0x47e8
leaq -0x48(%rbp), %rdi
callq 0x47e8
leaq -0x68(%rbp), %rdi
callq 0x47e8
leaq -0x69(%rbp), %rdi
callq 0x4460
callq 0x4150
movl %eax, -0x80(%rbp)
cmpl $0x0, -0x80(%rbp)
jne 0x12d68
movq -0x98(%rbp), %rdi
callq 0x41c0
movq %rax, %rcx
leaq 0x2bc6(%rip), %rdi      # 0x158c5
leaq 0x2bc4(%rip), %rsi      # 0x158ca
leaq 0x2bc0(%rip), %rdx      # 0x158cd
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x44f0
movl $0x1, %edi
callq 0x44c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x12d5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x12d54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x47e8
leaq -0x68(%rbp), %rdi
callq 0x47e8
leaq -0x69(%rbp), %rdi
callq 0x4460
jmp 0x12d7f
movl -0x80(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4350
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x46d0
nopl (%rax,%rax)
// File: parth-shel[P]xpac/MD5checksum.cc
// Function: MD5checksum::generate_hash()
void MD5checksum::generate_hash() {
	int fd;
	unsigned char result[MD5_DIGEST_LENGTH];
	void * file_buffer;
	if((fd = open(file_path.c_str(), O_RDONLY)) < 0) {
		return;
	}

	if((file_size = get_file_size(fd)) == 0) {
		return;
	}
	
	file_buffer = mmap(0, file_size, PROT_READ, MAP_SHARED, fd, 0);
	MD5((unsigned char*) file_buffer, file_size, result);
	munmap(file_buffer, file_size);

	close(fd);

	result_hash.clear();
	for(int i = 0;i < MD5_DIGEST_LENGTH;i++) {
		result_hash.push_back(result[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x41c0
movq %rax, %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4330
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x12e92
jmp 0x12f43
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x12f80
movq -0x38(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x12eb1
jmp 0x12f43
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0xc(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %ecx
movq %r9, %rdi
movl %ecx, %edx
callq 0x46f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0x20(%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4610
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x20(%rax), %rsi
callq 0x4290
movl -0xc(%rbp), %edi
callq 0x47a0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x13470
movl $0x0, -0x2c(%rbp)
cmpl $0x10, -0x2c(%rbp)
jge 0x12f43
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movslq -0x2c(%rbp), %rax
leaq -0x20(%rbp), %rsi
addq %rax, %rsi
callq 0x13490
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x12f1a
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: parth-shel[P]xpac/MD5checksum.cc
// Function: MD5checksum::get_file_size(int)
unsigned long MD5checksum::get_file_size(int fd) {
	struct stat statbuf;
	if(fstat(fd, &statbuf) < 0) {
		return 0;
	}
	return statbuf.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
leaq -0xa8(%rbp), %rsi
callq 0x4680
cmpl $0x0, %eax
jge 0x12fb0
movq $0x0, -0x8(%rbp)
jmp 0x12fb8
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: parth-shel[P]xpac/MD5checksum.cc
// Function: MD5checksum::save_hash()
void MD5checksum::save_hash() {
	std::string hash_path(file_path);
	hash_path.append(".md5hash");
	std::ofstream hash_file(hash_path, std::ios::out | std::ios::trunc);
	std::string str(result_hash.begin(), result_hash.end());
	hash_file << str; 
	hash_file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x280(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x41d0
movq -0x278(%rbp), %rdi
leaq 0x28c9(%rip), %rsi      # 0x158d1
callq 0x4770
jmp 0x1300f
movl $0x10, %edi
movl $0x20, %esi
callq 0x95c0
movl %eax, -0x284(%rbp)
jmp 0x13026
movl -0x284(%rbp), %edx
leaq -0x238(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4780
jmp 0x1303e
movq -0x280(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x298(%rbp)
callq 0x13500
movq -0x298(%rbp), %rdi
movq %rax, -0x260(%rbp)
callq 0x13530
movq %rax, -0x268(%rbp)
leaq -0x269(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x46e0
movq -0x290(%rbp), %rcx
movq -0x260(%rbp), %rsi
movq -0x268(%rbp), %rdx
leaq -0x258(%rbp), %rdi
callq 0x13560
jmp 0x130a5
leaq -0x269(%rbp), %rdi
callq 0x4460
leaq -0x238(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x43d0
jmp 0x130c6
leaq -0x238(%rbp), %rdi
callq 0x45a0
jmp 0x130d4
leaq -0x258(%rbp), %rdi
callq 0x47e8
leaq -0x238(%rbp), %rdi
callq 0x45c0
leaq -0x28(%rbp), %rdi
callq 0x47e8
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1314a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x269(%rbp), %rdi
callq 0x4460
jmp 0x1313e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x47e8
leaq -0x238(%rbp), %rdi
callq 0x45c0
leaq -0x28(%rbp), %rdi
callq 0x47e8
movq -0x30(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: parth-shel[P]xpac/MD5checksum.cc
// Function: MD5checksum::compare_saved_hash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool MD5checksum::compare_saved_hash(std::string other_file_path) {
	std::ifstream file(other_file_path, std::ios::in);
	if(!file.good()) {
		return false;
	}

	if(file.is_open()) {
		std::string buf((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
		std::string str(result_hash.begin(), result_hash.end());
		return (str == buf);
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2b8(%rbp)
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x4650
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x46a0
movb %al, -0x2aa(%rbp)
jmp 0x131af
movb -0x2aa(%rbp), %al
testb $0x1, %al
jne 0x131e5
jmp 0x131bb
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x1337f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x13399
leaq -0x220(%rbp), %rdi
callq 0x4630
movb %al, -0x2b9(%rbp)
jmp 0x131f9
movb -0x2b9(%rbp), %al
testb $0x1, %al
jne 0x13208
jmp 0x13371
leaq -0x260(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x135e0
leaq -0x270(%rbp), %rdi
callq 0x13640
leaq -0x271(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x46e0
movq -0x2c8(%rbp), %r9
movq -0x260(%rbp), %rsi
movl -0x258(%rbp), %edx
movq -0x270(%rbp), %rcx
movl -0x268(%rbp), %r8d
leaq -0x250(%rbp), %rdi
callq 0x13670
jmp 0x1326a
leaq -0x271(%rbp), %rdi
callq 0x4460
movq -0x2b8(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x2d8(%rbp)
callq 0x13500
movq -0x2d8(%rbp), %rdi
movq %rax, -0x2a0(%rbp)
callq 0x13530
movq %rax, -0x2a8(%rbp)
leaq -0x2a9(%rbp), %rdi
movq %rdi, -0x2d0(%rbp)
callq 0x46e0
movq -0x2d0(%rbp), %rcx
movq -0x2a0(%rbp), %rsi
movq -0x2a8(%rbp), %rdx
leaq -0x298(%rbp), %rdi
callq 0x13560
jmp 0x132dd
leaq -0x2a9(%rbp), %rdi
callq 0x4460
leaq -0x298(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0xdb30
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x298(%rbp), %rdi
callq 0x47e8
leaq -0x250(%rbp), %rdi
callq 0x47e8
jmp 0x1337f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x271(%rbp), %rdi
callq 0x4460
jmp 0x13399
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x2a9(%rbp), %rdi
callq 0x4460
leaq -0x250(%rbp), %rdi
callq 0x47e8
jmp 0x13399
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x4140
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x4140
movq -0x228(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/net/worker/echoworker_impl.h
// Function: net::WorkerStatus net::worker::EchoWorker::operator()<net::ClientBuffer>(net::ClientBuffer&)
WorkerStatus EchoWorker::operator()(CONNECTION &buffer){
	if (buffer.size() == 0)
		return WorkerStatus::PASS;

	// buffer.print();

	if (cmp_(cmd_shutdown, buffer)){
		return WorkerStatus::SHUTDOWN;
	}

	if (cmp_(cmd_exit, buffer)){
		return WorkerStatus::DISCONNECT;
	}


	if (cmp_(cmd_hello, buffer)){
		buffer.clear();
		buffer.push("Hello, how are you?\r\n");
		return WorkerStatus::WRITE;
	}

	if (cmp_(cmd_help, buffer)){
		buffer.clear();
		buffer.push(msg_help);
		return WorkerStatus::WRITE;
	}

	return WorkerStatus::WRITE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rdi
callq 0x4400
cmpq $0x0, %rax
jne 0x5d29
movl $0x0, 0x14(%rsp)
jmp 0x5de6
movq (%rsp), %rsi
leaq 0x8074(%rip), %rdi      # 0xdda8
callq 0x5df0
testb $0x1, %al
jne 0x5d3f
jmp 0x5d4c
movl $0x5, 0x14(%rsp)
jmp 0x5de6
movq (%rsp), %rsi
leaq 0x8041(%rip), %rdi      # 0xdd98
callq 0x5df0
testb $0x1, %al
jne 0x5d62
jmp 0x5d6c
movl $0x3, 0x14(%rsp)
jmp 0x5de6
movq (%rsp), %rsi
leaq 0x8001(%rip), %rdi      # 0xdd78
callq 0x5df0
testb $0x1, %al
jne 0x5d82
jmp 0x5da5
movq (%rsp), %rdi
callq 0x5e40
movq (%rsp), %rdi
leaq 0x33a2(%rip), %rsi      # 0x9138
callq 0x5e70
movl $0x2, 0x14(%rsp)
jmp 0x5de6
movq (%rsp), %rsi
leaq 0x7fd8(%rip), %rdi      # 0xdd88
callq 0x5df0
testb $0x1, %al
jne 0x5dbb
jmp 0x5dde
movq (%rsp), %rdi
callq 0x5e40
movq (%rsp), %rdi
leaq 0x7fe9(%rip), %rsi      # 0xddb8
callq 0x5ed0
movl $0x2, 0x14(%rsp)
jmp 0x5de6
movl $0x2, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: lagoproject[P]arti/analysis/showers.cc
// Function: mass(int)
double mass(int id) {
// return mass in GeV for the Corsika id secondary
    switch (id) {
    //1=foton, 2=e+, 3=e-, 5=mu+, 6=mu-, 7=pi0, 8=pi+, 9=pi-, 13=n, 14=p, 15=bar-p, other
        case 1:
            return (0.); //photon
            break;
        case 2:
        case 3:
            return (511.*kev2GeV);
            break;
        case 5:
        case 6:
            return (0.10566);
            break;
        case 7:
            return (0.13498);
            break;
        case 8:
        case 9:
            return (0.13957);
            break;
        case 13:
        case 25:
            return (0.93957);
            break;
        case 14:
        case 15:
            return (0.938272);
            break;
        default:
            if (id < 100)
                return 1.;
            else {
              int idm = 0;
              for (int i=0; i<masaN; i++)
                if (masaI[i] == id)
                    idm = i;
              return masas[idm];
            }
        return 1; // just in case
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x18, %eax
ja 0x13ea
movq -0x20(%rbp), %rax
leaq 0x3d0a(%rip), %rcx      # 0x5070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x144e
movsd 0x3cac(%rip), %xmm0     # 0x5030
mulsd 0x6d8c(%rip), %xmm0     # 0x8118
movsd %xmm0, -0x8(%rbp)
jmp 0x144e
movsd 0x3c8a(%rip), %xmm0     # 0x5028
movsd %xmm0, -0x8(%rbp)
jmp 0x144e
movsd 0x3c70(%rip), %xmm0     # 0x5020
movsd %xmm0, -0x8(%rbp)
jmp 0x144e
movsd 0x3c56(%rip), %xmm0     # 0x5018
movsd %xmm0, -0x8(%rbp)
jmp 0x144e
movsd 0x3c3c(%rip), %xmm0     # 0x5010
movsd %xmm0, -0x8(%rbp)
jmp 0x144e
movsd 0x3c25(%rip), %xmm0     # 0x5008
movsd %xmm0, -0x8(%rbp)
jmp 0x144e
cmpl $0x64, -0xc(%rbp)
jge 0x13ff
movsd 0x3c40(%rip), %xmm0     # 0x5038
movsd %xmm0, -0x8(%rbp)
jmp 0x144e
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1b, -0x14(%rbp)
jge 0x1439
movslq -0x14(%rbp), %rcx
leaq 0x6d32(%rip), %rax      # 0x8150
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x142c
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x142e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x140d
movslq -0x10(%rbp), %rcx
leaq 0x6d7c(%rip), %rax      # 0x81c0
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lagoproject[P]arti/analysis/showers.cc
// Function: curved(double, double)
void curved(double xp, double yp) {
  double d = r_earth + h;
  double t = sqrt(xp*xp + yp*yp)/d;
  double f = atan2(yp,xp);
  z = (d*cos(t) - r_earth)*cm2m;
  d *= sin(t);
  x = d*cos(f)*cm2m;
  y = d*sin(f)*cm2m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0x682e(%rip), %xmm0     # 0x8108
addsd 0x6a26(%rip), %xmm0     # 0x8308
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x8(%rbp), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x1080
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
callq 0x1030
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x11c0
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd 0x67be(%rip), %xmm1     # 0x8108
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd 0x67b7(%rip), %xmm0     # 0x8128
movsd %xmm0, 0x6987(%rip)     # 0x8300
movsd -0x20(%rbp), %xmm0
callq 0x1040
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x11c0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x6773(%rip), %xmm0     # 0x8128
movsd %xmm0, 0x6933(%rip)     # 0x82f0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x1040
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x6743(%rip), %xmm0     # 0x8128
movsd %xmm0, 0x690b(%rip)     # 0x82f8
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lagoproject[P]arti/analysis/showers.cc
// Function: ring(double, double)
inline double ring(double r1, double r2) {
	if (r2 > r1) 
		return M_PI*(r2*r2 - r1*r1);
	else
		return M_PI*(r1*r1 - r2*r2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x48e0
movsd -0x18(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x793(%rip), %xmm0      # 0x5068
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4924
movsd -0x10(%rbp), %xmm1
movsd -0x10(%rbp), %xmm2
movsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x74d(%rip), %xmm0      # 0x5068
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
// File: t0mm4rx[P]piscine_cpp/day01/ex02/main.cpp
// Function: fight(Zombie**, Zombie**)
void	fight(Zombie *tall[10], Zombie *small[10])
{
	int	actions;
	int zombieIndex;

	actions = 5 + rand() % 5;
	for (int i = 0; i < actions; i++)
	{
		zombieIndex = rand() % 10;
		if (rand() % 2 == 1)
			tall[zombieIndex]->announce();
		else
			small[zombieIndex]->announce();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2050
movl $0x5, %ecx
cltd
idivl %ecx
addl $0x5, %edx
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x31a5
callq 0x2050
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
callq 0x2050
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x3187
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2490
jmp 0x3198
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2490
jmp 0x319a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x314a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: grisu48[P]geoJson/geoJson.cpp
// Function: Coords::Coords(Coords const&)
Coords(const Coords &src) {
        this->lon = src.lon;
        this->lat = src.lat;
        this->ele = src.ele;
        this->time = src.time;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
callq 0x22d0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rcx
vmovss (%rcx), %xmm0
vmovss %xmm0, (%rax)
movq 0x28(%rsp), %rcx
vmovss 0x4(%rcx), %xmm0
vmovss %xmm0, 0x4(%rax)
movq 0x28(%rsp), %rcx
vmovss 0x8(%rcx), %xmm0
vmovss %xmm0, 0x8(%rax)
movq 0x28(%rsp), %rsi
addq $0x10, %rsi
callq 0x2050
jmp 0x8eef
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x2120
movq 0x20(%rsp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: SeanLee97[P]LL1-Parser/driver.cpp
// Function: main
int main(int argc, char* argv[]) {
	Grammar g;
	g.init(argv[1]);
	g.parse();
	//g.print_table();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x308(%rbp), %rdi
movq %rdi, -0x320(%rbp)
callq 0x47a0
movq -0x320(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6f60
jmp 0x35f2
leaq -0x308(%rbp), %rdi
callq 0x7920
jmp 0x3600
movl $0x0, -0x4(%rbp)
leaq -0x308(%rbp), %rdi
callq 0x3650
movl -0x4(%rbp), %eax
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x310(%rbp)
movl %eax, -0x314(%rbp)
leaq -0x308(%rbp), %rdi
callq 0x3650
movq -0x310(%rbp), %rdi
callq 0x3390
nopl (%rax)
// File: SeanLee97[P]LL1-Parser/scan.cpp
// Function: make_token(tok_num)
static inline token make_token(tok_num t) {
    token rtn;
    rtn.num = t;
    assert(image_index < TOKEN_MAX);
    token_image[image_index] = 0;
    rtn.name = token_names[t];
    rtn.image = string(token_image);
    rtn.line = tok_line;
    rtn.column = tok_col;
    return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x4420
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
cmpl $0x64, 0x150d1(%rip)    # 0x19354
jge 0x4287
jmp 0x42a6
leaq 0xcf56(%rip), %rdi      # 0x111e4
leaq 0xcf67(%rip), %rsi      # 0x111fc
movl $0x55, %edx
leaq 0xcf64(%rip), %rcx      # 0x11205
callq 0x3150
movq -0x50(%rbp), %rax
movslq 0x150a3(%rip), %rcx     # 0x19354
leaq 0x150b8(%rip), %rdx     # 0x19370
movq %rdx, -0x68(%rbp)
movb $0x0, (%rcx,%rdx)
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0x14f54(%rip), %rcx     # 0x19220
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x8(%rax)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x33a0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x4440
jmp 0x42f4
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
leaq -0x30(%rbp), %rsi
callq 0x32c0
leaq -0x30(%rbp), %rdi
callq 0x3130
leaq -0x31(%rbp), %rdi
callq 0x3250
movq -0x50(%rbp), %rax
movl 0x1503b(%rip), %ecx     # 0x1935c
movl %ecx, 0x30(%rax)
movl 0x15036(%rip), %ecx     # 0x19360
movl %ecx, 0x34(%rax)
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x4362
jmp 0x4359
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3250
movq -0x50(%rbp), %rdi
callq 0x44f0
jmp 0x436c
movq -0x50(%rbp), %rdi
callq 0x44f0
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: SeanLee97[P]LL1-Parser/scan.cpp
// Function: nextchar()
static inline void nextchar() {
    assert(image_index < TOKEN_MAX);
    token_image[image_index++] = cur_char;
    cur_char = cin.get();
    cur_col++;
    if (cur_char == '\n') {
        cur_line++;
        cur_col = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x64, 0x14fc9(%rip)    # 0x19354
jge 0x438f
jmp 0x43ae
leaq 0xce4e(%rip), %rdi      # 0x111e4
leaq 0xce5f(%rip), %rsi      # 0x111fc
movl $0x48, %edx
leaq 0xcea0(%rip), %rcx      # 0x11249
callq 0x3150
movl 0x14f74(%rip), %eax     # 0x19328
movb %al, %dl
movl 0x14f98(%rip), %eax     # 0x19354
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x14f8d(%rip)     # 0x19354
movslq %eax, %rcx
leaq 0x14f9f(%rip), %rax     # 0x19370
movb %dl, (%rax,%rcx)
movq 0x14c05(%rip), %rdi     # 0x18fe0
callq 0x32a0
movl %eax, 0x14f42(%rip)     # 0x19328
movl 0x14f6c(%rip), %eax     # 0x19358
addl $0x1, %eax
movl %eax, 0x14f63(%rip)     # 0x19358
cmpl $0xa, 0x14f2c(%rip)     # 0x19328
jne 0x4417
movl 0x14f28(%rip), %eax     # 0x1932c
addl $0x1, %eax
movl %eax, 0x14f1f(%rip)     # 0x1932c
movl $0x0, 0x14f41(%rip)     # 0x19358
popq %rbp
retq
nopl (%rax)
// File: SeanLee97[P]LL1-Parser/grammar.cpp
// Function: Grammar::_get_idx_by_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Grammar::_get_idx_by_symbol(string symbol_to_find) {

	for(int i = 0; i < terminal_names.size(); i++) {
		if(terminal_names[i].compare(symbol_to_find) == 0)
			return i * -1;
	}

	for(int i = 0; i < nonterminal_names.size(); i++) {
		if(nonterminal_names[i].compare(symbol_to_find) == 0)
			return i;
	}

	return 999;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x238, %rdi            # imm = 0x238
callq 0x8e30
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x4e92
movq -0x28(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
movslq -0x1c(%rbp), %rsi
callq 0x8db0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3030
cmpl $0x0, %eax
jne 0x4e85
imull $-0x1, -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4efe
jmp 0x4e87
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4e33
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x250, %rdi            # imm = 0x250
callq 0x8e30
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x4ef7
movq -0x28(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
movslq -0x20(%rbp), %rsi
callq 0x8db0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3030
cmpl $0x0, %eax
jne 0x4eea
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4efe
jmp 0x4eec
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4e99
movl $0x3e7, -0x4(%rbp)      # imm = 0x3E7
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: SeanLee97[P]LL1-Parser/grammar.cpp
// Function: Grammar::_in_array(std::vector<int, std::allocator<int>>, int)
bool Grammar::_in_array(vector<int> find_in, int element) {

	if(find_in.size() == 0) return false;

	for(int i = 0; i < find_in.size(); i++) {
		if(find_in[i] == abs(element)) return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
callq 0x87c0
cmpq $0x0, %rax
jne 0x55b3
movb $0x0, -0x1(%rbp)
jmp 0x560b
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x87c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x5607
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x86c0
movl (%rax), %eax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jne 0x55fa
movb $0x1, -0x1(%rbp)
jmp 0x560b
jmp 0x55fc
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x55ba
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SeanLee97[P]LL1-Parser/grammar.cpp
// Function: Grammar::_push_unique_elements(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
vector<int> Grammar::_push_unique_elements(vector<int> target, vector<int> source) {
	for(int i = 0; i < source.size(); i++) {
		if(!_in_array(target, abs(source[i]))) {
			target.push_back(source[i]);
		}
	}
	return target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rcx, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x78(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x87c0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f55
movq -0x70(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x87e0
movq -0x78(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x86c0
movq -0x58(%rbp), %rdi
movq -0x90(%rbp), %rsi
movl (%rax), %edx
movl %edx, %eax
negl %eax
cmovnsl %eax, %edx
callq 0x5580
movb %al, -0x81(%rbp)
jmp 0x5ef0
movb -0x81(%rbp), %al
xorb $-0x1, %al
movb %al, -0x91(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3900
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x5f13
jmp 0x5f45
movq -0x78(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x86c0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x8900
jmp 0x5f45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3900
jmp 0x5f6f
jmp 0x5f47
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5e8d
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x89d0
movq -0x60(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3390
nopl (%rax,%rax)
// File: kmyk[P]procon26/beam_search.cpp
// Function: beam_search(board const&, std::vector<block, std::allocator<block>> const&, int, bool)
vector<placement_t> beam_search(board const & brd, std::vector<block> const & blks, int beam_width, bool is_chokudai) {
    if (is_chokudai) {
        unordered_set<bitset<board_size * board_size> > cache;
        while (true) beam_search_solver(beam_width, &cache)(brd, blks);
    } else {
        return beam_search_solver(beam_width, nullptr)(brd, blks);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4350, %rsp           # imm = 0x4350
movq %rdi, -0x4340(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x4338(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
je 0x262b
leaq -0x58(%rbp), %rdi
callq 0x2a90
jmp 0x25a8
movl -0x1c(%rbp), %esi
leaq -0x21c8(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x2ab0
jmp 0x25bd
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x70(%rbp), %rdi
leaq -0x21c8(%rbp), %rsi
callq 0x2db0
jmp 0x25d7
leaq -0x70(%rbp), %rdi
callq 0x5210
leaq -0x21c8(%rbp), %rdi
callq 0x5270
jmp 0x25a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x21d0(%rbp)
movl %eax, -0x21d4(%rbp)
jmp 0x2620
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x21d0(%rbp)
movl %eax, -0x21d4(%rbp)
leaq -0x21c8(%rbp), %rdi
callq 0x5270
leaq -0x58(%rbp), %rdi
callq 0x52d0
jmp 0x269c
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
leaq -0x4330(%rbp), %rdi
movq %rdi, -0x4348(%rbp)
callq 0x2ab0
movq -0x4340(%rbp), %rdi
movq -0x4348(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x2db0
jmp 0x2662
leaq -0x4330(%rbp), %rdi
callq 0x5270
movq -0x4338(%rbp), %rax
addq $0x4350, %rsp           # imm = 0x4350
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x21d0(%rbp)
movl %eax, -0x21d4(%rbp)
leaq -0x4330(%rbp), %rdi
callq 0x5270
movq -0x21d0(%rbp), %rdi
callq 0x2260
nopl (%rax,%rax)