LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: akgupta007[P]DBMS-query-processing-Algotihms/file_manager.cpp
// Function: FileHandler::NewPage()
PageHandler FileHandler::NewPage() {
	int page_number ; // new page number
	char *page_buffer ; //to store page read from buffer manager
	PageHandler pageHandle;
	//if free list not empty 
	if(hdr.firstFreePage!= END_FREE) {
		// first free page number will be the new page number 
		page_number = hdr.firstFreePage;
		//contents of page are read using the buffer manager
		page_buffer = bufferManager->GetPage(PageDescriptor(this->unix_file_desc,page_number));
		// update the head of free page list for file	
		hdr.firstFreePage = ((PageHdr*)page_buffer)->nextFreePage;
	}
	else { // free pages
		page_number = hdr.totalPages; // new page will be added at the end of file
		page_buffer = bufferManager->AllocatePage(PageDescriptor(this->unix_file_desc,page_number)); //allocate and load the page in buffer manager
		//increase number of pages by one
		hdr.totalPages++;
	}
	//mark file header is changed
	this->hdrChanged = true;
	// mark the new page as used
    ((PageHdr *)page_buffer)->nextFreePage = NOT_FREE;
    //overwrite page contents
    memset(page_buffer+sizeof(PageHdr),0,PAGE_CONTENT_SIZE);
    //mark the page dirty due to next pointer of free list changed
    MarkDirty(page_number);
    pageHandle.pageNum = page_number;
    pageHandle.data = page_buffer+sizeof(PageHdr);
 
    return pageHandle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x6740
movq -0x38(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x6d05
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, -0x14(%rbp)
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movl 0x14(%rax), %esi
movl -0x14(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x3b20
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2700
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
jmp 0x6d46
movq -0x38(%rbp), %rax
movl 0xc(%rax), %ecx
movl %ecx, -0x14(%rbp)
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movl 0x14(%rax), %esi
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x3b20
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2c60
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x11(%rax)
movq -0x20(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
xorl %esi, %esi
movl $0xffc, %edx            # imm = 0xFFC
callq 0x2100
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6da0
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %edx
movl %edx, (%rcx)
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
movq %rdx, 0x8(%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/file_manager.cpp
// Function: FileHandler::DisposePage(int)
bool FileHandler::DisposePage(int page_number) {

	if(!checkPageValid(page_number)) return false; // invalid request
	// read the page from the buffer manager 
	char *page_buffer;
	page_buffer = bufferManager->GetPage(PageDescriptor(this->unix_file_desc,page_number));
	PageHdr * page_header = (PageHdr*) page_buffer;
	// if already free - 
	if (page_header->nextFreePage!=NOT_FREE) {
		UnpinPage(page_number); // since page read into buffer manager
		return false;
	}
	// update the head of free list by adding this page at the head
	page_header->nextFreePage = hdr.firstFreePage;
	hdr.firstFreePage = page_number;
	this->hdrChanged = true;
	// mark the page as dirty and then unpin it 
	MarkDirty(page_number);
	UnpinPage(page_number);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0x6c10
testb $0x1, %al
jne 0x6e09
movb $0x0, -0x1(%rbp)
jmp 0x6e86
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movl 0x14(%rax), %esi
movl -0x14(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x3b20
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2700
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $-0x2, (%rax)
je 0x6e57
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6c50
movb $0x0, -0x1(%rbp)
jmp 0x6e86
movq -0x38(%rbp), %rdi
movl 0x8(%rdi), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rdi)
movb $0x1, 0x11(%rdi)
movl -0x14(%rbp), %esi
callq 0x6da0
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6c50
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/file_manager.cpp
// Function: FileHandler::FlushPages()
bool FileHandler::FlushPages() {
	if(this->hdrChanged) {
		lseek(this->unix_file_desc,0,0); // seek file pointer to start
		int _wr_res = write(this->unix_file_desc,(char *)&hdr,sizeof(FileHdr));
		if(_wr_res<0) return false; //write error
		this->hdrChanged =false;
	}
	return bufferManager->FlushPages(this->unix_file_desc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x11(%rax)
je 0x6ef8
movq -0x20(%rbp), %rax
movl 0x14(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x22c0
movq -0x20(%rbp), %rsi
movl 0x14(%rsi), %edi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x2080
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x6ef0
movb $0x0, -0x1(%rbp)
jmp 0x6f0c
movq -0x20(%rbp), %rax
movb $0x0, 0x11(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl 0x14(%rax), %esi
callq 0x2f80
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/file_manager.cpp
// Function: FileHandler::FlushPage(int)
bool FileHandler::FlushPage(int page_number) {
	if(this->hdrChanged) {
		lseek(this->unix_file_desc,0,0); // seek file pointer to start
		int _wr_res = write(this->unix_file_desc,(char *)&hdr,sizeof(FileHdr));
		if(_wr_res<0) return false; //write error
		this->hdrChanged =false;
	}
	return bufferManager->FlushPage(PageDescriptor(this->unix_file_desc,page_number));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x11(%rax)
je 0x6f7b
movq -0x28(%rbp), %rax
movl 0x14(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x22c0
movq -0x28(%rbp), %rsi
movl 0x14(%rsi), %edi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x2080
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x6f73
movb $0x0, -0x1(%rbp)
jmp 0x6fa7
movq -0x28(%rbp), %rax
movb $0x0, 0x11(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movl 0x14(%rax), %esi
movl -0x14(%rbp), %edx
leaq -0x20(%rbp), %rdi
callq 0x3b20
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x31b0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/file_manager.cpp
// Function: FileManager::FileManager()
FileManager::FileManager() {
	// intialize manager with a buffer manager
	// thus buffer manager will be hidden from student API access 
	if(FileManagerInstanceCount==1) {
		throw FileManagerInstanceException();
	}
	FileManagerInstanceCount = 1;
	bufferManager = new BufferManager(BUFFER_SIZE);
 
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, 0x91bd(%rip)      # 0x10198
jne 0x701a
movl $0x8, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x2100
movq -0x28(%rbp), %rdi
callq 0x7420
movq -0x28(%rbp), %rdi
leaq 0x8cf2(%rip), %rsi      # 0xfd00
leaq 0x44b(%rip), %rdx       # 0x7460
callq 0x2250
movl $0x1, 0x9174(%rip)      # 0x10198
movl $0x78, %edi
callq 0x21a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x3, %esi
callq 0x24a0
jmp 0x7044
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2180
movq -0x10(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/file_manager.cpp
// Function: FileManager::CreateFile(char const*)
FileHandler FileManager::CreateFile(const char* filename) {
	// open file for writing
	int fd = open(filename,O_CREAT|O_EXCL|O_RDWR,0660); // updated to fail if file already exists
	if(fd==-1) throw InvalidFileException();
	// write out the initial header
	char hdr_buf[FILE_HDR_SIZE];
	memset(hdr_buf,0,FILE_HDR_SIZE);
	FileHdr *hdr= (FileHdr*) hdr_buf;
	hdr->firstFreePage = END_FREE;
	hdr->totalPages = 0;
	write(fd,hdr_buf,FILE_HDR_SIZE);
	close(fd);
	return OpenFile(filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1050, %rsp           # imm = 0x1050
movq %rdi, -0x1040(%rbp)
movq %rdi, %rax
movq %rax, -0x1038(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1030(%rbp)
movq -0x18(%rbp), %rdi
movl $0xc2, %esi
movl $0x1b0, %edx            # imm = 0x1B0
movb $0x0, %al
callq 0x2140
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x7157
movl $0x8, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, -0x1048(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x2100
movq -0x1048(%rbp), %rdi
callq 0x7480
movq -0x1048(%rbp), %rdi
leaq 0x8bcd(%rip), %rsi      # 0xfd18
leaq 0x36e(%rip), %rdx       # 0x74c0
callq 0x2250
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2100
leaq -0x1020(%rbp), %rax
movq %rax, -0x1028(%rbp)
movq -0x1028(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x1028(%rbp), %rax
movl $0x0, 0x4(%rax)
movl -0x1c(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2080
movl -0x1c(%rbp), %edi
callq 0x22d0
movq -0x1040(%rbp), %rdi
movq -0x1030(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x71e0
movq -0x1038(%rbp), %rax
addq $0x1050, %rsp           # imm = 0x1050
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/file_manager.cpp
// Function: FileManager::OpenFile(char const*)
FileHandler FileManager::OpenFile(const char *filename) {
	FileHandler fileHandle; 
	// open file 
	fileHandle.fileName = new char[strlen(filename)+1];
	strcpy(fileHandle.fileName, filename);
 

	fileHandle.unix_file_desc = open(filename,O_RDWR);
	if(fileHandle.unix_file_desc==-1) throw InvalidFileException();
	//read header
	fileHandle.hdr.firstFreePage = 0;
	fileHandle.hdr.totalPages = 0;
	int _temp_res = read(fileHandle.unix_file_desc,(char *)&fileHandle.hdr,
            sizeof(FileHdr));
    // update file metadata
    fileHandle.isOpen = true;
    fileHandle.hdrChanged = false;
    fileHandle.bufferManager = bufferManager;
    return fileHandle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6830
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
movq %rax, 0x18(%rdi)
movq 0x18(%rdi), %rdi
movq -0x18(%rbp), %rsi
callq 0x2170
movq -0x18(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x2140
movq -0x28(%rbp), %rdi
movl %eax, 0x14(%rdi)
cmpl $-0x1, 0x14(%rdi)
jne 0x7290
movl $0x8, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x2100
movq -0x40(%rbp), %rdi
callq 0x7480
movq -0x40(%rbp), %rdi
leaq 0x8a94(%rip), %rsi      # 0xfd18
leaq 0x235(%rip), %rdx       # 0x74c0
callq 0x2250
movq -0x28(%rbp), %rsi
movl $0x0, 0x8(%rsi)
movl $0x0, 0xc(%rsi)
movl 0x14(%rsi), %edi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x2200
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq %rax, %rsi
movq -0x38(%rbp), %rax
movl %esi, -0x1c(%rbp)
movb $0x1, 0x10(%rcx)
movb $0x0, 0x11(%rcx)
movq (%rdx), %rdx
movq %rdx, (%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/file_manager.cpp
// Function: FileManager::CloseFile(FileHandler&)
bool FileManager::CloseFile(FileHandler &fileHandle) {
	if(!fileHandle.isOpen) return false; // if not already open
	if(!fileHandle.FlushPages()) return false; //flush pages to file, if error in flushing all pages , return false
	close(fileHandle.unix_file_desc); // close the file
 

	//update meta data
	fileHandle.isOpen = false;
	fileHandle.bufferManager = NULL;	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x7330
movb $0x0, -0x1(%rbp)
jmp 0x7366
movq -0x18(%rbp), %rdi
callq 0x6ea0
testb $0x1, %al
jne 0x7343
movb $0x0, -0x1(%rbp)
jmp 0x7366
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x22d0
movq -0x18(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/check.cpp
// Function: getValue[abi:cxx11](char const*)
list<int> getValue(const char *filename){
	ifstream myfile(filename);
	if(!myfile){
		cout<<"could not open file " << filename <<endl;
		exit (0);
	}
	list<int> num;
	int n;
	while(!myfile.eof()){
		myfile >> n;
		num.push_back(n);
	}
	myfile.close();
	return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x240(%rbp)
movq %rdi, %rax
movq %rax, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x2290
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x20c0
movb %al, -0x22d(%rbp)
jmp 0x7629
movb -0x22d(%rbp), %al
testb $0x1, %al
jne 0x7635
jmp 0x769d
movq 0x899c(%rip), %rdi      # 0xffd8
leaq 0x2d69(%rip), %rsi      # 0xa3ac
callq 0x2190
movq %rax, -0x248(%rbp)
jmp 0x7651
movq -0x248(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
movq %rax, -0x250(%rbp)
jmp 0x766a
movq -0x250(%rbp), %rdi
movq 0x8948(%rip), %rsi      # 0xffc0
callq 0x21b0
jmp 0x767f
xorl %edi, %edi
callq 0x21c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x7770
movq -0x240(%rbp), %rdi
movb $0x0, -0x225(%rbp)
callq 0x35b0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x22a0
movb %al, -0x251(%rbp)
jmp 0x76d0
movb -0x251(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x76de
jmp 0x772a
leaq -0x218(%rbp), %rdi
leaq -0x22c(%rbp), %rsi
callq 0x2120
jmp 0x76f3
movq -0x240(%rbp), %rdi
leaq -0x22c(%rbp), %rsi
callq 0x3610
jmp 0x7708
jmp 0x76b0
movq -0x240(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
callq 0x3670
jmp 0x7770
leaq -0x218(%rbp), %rdi
callq 0x2050
jmp 0x7738
movb $0x1, -0x225(%rbp)
testb $0x1, -0x225(%rbp)
jne 0x7754
movq -0x240(%rbp), %rdi
callq 0x3670
leaq -0x218(%rbp), %rdi
callq 0x2060
movq -0x238(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x2060
movq -0x220(%rbp), %rdi
callq 0x2270
nopl (%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/check.cpp
// Function: checkPage(std::__cxx11::list<int, std::allocator<int>>, char*)
list<int> checkPage(list<int> lst, char* pageData){
	int n;
	int num = lst.front();
	list<int> position;
	int i = 0;
	for(; i< PAGE_CONTENT_SIZE/sizeof(int); i++){
		memcpy (&n, &pageData[i*sizeof(int)], sizeof(int));
		if (n == INT_MIN){
			break;
		}
		if (n > num){
			lst.pop_front();
			position.push_back(i);
			i--;
			if(lst.empty()){
				break;
			}
			num = lst.front();
		}
	}
	while( !lst.empty() ){
		position.push_back(i);
		lst.pop_front();
	}
	return position;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, %rax
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3c40
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x35b0
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
jae 0x7874
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x2, %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x80000000, -0x1c(%rbp) # imm = 0x80000000
jne 0x7805
jmp 0x7874
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x7864
movq -0x50(%rbp), %rdi
callq 0x3c70
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3610
jmp 0x7825
movq -0x50(%rbp), %rdi
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
callq 0x3c20
testb $0x1, %al
jne 0x783d
jmp 0x7856
jmp 0x7874
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3670
jmp 0x78be
movq -0x50(%rbp), %rdi
callq 0x3c40
movl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x7866
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x77d8
jmp 0x7876
movq -0x50(%rbp), %rdi
callq 0x3c20
xorb $-0x1, %al
testb $0x1, %al
jne 0x7887
jmp 0x78a1
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3610
jmp 0x7896
movq -0x50(%rbp), %rdi
callq 0x3c70
jmp 0x7876
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x78b4
movq -0x40(%rbp), %rdi
callq 0x3670
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2270
nopw (%rax,%rax)
// File: akgupta007[P]DBMS-query-processing-Algotihms/check.cpp
// Function: PrintPage(PageHandler)
void PrintPage(PageHandler ph){
	char* data = ph.GetData ();
	int temp_num;
	// Output the all integers
	for(int i=0; i<1022 ; i++){
		memcpy (&temp_num, &data[i*4], sizeof(int));
		cout << i<< "th number: " << temp_num << endl;
		if(temp_num == INT_MIN) break;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6800
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3fe, -0x18(%rbp)     # imm = 0x3FE
jge 0x7b78
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %esi
movq 0x84a6(%rip), %rdi      # 0xffd8
callq 0x2260
movq %rax, %rdi
leaq 0x2880(%rip), %rsi      # 0xa3c1
callq 0x2190
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2260
movq %rax, %rdi
movq 0x8465(%rip), %rsi      # 0xffc0
callq 0x21b0
cmpl $0x80000000, -0x14(%rbp) # imm = 0x80000000
jne 0x7b6b
jmp 0x7b78
jmp 0x7b6d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7b0c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: akgupta007[P]DBMS-query-processing-Algotihms/check.cpp
// Function: main
int main(int argc, char* argv[]) {
	//read input file
	
	FileManager fm;
	FileHandler fh;
	
	// Reopen the same file, but for reading this time
	fh = fm.OpenFile (argv[1]);
	
	PageHandler ph_last = fh.LastPage ();
	int total_pages = ph_last.GetPageNum ()+1;
	for(int i = 0; i<total_pages; i++){
		cout<< "Page : "<<i <<endl;
		ph_last = fh.PageAt(i);
		PrintPage(ph_last);
		fh.UnpinPage(i);
	}
	cout<<total_pages<<endl;
	fh.FlushPages();
	fm.CloseFile (fh);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6fc0
leaq -0x40(%rbp), %rdi
callq 0x6830
jmp 0x829d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x70(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x71e0
jmp 0x82b4
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movaps %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6a00
jmp 0x82d3
leaq -0x80(%rbp), %rdi
callq 0x6820
movl %eax, -0xac(%rbp)
jmp 0x82e4
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
movl $0x0, -0x88(%rbp)
movl -0x88(%rbp), %eax
cmpl -0x84(%rbp), %eax
jge 0x83dc
movq 0x7cc2(%rip), %rdi      # 0xffd8
leaq 0x20b0(%rip), %rsi      # 0xa3cd
callq 0x2190
movq %rax, -0xb8(%rbp)
jmp 0x832b
movq -0xb8(%rbp), %rdi
movl -0x88(%rbp), %esi
callq 0x2260
movq %rax, -0xc0(%rbp)
jmp 0x8346
movq -0xc0(%rbp), %rdi
movq 0x7c6c(%rip), %rsi      # 0xffc0
callq 0x21b0
jmp 0x835b
movl -0x88(%rbp), %edx
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6b20
jmp 0x8373
movups -0x98(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x6790
jmp 0x8390
leaq -0xa8(%rbp), %rdi
callq 0x7af0
jmp 0x839e
movl -0x88(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x6c50
jmp 0x83af
jmp 0x83b1
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0x82fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x7080
jmp 0x843b
movl -0x84(%rbp), %esi
movq 0x7bef(%rip), %rdi      # 0xffd8
callq 0x2260
movq %rax, -0xc8(%rbp)
jmp 0x83f7
movq -0xc8(%rbp), %rdi
movq 0x7bbb(%rip), %rsi      # 0xffc0
callq 0x21b0
jmp 0x840c
leaq -0x40(%rbp), %rdi
callq 0x6ea0
jmp 0x8417
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7310
jmp 0x8426
leaq -0x18(%rbp), %rdi
callq 0x7080
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/enum-match.cc
// Function: main
int main() {
    Tokens curTok = INLINE;
    ff(128);    // exactly matches ff(int)
    ff(INLINE); // exactly matches ff(Tokens)
    ff(curTok); // exactly matches ff(Tokens)

	void newf(unsigned char);
	void newf(int);
	unsigned char uc = VIRTUAL;
	
	newf(VIRTUAL);  // calls newf(int)
	newf(uc);       // calls newf(unsigned char)
	
	newf(129);      // calls newf(int)
	
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x80, -0x8(%rbp)
movl $0x80, %edi
callq 0x11f0
movl $0x80, %edi
callq 0x11b0
movl -0x8(%rbp), %edi
callq 0x11b0
movb $-0x7f, -0x9(%rbp)
movl $0x81, %edi
callq 0x1230
movzbl -0x9(%rbp), %edi
callq 0x1270
movl $0x81, %edi
callq 0x1230
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: rohitrangan[P]3PC/src/server_fail.cpp
// Function: server_shutdown(int)
void server_shutdown (int s)
{
    (void) s;
    cout << "\n";
    cout << "Initiating Server Shutdown...\n";
    cout << "Closing All Connections... ";
    site.close ();
    cout << "\nAll Connections Closed. Exiting...\n\n";
    exit (EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x12416(%rip), %rdi     # 0x15fc8
leaq 0xc63b(%rip), %rsi      # 0x101f4
callq 0x32e0
movq 0x12403(%rip), %rdi     # 0x15fc8
leaq 0xc45c(%rip), %rsi      # 0x10028
callq 0x32e0
movq 0x123f0(%rip), %rdi     # 0x15fc8
leaq 0xc468(%rip), %rsi      # 0x10047
callq 0x32e0
leaq 0x126bd(%rip), %rdi     # 0x162a8
callq 0xc7b0
movq 0x123d1(%rip), %rdi     # 0x15fc8
leaq 0xc465(%rip), %rsi      # 0x10063
callq 0x32e0
xorl %edi, %edi
callq 0x33c0
nopw (%rax,%rax)
// File: rohitrangan[P]3PC/src/socket.cpp
// Function: Socket::connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int Socket::connect (string host, int port)
{
    /* Creating the socket. */
    if ((socketFD = socket (AF_INET, SOCK_STREAM, 0)) < 0)
    {
        int errsv = errno;
        std::cerr << "Cannot Create Socket, Error ";
        std::cerr << errsv << "\n";
        exit (1);
    }
    /* Determining server's IP address. */
    stringstream s1;
    s1 << port;
    int status;
    addrinfo hints;
    addrinfo* servinfo;
    memset (&hints, 0, sizeof (hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    if ((status = getaddrinfo (host.c_str (), s1.str ().c_str (), &hints,
                               &servinfo)) != 0)
        return -1;

    /* Connecting to the server. */
    return ::connect (socketFD, servinfo->ai_addr, servinfo->ai_addrlen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rsi, -0x230(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3090
movq -0x228(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0xc07c
callq 0x3040
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq 0x9fa8(%rip), %rdi      # 0x15ff0
leaq 0x433a(%rip), %rsi      # 0x10389
callq 0x32e0
movl -0x20(%rbp), %esi
movq 0x9f92(%rip), %rdi      # 0x15ff0
callq 0x34a0
movq %rax, %rdi
leaq 0x4187(%rip), %rsi      # 0x101f4
callq 0x32e0
movl $0x1, %edi
callq 0x33c0
leaq -0x1a8(%rbp), %rdi
callq 0x31f0
leaq -0x198(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x34a0
jmp 0xc099
movq -0x230(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, -0x1d0(%rbp)
movaps %xmm0, -0x1e0(%rbp)
movaps %xmm0, -0x1f0(%rbp)
movl $0x2, -0x1ec(%rbp)
movl $0x1, -0x1e8(%rbp)
callq 0x3100
movq %rax, -0x238(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x32d0
jmp 0xc0ed
leaq -0x218(%rbp), %rdi
callq 0x3100
movq -0x238(%rbp), %rdi
movq %rax, %rsi
leaq -0x1f0(%rbp), %rdx
leaq -0x1f8(%rbp), %rcx
callq 0x3410
movl %eax, -0x23c(%rbp)
jmp 0xc11e
movl -0x23c(%rbp), %eax
movl %eax, -0x1b8(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x31b0
movl -0x23c(%rbp), %eax
cmpl $0x0, %eax
je 0xc188
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x21c(%rbp)
jmp 0xc1bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0xc1d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x31b0
jmp 0xc1d7
movq -0x228(%rbp), %rax
movl (%rax), %edi
movq -0x1f8(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x3260
movl %eax, -0x240(%rbp)
jmp 0xc1ac
movl -0x240(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x21c(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x3220
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x1a8(%rbp), %rdi
callq 0x3220
movq -0x1b0(%rbp), %rdi
callq 0x34b0
nop
// File: rohitrangan[P]3PC/src/socket.cpp
// Function: Socket::recv[abi:cxx11](unsigned long)
string Socket::recv (size_t len)
{
    char* recv_buf = new char[len + 1];
    int recv_len = ::recv (socketFD, recv_buf, len, 0);
    if (recv_len < 0)
        return string ("");
    recv_buf[recv_len] = '\0';
    return string (recv_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl (%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x30d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0xc31e
leaq -0x25(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34c0
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x3f00(%rip), %rsi      # 0x101f5
callq 0x75f0
jmp 0xc2fc
leaq -0x25(%rbp), %rdi
callq 0x3360
jmp 0xc374
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x3360
jmp 0xc37e
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x35(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x34c0
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x75f0
jmp 0xc352
leaq -0x35(%rbp), %rdi
callq 0x3360
jmp 0xc374
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x35(%rbp), %rdi
callq 0x3360
jmp 0xc37e
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: rohitrangan[P]3PC/src/socket.cpp
// Function: Socket::bind(int)
int Socket::bind (int port)
{
    /* Creating the socket. */
    if ((socketFD = socket (AF_INET, SOCK_STREAM, 0)) < 0)
    {
        int errsv = errno;
        std::cerr << "Cannot Create Socket, Error ";
        std::cerr << errsv << "\n";
        exit (1);
    }
    sockaddr_in myaddr;
    memset ((char*)&myaddr, 0, sizeof(myaddr));
    myaddr.sin_family = AF_INET;
    myaddr.sin_addr.s_addr = htonl (INADDR_ANY);
    myaddr.sin_port = htons (port);
    return ::bind (socketFD, (sockaddr *)&myaddr, sizeof (myaddr));
}

// 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)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3090
movq -0x28(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0xc438
callq 0x3040
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq 0x9bec(%rip), %rdi      # 0x15ff0
leaq 0x3f7e(%rip), %rsi      # 0x10389
callq 0x32e0
movl -0x10(%rbp), %esi
movq 0x9bd6(%rip), %rdi      # 0x15ff0
callq 0x34a0
movq %rax, %rdi
leaq 0x3dcb(%rip), %rsi      # 0x101f4
callq 0x32e0
movl $0x1, %edi
callq 0x33c0
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3160
movw $0x2, -0x20(%rbp)
xorl %edi, %edi
callq 0x3230
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movzwl %ax, %edi
callq 0x3050
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, -0x1e(%rbp)
movl (%rax), %edi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x3060
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rohitrangan[P]3PC/src/socket.cpp
// Function: Socket::getSourceAddr[abi:cxx11]()
string Socket::getSourceAddr ()
{
    char src[INET_ADDRSTRLEN];
    sockaddr_storage tmp;
    socklen_t addr_size = sizeof (sockaddr);
    getsockname (socketFD, (sockaddr*)&tmp, &addr_size);
    sockaddr_in* src_addr = (sockaddr_in*)&tmp;
    inet_ntop (AF_INET, &src_addr->sin_addr, src, sizeof (src));
    return string (src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x10, -0xa4(%rbp)
movl (%rax), %edi
leaq -0xa0(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
leaq -0xa4(%rbp), %rdx
callq 0x32b0
movq -0xe8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rsi
addq $0x4, %rsi
movl $0x2, %edi
leaq -0x20(%rbp), %rdx
movq %rdx, -0xd8(%rbp)
movl $0x10, %ecx
callq 0x3350
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x34c0
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
callq 0x75f0
jmp 0xc5e0
leaq -0xb1(%rbp), %rdi
callq 0x3360
movq -0xf0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb1(%rbp), %rdi
callq 0x3360
movq -0xc0(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: rohitrangan[P]3PC/src/socket.cpp
// Function: Socket::enableBlocking()
int Socket::enableBlocking ()
{
    if (socketFD < 0 && blockingEnabled)
        return -1;

    int flags;
    if ((flags = fcntl (socketFD, F_GETFL, 0)) < 0)
        return -1;

    int rval = fcntl (socketFD, F_SETFL, flags | O_NONBLOCK);
    if (rval < 0)
        return rval;
    else
        blockingEnabled = false;

    return rval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
jge 0xc82c
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0xc82c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc88b
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x3170
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0xc851
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc88b
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x14(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x3170
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xc87d
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc88b
movq -0x20(%rbp), %rax
movb $0x0, 0x4(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rohitrangan[P]3PC/src/socket.cpp
// Function: Socket::disableBlocking()
int Socket::disableBlocking ()
{
    if (socketFD < 0 && (!blockingEnabled))
        return -1;

    int flags;
    if ((flags = fcntl (socketFD, F_GETFL, 0)) < 0)
        return -1;

    int rval = fcntl (socketFD, F_SETFL, flags & (~O_NONBLOCK));
    if (rval < 0)
        return rval;
    else
        blockingEnabled = true;

    return rval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
jge 0xc8cc
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0xc8cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc92b
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x3170
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0xc8f1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc92b
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x14(%rbp), %edx
andl $0xfffff7ff, %edx       # imm = 0xFFFFF7FF
movl $0x4, %esi
movb $0x0, %al
callq 0x3170
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xc91d
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc92b
movq -0x20(%rbp), %rax
movb $0x1, 0x4(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: rohitrangan[P]3PC/src/message.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void split(const std::string& line, char delim, std::vector<std::string>& val) {
    std::string::size_type i = 0;
    std::string::size_type j = line.find (delim);

    while (j != std::string::npos)
    {
        val.push_back (line.substr (i, j-i));
        i = ++j;
        j = line.find (delim, j);

        if (j == std::string::npos)
            val.push_back (line.substr (i, line.length ()));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x9(%rbp), %esi
callq 0x3430
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0xca8f
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3310
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0xceb0
jmp 0xc9ba
leaq -0x48(%rbp), %rdi
callq 0x31b0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x28(%rbp), %rdx
movsbl %al, %esi
callq 0x3430
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0xca8a
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x3470
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, %rcx
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3310
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xceb0
jmp 0xca51
leaq -0x78(%rbp), %rdi
callq 0x31b0
jmp 0xca8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31b0
jmp 0xca98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x31b0
jmp 0xca98
jmp 0xc976
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: rohitrangan[P]3PC/src/message.cpp
// Function: Message::parseMessage()
void Message::parseMessage ()
{
    std::vector<std::string> m_parsed;
    split (message_str, DELIM, m_parsed);
    this->message = messageIndex (m_parsed[0]);
    this->transaction_id = std::stoi (m_parsed[1]);
    this->site_id = std::stoi (m_parsed[2]);
    this->failed_id = std::stoi (m_parsed[3]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcf70
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
addq $0x10, %rdi
movl $0x2c, %esi
callq 0xc940
jmp 0xcbdc
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0xcf90
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x3110
jmp 0xcbf7
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %rsi, -0x70(%rbp)
callq 0xce40
movq -0x70(%rbp), %rdi
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
callq 0x31b0
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xcf90
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x75b0
movl %eax, -0x64(%rbp)
jmp 0xcc3d
movq -0x60(%rbp), %rax
movl -0x64(%rbp), %ecx
movl %ecx, 0x4(%rax)
leaq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0xcf90
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x75b0
movl %eax, -0x74(%rbp)
jmp 0xcc6b
movq -0x60(%rbp), %rax
movl -0x74(%rbp), %ecx
movl %ecx, 0x8(%rax)
leaq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0xcf90
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x75b0
movl %eax, -0x78(%rbp)
jmp 0xcc99
movq -0x60(%rbp), %rax
movl -0x78(%rbp), %ecx
movl %ecx, 0xc(%rax)
leaq -0x20(%rbp), %rdi
callq 0xcfb0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcfb0
movq -0x28(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: rohitrangan[P]3PC/src/message.cpp
// Function: Message::createMessage[abi:cxx11]()
std::string Message::createMessage ()
{
    std::stringstream s;
    s << message_strings[message] << DELIM << transaction_id;
    s << DELIM << site_id << DELIM << failed_id;
    return s.str ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31f0
movq -0x1b8(%rbp), %rax
leaq -0x188(%rbp), %rdi
movl (%rax), %eax
shlq $0x5, %rax
leaq 0x959a(%rip), %rsi      # 0x162d0
addq %rax, %rsi
callq 0x3290
movq %rax, -0x1b0(%rbp)
jmp 0xcd47
movq -0x1b0(%rbp), %rdi
movl $0x2c, %esi
callq 0x33b0
movq %rax, -0x1d0(%rbp)
jmp 0xcd61
movq -0x1d0(%rbp), %rdi
movq -0x1b8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x34a0
jmp 0xcd79
leaq -0x188(%rbp), %rdi
movl $0x2c, %esi
callq 0x33b0
movq %rax, -0x1d8(%rbp)
jmp 0xcd93
movq -0x1d8(%rbp), %rdi
movq -0x1b8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x34a0
movq %rax, -0x1e0(%rbp)
jmp 0xcdb2
movq -0x1e0(%rbp), %rdi
movl $0x2c, %esi
callq 0x33b0
movq %rax, -0x1e8(%rbp)
jmp 0xcdcc
movq -0x1e8(%rbp), %rdi
movq -0x1b8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x34a0
jmp 0xcde4
movq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x32d0
jmp 0xcdf9
leaq -0x198(%rbp), %rdi
callq 0x3220
movq -0x1c0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3220
movq -0x1a0(%rbp), %rdi
callq 0x34b0
nop
// File: rohitrangan[P]3PC/src/message.cpp
// Function: Message::messageIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
message_id Message::messageIndex (std::string message_str)
{
    for (int i = 0; i < NUM_MESSAGES; ++i)
    {
        if (message_strings[i] == message_str)
            return (message_id) i;
    }
    return ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0xce97
movq -0x28(%rbp), %rsi
movslq -0x1c(%rbp), %rax
leaq 0x9460(%rip), %rdi      # 0x162d0
shlq $0x5, %rax
addq %rax, %rdi
callq 0xcee0
testb $0x1, %al
jne 0xce82
jmp 0xce8a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xce9e
jmp 0xce8c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xce5b
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: amukherj[P]concurrencyts/barrier.cc
// Function: main
int main() {
  std::experimental::flex_barrier barrier(7, []() ->int {
    std::cout << "All threads done\n";
    return -1;
  });

  for (int i = 0; i < 10; ++i) {
    std::thread thr([&, i]() {
      std::this_thread::sleep_for(std::chrono::seconds(5));
      barrier.arrive_and_wait();
      std::cout << "Thread " << i << " done\n";
    });
    thr.detach();
  }

  std::thread thr1([&]() {
    barrier.arrive_and_wait();
    std::cout << "Thread 6 done\n";
  });
  thr1.join();

  for (int i = 0; i < 9; ++i) {
    std::thread thr([&, i]() {
      std::this_thread::sleep_for(std::chrono::seconds(5));
      barrier.arrive_and_wait();
      std::cout << "Thread " << i << " done\n";
    });
    thr.detach();
  }
  barrier.arrive_and_wait();
  std::this_thread::sleep_for(std::chrono::seconds(5));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
leaq -0xb1(%rbp), %rdi
callq 0x2520
movq %rax, %rdx
leaq -0xb0(%rbp), %rdi
movl $0x7, %esi
callq 0x3140
movl $0x0, -0xb8(%rbp)
cmpl $0xa, -0xb8(%rbp)
jge 0x23bd
movl -0xb8(%rbp), %eax
movl %eax, -0xd0(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2540
jmp 0x2358
leaq -0xc0(%rbp), %rdi
callq 0x2170
jmp 0x2366
leaq -0xc0(%rbp), %rdi
callq 0x3180
movl -0xb8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8(%rbp)
jmp 0x231c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x24fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x3180
jmp 0x24fe
leaq -0xb0(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x2600
jmp 0x23e0
leaq -0xe8(%rbp), %rdi
callq 0x2150
jmp 0x23ee
movl $0x0, -0xf4(%rbp)
cmpl $0x9, -0xf4(%rbp)
jge 0x2493
movl -0xf4(%rbp), %eax
movl %eax, -0x110(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x26c0
jmp 0x2434
leaq -0x100(%rbp), %rdi
callq 0x2170
jmp 0x2442
leaq -0x100(%rbp), %rdi
callq 0x3180
movl -0xf4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf4(%rbp)
jmp 0x23f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x24f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x3180
jmp 0x24f2
leaq -0xb0(%rbp), %rdi
callq 0x31b0
jmp 0x24a1
movl $0x5, -0x11c(%rbp)
leaq -0x118(%rbp), %rdi
leaq -0x11c(%rbp), %rsi
callq 0x33e0
jmp 0x24c0
leaq -0x118(%rbp), %rdi
callq 0x3330
jmp 0x24ce
leaq -0xe8(%rbp), %rdi
callq 0x3180
leaq -0xb0(%rbp), %rdi
callq 0x3400
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0xe8(%rbp), %rdi
callq 0x3180
leaq -0xb0(%rbp), %rdi
callq 0x3400
movq -0xd8(%rbp), %rdi
callq 0x2180
nopw %cs:(%rax,%rax)
// File: amukherj[P]concurrencyts/./barrier.h
// Function: concurrencyts::barrier_base<concurrencyts::flex_barrier>::arrive_and_wait()
void arrive_and_wait() {
    std::unique_lock<std::mutex> ul{lock};
    allow.wait(ul, [this]()->bool { return count > 0; });
  
    if (--count == 0) {
      ul.unlock();

      auto ffunc = static_cast<T*>(this)->final_func();
      if (ffunc) {
        // run the completion block
        auto tmp_count = ffunc();
        if (tmp_count >= 0) {
          // readjust max_count for next phase of barrier.
          max_count = tmp_count;
        }
      }

      // release all waiting threads
      done.notify_all();
    } else {
      done.wait(ul, [this]()->bool { return count == 0; });
      ul.unlock();
    }
  
    ul.lock();
    if (++released_count == max_count) {
      count = max_count;
      released_count = 0;
      ul.unlock();
      // allow all waiting threads
      allow.notify_all();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
addq $0x8, %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3850
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x3890
jmp 0x31f3
movq -0x58(%rbp), %rcx
movq 0x90(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x90(%rcx)
cmpq $0x0, %rax
jne 0x3287
leaq -0x18(%rbp), %rdi
callq 0x38e0
jmp 0x321a
movq -0x58(%rbp), %rdi
callq 0x3930
movq %rax, -0x60(%rbp)
jmp 0x3229
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3278
movq -0x38(%rbp), %rax
callq *%rax
movl %eax, -0x64(%rbp)
jmp 0x3243
movl -0x64(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x3276
movq -0x58(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x3276
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3a00
jmp 0x3318
jmp 0x3278
movq -0x58(%rbp), %rdi
addq $0x60, %rdi
callq 0x2140
jmp 0x32b2
movq -0x58(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
leaq -0x18(%rbp), %rsi
callq 0x3950
jmp 0x32a5
leaq -0x18(%rbp), %rdi
callq 0x38e0
jmp 0x32b0
jmp 0x32b2
leaq -0x18(%rbp), %rdi
callq 0x39a0
jmp 0x32bd
movq -0x58(%rbp), %rcx
movq 0x98(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x98(%rcx)
cmpq (%rcx), %rax
jne 0x3309
movq -0x58(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x90(%rax)
movq $0x0, 0x98(%rax)
leaq -0x18(%rbp), %rdi
callq 0x38e0
jmp 0x32fc
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
callq 0x2140
leaq -0x18(%rbp), %rdi
callq 0x3a00
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2180
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_vector_benchmark.cpp
// Function: main
int main(int argc, char* argv[])
{
   const std::size_t vec_size  = ((argc >= 2) ? atoi(argv[1]) : 100000);
   const std::string file_name = ((argc >  3) ? argv[2] : ""          );

   switch (argc)
   {
      case 2 : run_benchmark     <numeric_type>(vec_size          ); break;
      case 3 : run_file_benchmark<numeric_type>(vec_size,file_name); break;
   }

   return 0;
}

// Assembly:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
movl %edi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
cmpl $0x2, 0x70(%rsp)
jl 0x11c4e0
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x113290
movl %eax, 0x28(%rsp)
jmp 0x11c4eb
movl $0x186a0, %eax          # imm = 0x186A0
movl %eax, 0x28(%rsp)
jmp 0x11c4eb
movl 0x28(%rsp), %eax
cltq
movq %rax, 0x60(%rsp)
cmpl $0x3, 0x70(%rsp)
jle 0x11c50d
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x11c51b
leaq 0x33e36b(%rip), %rax    # 0x45a87f
movq %rax, 0x20(%rsp)
jmp 0x11c51b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1136c0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x11c7f0
jmp 0x11c54a
leaq 0x3f(%rsp), %rdi
callq 0x1137f0
movl 0x70(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x2, %eax
je 0x11c588
jmp 0x11c563
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x11c5b0
jmp 0x11c5c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x1137f0
jmp 0x11c5de
leaq 0x60(%rsp), %rdi
callq 0x11c910
jmp 0x11c594
jmp 0x11c5c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x113808
jmp 0x11c5de
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x11ca40
jmp 0x11c5c1
jmp 0x11c5c3
movl $0x0, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x113808
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1134c0
nopl (%rax,%rax)