LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CDISC2020[P]Projet_satellite_agile/src/GPIO.cpp
// Function: GPIOWrite(int, int)
int GPIOWrite(int pin, int value)
{
	static const char s_values_str[] = "01";
 
	char path[VALUE_MAX];
	int fd;
 
	snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
	fd = open(path, O_WRONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open gpio value for writing!\n");
		return(-1);
	}
 
	if (1 != write(fd, &s_values_str[LOW == value ? 0 : 1], 1)) {
		fprintf(stderr, "Failed to write value!\n");
		return(-1);
	}
 
	close(fd);
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
movl -0x8(%rbp), %ecx
movl $0x1e, %esi
leaq 0x20c4(%rip), %rdx      # 0x8685
movb $0x0, %al
callq 0x3440
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x31a0
movl %eax, -0x34(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x34(%rbp), %eax
jne 0x6606
movq 0x49ec(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x20eb(%rip), %rsi      # 0x86e1
movb $0x0, %al
callq 0x33b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x666b
movl -0x34(%rbp), %edi
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl %edx, %ecx
cmovel %ecx, %eax
cltq
leaq 0x2107(%rip), %rsi      # 0x8728
addq %rax, %rsi
movl $0x1, %edx
callq 0x3100
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
je 0x665c
movq 0x4996(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x20bd(%rip), %rsi      # 0x8709
movb $0x0, %al
callq 0x33b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x666b
movl -0x34(%rbp), %edi
callq 0x34f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/main_PM.cpp
// Function: Server_PM(void*)
void * Server_PM(void *args)
{
	PlanFilePath* f;
	Status* s;
	ModeStruct* m;

	char buffer[1024];
	int i; for(i=0; i>1024; i++) buffer[i] = '\0';

	while(1)
	{
		channelReceptionPM->RecvQueuingMsg(buffer);
		s = (Status*)buffer;

		if(s->code == 3) // nouveau plan
		{
			// ARRIVE de COM PLAN
			f=(PlanFilePath*)buffer;
			cout << "PLAN" << endl;

			pthread_mutex_lock(mu);              // verrouiller la ressource partagé
			PM.destructPlan();
			PM.generatePlan(f->filepath);
			pthread_mutex_unlock(mu);            // deverrouiller la ressource partagé
		}

		else if(s->code == 6) // Changement de mode
		{
			// ARRIVE de FDIR
			m = (ModeStruct*)buffer;
			mode = m->rpiMode;
		}

	        else if (s->code == 17) // telecommande
                {
			// ARRIVE de COM TM
			f=(PlanFilePath*)buffer;
			cout << "TM" << endl;

			// Comment cancel une TM !!? 
			pthread_mutex_lock(mu);              // verrouiller la ressource partagé
			planBack = PM.backup(); // on save ancien plan
			PM.generatePlan(f->filepath); 
			pthread_mutex_unlock(mu);            // deverrouiller la ressource partagé
                }

		usleep(100);
	}

	cout << "Terminaison du Thread " << tid_FD << endl;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl $0x0, -0x424(%rbp)
cmpl $0x400, -0x424(%rbp)    # imm = 0x400
jle 0x66c5
movslq -0x424(%rbp), %rax
movb $0x0, -0x420(%rbp,%rax)
movl -0x424(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x424(%rbp)
jmp 0x6699
jmp 0x66c7
movq 0x4d0a(%rip), %rdi      # 0xb3d8
leaq -0x420(%rbp), %rsi
callq 0x3c70
leaq -0x420(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x6758
leaq -0x420(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x48d0(%rip), %rdi      # 0xafd0
leaq 0x1d86(%rip), %rsi      # 0x848d
callq 0x3280
movq %rax, %rdi
movq 0x48aa(%rip), %rsi      # 0xafc0
callq 0x32b0
movq 0x4cc6(%rip), %rdi      # 0xb3e8
callq 0x33e0
leaq 0x4ba2(%rip), %rdi      # 0xb2d0
callq 0x5b20
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
leaq 0x4b8e(%rip), %rdi      # 0xb2d0
callq 0x5b90
movq 0x4c9a(%rip), %rdi      # 0xb3e8
callq 0x31c0
jmp 0x67f6
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x677d
leaq -0x420(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x4(%rax), %al
andb $0x1, %al
movb %al, 0x4c49(%rip)       # 0xb3c4
jmp 0x67f4
movq -0x18(%rbp), %rax
cmpl $0x11, (%rax)
jne 0x67f2
leaq -0x420(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x4838(%rip), %rdi      # 0xafd0
leaq 0x1f8c(%rip), %rsi      # 0x872b
callq 0x3280
movq %rax, %rdi
movq 0x4812(%rip), %rsi      # 0xafc0
callq 0x32b0
movq 0x4c2e(%rip), %rdi      # 0xb3e8
callq 0x33e0
leaq 0x4b0a(%rip), %rdi      # 0xb2d0
callq 0x5d50
movq %rax, 0x4c0e(%rip)      # 0xb3e0
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
leaq 0x4aef(%rip), %rdi      # 0xb2d0
callq 0x5b90
movq 0x4bfb(%rip), %rdi      # 0xb3e8
callq 0x31c0
jmp 0x67f4
jmp 0x67f6
movl $0x64, %edi
callq 0x3390
jmp 0x66c7
nopw %cs:(%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/main_PM.cpp
// Function: proceed()
void proceed()
{
	// Fonctionnement normal
	cout << endl << "Fonctionnement" << endl;
	pthread_mutex_lock(mu);              // verrouiller la ressource partagé
	PM.executePlan(&control, channelSM, mode);
	if(planBack!=NULL && PM.backup()==NULL)	// S'il existe
	{
		cout << endl << "TM Executee" << endl;
		PM.recover(planBack);
		planBack=NULL;
	}
	pthread_mutex_unlock(mu);            // deverrouiller la ressource partagé
	usleep(500000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x47a5(%rip), %rdi      # 0xafd0
movq 0x478e(%rip), %rsi      # 0xafc0
callq 0x32b0
movq %rax, %rdi
leaq 0x1eed(%rip), %rsi      # 0x872e
callq 0x3280
movq %rax, %rdi
movq 0x4770(%rip), %rsi      # 0xafc0
callq 0x32b0
movq 0x4b8c(%rip), %rdi      # 0xb3e8
callq 0x33e0
movq 0x4b68(%rip), %rdx      # 0xb3d0
movb 0x4b56(%rip), %al       # 0xb3c4
leaq 0x4a5b(%rip), %rdi      # 0xb2d0
leaq 0x4ac4(%rip), %rsi      # 0xb340
andb $0x1, %al
movzbl %al, %ecx
callq 0x5260
cmpq $0x0, 0x4b52(%rip)      # 0xb3e0
je 0x68f1
leaq 0x4a39(%rip), %rdi      # 0xb2d0
callq 0x5d50
cmpq $0x0, %rax
jne 0x68f1
movq 0x4727(%rip), %rdi      # 0xafd0
movq 0x4710(%rip), %rsi      # 0xafc0
callq 0x32b0
movq %rax, %rdi
leaq 0x1e7e(%rip), %rsi      # 0x873d
callq 0x3280
movq %rax, %rdi
movq 0x46f2(%rip), %rsi      # 0xafc0
callq 0x32b0
movq 0x4b06(%rip), %rsi      # 0xb3e0
leaq 0x49ef(%rip), %rdi      # 0xb2d0
callq 0x5db0
movq $0x0, 0x4aef(%rip) # 0xb3e0
movq 0x4af0(%rip), %rdi      # 0xb3e8
callq 0x31c0
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x3390
popq %rbp
retq
nopl (%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/main_PM.cpp
// Function: Alive(void*)
void* Alive(void* args)
{
	while(1)
	{	
		//str[100]='C' si vous êtes sur la Com, ='P' si vous êtes sur le plan
		char str[2]="P";
		channelFDIR->SendQueuingMsg(str, sizeof(str));

		usleep(10*1000); //10 ms
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movw 0x1de6(%rip), %ax       # 0x8749
movw %ax, -0xa(%rbp)
movq 0x4a5a(%rip), %rdi      # 0xb3c8
leaq -0xa(%rbp), %rsi
movl $0x2, %edx
callq 0x3c00
movl $0x2710, %edi           # imm = 0x2710
callq 0x3390
jmp 0x695c
nopl (%rax,%rax)
// File: renbozqin[P]blocking_queue/test.cpp
// Function: void thread2<int>(BlockingQueue<int>&, BlockingQueue<int>&)
void thread2(BlockingQueue<T> &queue, BlockingQueue<T>& queue2){
	int k = 0;
	while(1){
	while(queue.Size()){
		T front = queue.Take();
		queue2.Put(front);
		std::this_thread::sleep_for(std::chrono::milliseconds(37));
		k++;
	}
	if(k==queueSize) break;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
jmp 0x2999
movq -0x8(%rbp), %rdi
callq 0x4fc0
cmpq $0x0, %rax
je 0x29e9
movq -0x8(%rbp), %rdi
callq 0x4b90
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4990
movl $0x25, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x38c0
leaq -0x20(%rbp), %rdi
callq 0x3810
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2999
movslq -0x14(%rbp), %rax
cmpq $0xa, %rax
jne 0x29f5
jmp 0x29f7
jmp 0x2997
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: renbozqin[P]blocking_queue/test.cpp
// Function: void thread3<int>(BlockingQueue<int>&)
void thread3(BlockingQueue<T>& queue){
	int k = 0;
	while(1){
	while(queue.Size()){
		queue.Take();
		std::this_thread::sleep_for(std::chrono::milliseconds(18));
		k++;
	}
	if(k==queueSize)break;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
jmp 0x2ad5
movq -0x8(%rbp), %rdi
callq 0x4fc0
cmpq $0x0, %rax
je 0x2b15
movq -0x8(%rbp), %rdi
callq 0x4b90
movl $0x12, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x38c0
leaq -0x18(%rbp), %rdi
callq 0x3810
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ad5
movslq -0xc(%rbp), %rax
cmpq $0xa, %rax
jne 0x2b21
jmp 0x2b23
jmp 0x2ad3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: renbozqin[P]blocking_queue/blocking_queue.cpp
// Function: BlockingQueue<int>::Put(int const&)
void BlockingQueue<T>::Put(const T& task){
	std::unique_lock<std::mutex> lock(mtx);
	full_.wait(lock, [this]{return (queue_.size() < capacity_);} );
	assert(queue_.size() < capacity_);
	queue_.push(task);
	empty_.notify_all(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x4a70
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
callq 0x4ab0
jmp 0x49d3
movq -0x48(%rbp), %rdi
addq $0x88, %rdi
callq 0x4b00
movq %rax, -0x50(%rbp)
jmp 0x49e9
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq 0xd8(%rcx), %rax
jae 0x49fc
jmp 0x4a32
leaq 0x5715(%rip), %rdi      # 0xa118
leaq 0x5728(%rip), %rsi      # 0xa132
movl $0x7, %edx
leaq 0x572f(%rip), %rcx      # 0xa145
callq 0x20c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4b50
jmp 0x4a64
movq -0x48(%rbp), %rdi
addq $0x88, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b20
jmp 0x4a48
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
callq 0x21d0
leaq -0x20(%rbp), %rdi
callq 0x4b50
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x21f0
nopl (%rax)
// File: renbozqin[P]blocking_queue/blocking_queue.cpp
// Function: BlockingQueue<int>::Take()
T BlockingQueue<T>::Take(){
	std::unique_lock<std::mutex> lock(mtx);
	empty_.wait(lock, [this]{return !queue_.empty();} );
	assert(!queue_.empty());
	T front(queue_.front());
	queue_.pop();
	full_.notify_all();
	return front;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4a70
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x58, %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x4c90
jmp 0x4bcf
movq -0x40(%rbp), %rdi
addq $0x88, %rdi
callq 0x4ce0
movb %al, -0x41(%rbp)
jmp 0x4be4
movb -0x41(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4bef
jmp 0x4bf1
jmp 0x4c27
leaq 0x557f(%rip), %rdi      # 0xa177
leaq 0x5533(%rip), %rsi      # 0xa132
movl $0x10, %edx
leaq 0x557c(%rip), %rcx      # 0xa187
callq 0x20c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4b50
jmp 0x4c7d
movq -0x40(%rbp), %rdi
addq $0x88, %rdi
callq 0x4d00
movq %rax, -0x50(%rbp)
jmp 0x4c3d
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
addq $0x88, %rdi
callq 0x4d20
jmp 0x4c58
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x21d0
movl -0x30(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4b50
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21f0
nopw %cs:(%rax,%rax)
// File: renbozqin[P]blocking_queue/blocking_queue.cpp
// Function: BlockingQueue<int>::Front()
T BlockingQueue<T>::Front(){
	std::unique_lock<std::mutex> lock(mtx);
	empty_.wait(lock, [this]{return !queue_.empty();} );
	assert(!queue_.empty());
	T front(queue_.front());
	return front;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4a70
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x58, %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x4e20
jmp 0x4d7f
movq -0x40(%rbp), %rdi
addq $0x88, %rdi
callq 0x4ce0
movb %al, -0x41(%rbp)
jmp 0x4d94
movb -0x41(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4d9f
jmp 0x4da1
jmp 0x4dd7
leaq 0x53cf(%rip), %rdi      # 0xa177
leaq 0x5383(%rip), %rsi      # 0xa132
movl $0x21, %edx
leaq 0x53f3(%rip), %rcx      # 0xa1ae
callq 0x20c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4b50
jmp 0x4e0e
movq -0x40(%rbp), %rdi
addq $0x88, %rdi
callq 0x4d00
movq %rax, -0x50(%rbp)
jmp 0x4ded
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4b50
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21f0
nopw (%rax,%rax)
// File: renbozqin[P]blocking_queue/blocking_queue.cpp
// Function: BlockingQueue<int>::Back()
T BlockingQueue<T>::Back(){
	std::unique_lock<std::mutex> lock(mtx);
	empty_.wait(lock, [this]{return !queue_.empty();} );
	assert(!queue_.empty());
	T back(queue_.back());
	return back;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4a70
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x58, %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x4f50
jmp 0x4eaf
movq -0x40(%rbp), %rdi
addq $0x88, %rdi
callq 0x4ce0
movb %al, -0x41(%rbp)
jmp 0x4ec4
movb -0x41(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4ecf
jmp 0x4ed1
jmp 0x4f07
leaq 0x529f(%rip), %rdi      # 0xa177
leaq 0x5253(%rip), %rsi      # 0xa132
movl $0x2a, %edx
leaq 0x52eb(%rip), %rcx      # 0xa1d6
callq 0x20c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4b50
jmp 0x4f3e
movq -0x40(%rbp), %rdi
addq $0x88, %rdi
callq 0x4fa0
movq %rax, -0x50(%rbp)
jmp 0x4f1d
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4b50
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21f0
nopw (%rax,%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: FastaIndexEntry::clear()
void FastaIndexEntry::clear(void)
{
    name = "";
    length = 0;
    offset = -1;  // no real offset will ever be below 0, so this allows us to
                  // check if we have already recorded a real offset
    line_blen = 0;
    line_len = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0xa80b(%rip), %rsi      # 0xe016
callq 0x3410
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq $-0x1, 0x28(%rax)
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: operator<<(std::ostream&, FastaIndexEntry const&)
ostream& operator<<(ostream& output, const FastaIndexEntry& e) {
    // just write the first component of the name, for compliance with other tools
    output << split(e.name, ' ').at(0) << "\t" << e.length << "\t" << e.offset << "\t" <<
        e.line_blen << "\t" << e.line_len;
    return output;  // for multiple << operators.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x20, %edx
callq 0xc900
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5a00
movq %rax, -0x40(%rbp)
jmp 0x38a4
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x3290
movq %rax, -0x58(%rbp)
jmp 0x38b7
movq -0x58(%rbp), %rdi
leaq 0xa753(%rip), %rsi      # 0xe015
callq 0x32c0
movq %rax, -0x60(%rbp)
jmp 0x38cd
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3530
movq %rax, -0x68(%rbp)
jmp 0x38e3
movq -0x68(%rbp), %rdi
leaq 0xa727(%rip), %rsi      # 0xe015
callq 0x32c0
movq %rax, -0x70(%rbp)
jmp 0x38f9
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x3160
movq %rax, -0x78(%rbp)
jmp 0x3910
movq -0x78(%rbp), %rdi
leaq 0xa6fa(%rip), %rsi      # 0xe015
callq 0x32c0
movq %rax, -0x80(%rbp)
jmp 0x3926
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x3530
movq %rax, -0x88(%rbp)
jmp 0x393f
movq -0x88(%rbp), %rdi
leaq 0xa6c8(%rip), %rsi      # 0xe015
callq 0x32c0
movq %rax, -0x90(%rbp)
jmp 0x395b
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x3530
jmp 0x3970
leaq -0x28(%rbp), %rdi
callq 0x5a40
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5a40
movq -0x30(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: operator<<(std::ostream&, FastaIndex&)
ostream& operator<<(ostream& output, FastaIndex& fastaIndex) {
    vector<FastaIndexEntry> sortedIndex;
    for(vector<string>::const_iterator it = fastaIndex.sequenceNames.begin(); it != fastaIndex.sequenceNames.end(); ++it)
    {
        sortedIndex.push_back(fastaIndex[*it]);
    }
    sort(sortedIndex.begin(), sortedIndex.end(), fastaIndexEntryCompare);
    for( vector<FastaIndexEntry>::iterator fit = sortedIndex.begin(); fit != sortedIndex.end(); ++fit) {
        output << *fit << endl;
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5d50
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x5d70
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5da0
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x5e20
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5de0
testb $0x1, %al
jne 0x402e
jmp 0x4087
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5fa0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x5ec0
movq %rax, -0x78(%rbp)
jmp 0x4051
movq -0x78(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5e50
jmp 0x4060
jmp 0x4062
leaq -0x30(%rbp), %rdi
callq 0x5fc0
jmp 0x400a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6110
jmp 0x4160
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6030
movq -0x88(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x6060
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
leaq -0x10a(%rip), %rdx      # 0x3fb0
callq 0x5fe0
jmp 0x40c1
leaq -0x28(%rbp), %rdi
callq 0x6030
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6060
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6090
testb $0x1, %al
jne 0x40ee
jmp 0x413c
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x60d0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x3860
movq %rax, -0x90(%rbp)
jmp 0x411a
movq -0x90(%rbp), %rdi
movq 0xfe80(%rip), %rsi      # 0x13fa8
callq 0x3320
jmp 0x412f
jmp 0x4131
leaq -0x68(%rbp), %rdi
callq 0x60f0
jmp 0x40ce
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6110
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3540
nopl (%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: getlineCounting(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&)
bool getlineCounting(istream& in, string& line, int& bytes) {
    bytes = 0;
    line.clear();
    for(int got = in.get(); got != EOF; got = in.get()) {
        bytes++;
        if (got == '\n') {
            // Line is over, but we read something (the '\n')
            return true;
        } else if (got != '\r') {
            // Anything other than a '\r' is real data.
            line.push_back((char)got);
        }
        // '\r' is skipped, but still counted in bytes
    }
    return !line.empty();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x3400
movq -0x10(%rbp), %rdi
callq 0x33a0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0x41e7
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpl $0xa, -0x24(%rbp)
jne 0x41c0
movb $0x1, -0x1(%rbp)
jmp 0x41f7
cmpl $0xd, -0x24(%rbp)
je 0x41d5
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movsbl %al, %esi
callq 0x3270
jmp 0x41d7
jmp 0x41d9
movq -0x10(%rbp), %rdi
callq 0x33a0
movl %eax, -0x24(%rbp)
jmp 0x41a3
movq -0x18(%rbp), %rdi
callq 0x3510
xorb $-0x1, %al
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: ekg[P]fastahack/Fasta.cpp
// Function: FastaIndex::flushEntryToIndex(FastaIndexEntry&)
void FastaIndex::flushEntryToIndex(FastaIndexEntry& entry) {
    string name = split(entry.name, " \t").at(0);  // key by first token of name
    sequenceNames.push_back(name);
    this->insert(make_pair(name, FastaIndexEntry(entry.name, entry.length,
                        entry.offset, entry.line_blen,
                        entry.line_len)));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x3550
movq -0x148(%rbp), %rdx
leaq 0x988d(%rip), %rsi      # 0xe014
leaq -0x68(%rbp), %rdi
callq 0x5b80
jmp 0x4792
movq -0x150(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0xcaf0
jmp 0x47a8
xorl %eax, %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdi
callq 0x5a00
movq %rax, -0x160(%rbp)
jmp 0x47be
movq -0x160(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3130
jmp 0x47d0
leaq -0x48(%rbp), %rdi
callq 0x5a40
leaq -0x68(%rbp), %rdi
callq 0x31a0
leaq -0x69(%rbp), %rdi
callq 0x3340
movq -0x158(%rbp), %rdi
addq $0x30, %rdi
leaq -0x30(%rbp), %rsi
callq 0x5c30
jmp 0x4801
movq -0x10(%rbp), %rsi
leaq -0x130(%rbp), %rdi
callq 0x3130
jmp 0x4813
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
movq 0x28(%rax), %rcx
movl 0x30(%rax), %r8d
movl 0x34(%rax), %r9d
leaq -0x110(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x3750
jmp 0x483b
leaq -0xd8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x110(%rbp), %rdx
callq 0x5ce0
jmp 0x4854
movq -0x158(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x5ca0
movb %dl, -0x169(%rbp)
movq %rax, -0x168(%rbp)
jmp 0x4876
movb -0x169(%rbp), %al
movq -0x168(%rbp), %rcx
movq %rcx, -0x140(%rbp)
movb %al, -0x138(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x5d20
leaq -0x110(%rbp), %rdi
callq 0x3840
leaq -0x130(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4900
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x48f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5a40
leaq -0x68(%rbp), %rdi
callq 0x31a0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x496e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4965
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4959
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x494d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x5d20
leaq -0x110(%rbp), %rdi
callq 0x3840
leaq -0x130(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x78(%rbp), %rdi
callq 0x3540
nopw (%rax,%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: FastaIndex::writeIndexFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FastaIndex::writeIndexFile(string fname) {
    //cerr << "writing fasta index file " << fname << endl;
    ofstream file;
    file.open(fname.c_str()); 
    if (file.is_open()) {
        file << *this;
    } else { 
        cerr << "could not open index file " << fname << " for writing!" << endl;
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rsi, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x3520
movq -0x230(%rbp), %rdi
callq 0x3120
movq -0x228(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x3070
jmp 0x49da
leaq -0x210(%rbp), %rdi
callq 0x3230
movb %al, -0x239(%rbp)
jmp 0x49ee
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x49fa
jmp 0x4a37
movq -0x238(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x3fd0
jmp 0x4a0f
jmp 0x4aaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3450
jmp 0x4abf
movq 0xf5b2(%rip), %rdi      # 0x13ff0
leaq 0x961b(%rip), %rsi      # 0xe060
callq 0x32c0
movq %rax, -0x248(%rbp)
jmp 0x4a53
movq -0x230(%rbp), %rsi
movq -0x248(%rbp), %rdi
callq 0x3290
movq %rax, -0x250(%rbp)
jmp 0x4a6f
movq -0x250(%rbp), %rdi
leaq 0x96ad(%rip), %rsi      # 0xe12a
callq 0x32c0
movq %rax, -0x258(%rbp)
jmp 0x4a8b
movq -0x258(%rbp), %rdi
movq 0xf50f(%rip), %rsi      # 0x13fa8
callq 0x3320
jmp 0x4aa0
movl $0x1, %edi
callq 0x33b0
leaq -0x210(%rbp), %rdi
callq 0x3450
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x3540
nopl (%rax,%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: FastaIndex::entry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FastaIndexEntry FastaIndex::entry(string name) {
    FastaIndex::iterator e = this->find(name);
    if (e == this->end()) {
        cerr << "unable to find FASTA index entry for '" << name << "'" << endl;
        exit(1);
    } else {
        return e->second;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rdi, -0x40(%rbp)
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x61b0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x6210
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x61e0
testb $0x1, %al
jne 0x4b8b
jmp 0x4bd2
movq 0xf45e(%rip), %rdi      # 0x13ff0
leaq 0x959f(%rip), %rsi      # 0xe138
callq 0x32c0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
leaq 0x95a9(%rip), %rsi      # 0xe15d
callq 0x32c0
movq %rax, %rdi
movq 0xf3e5(%rip), %rsi      # 0x13fa8
callq 0x3320
movl $0x1, %edi
callq 0x33b0
leaq -0x20(%rbp), %rdi
callq 0x6240
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x6260
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: FastaReference::~FastaReference()
FastaReference::~FastaReference(void) {
    if (file != NULL)
      fclose(file);
    if (index != NULL)
      delete index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x4fec
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x32d0
jmp 0x4fea
jmp 0x4fec
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x5022
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5020
movq -0x18(%rbp), %rdi
callq 0x4ad0
movq -0x18(%rbp), %rdi
movl $0x280, %esi            # imm = 0x280
callq 0x32f0
jmp 0x5022
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x31a0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x61a0
nopl (%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: FastaReference::sequenceNameStartingWith(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string FastaReference::sequenceNameStartingWith(string seqnameStart) {
    try {
        return (*index)[seqnameStart].name;
    } catch (exception& e) {
        cerr << e.what() << ": unable to find index entry for " << seqnameStart << endl;
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x50(%rbp)
movq %rsi, %rax
movq -0x50(%rbp), %rsi
movq %rdi, -0x48(%rbp)
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x5ec0
movq %rax, -0x38(%rbp)
jmp 0x536d
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3130
jmp 0x537c
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x542b
movq -0x20(%rbp), %rdi
callq 0x3110
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0xec2a(%rip), %rdi      # 0x13ff0
callq 0x32c0
movq %rax, -0x58(%rbp)
jmp 0x53d1
movq -0x58(%rbp), %rdi
leaq 0x8daf(%rip), %rsi      # 0xe18b
callq 0x32c0
movq %rax, -0x60(%rbp)
jmp 0x53e7
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x3290
movq %rax, -0x68(%rbp)
jmp 0x53fa
movq -0x68(%rbp), %rdi
movq 0xeba3(%rip), %rsi      # 0x13fa8
callq 0x3320
jmp 0x540c
movl $0x1, %edi
callq 0x33b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x34f0
jmp 0x5429
jmp 0x542b
movq -0x20(%rbp), %rdi
callq 0x3540
movq %rax, %rdi
callq 0x61a0
nopl (%rax)
// File: ekg[P]fastahack/Fasta.cpp
// Function: FastaReference::getTargetSubSequence[abi:cxx11](FastaRegion&)
string FastaReference::getTargetSubSequence(FastaRegion& target) {
    if (target.startPos == -1) {
        return getSequence(target.startSeq);
    } else {
        return getSubSequence(target.startSeq, target.startPos - 1, target.length());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
jne 0x54c3
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3130
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x5040
jmp 0x549e
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x552e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x553b
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3130
movq -0x18(%rbp), %rdi
movl 0x20(%rdi), %eax
decl %eax
movl %eax, -0x90(%rbp)
callq 0x6350
movl %eax, -0x8c(%rbp)
jmp 0x54ec
movl -0x8c(%rbp), %r8d
movl -0x90(%rbp), %ecx
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x5550
jmp 0x550c
leaq -0x68(%rbp), %rdi
callq 0x31a0
jmp 0x552e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31a0
jmp 0x553b
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: ekg[P]fastahack/./Region.h
// Function: FastaRegion::length()
int length(void) {
        if (stopPos > 0) {
            return stopPos - startPos + 1;
        } else {
            return 1;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x24(%rax)
jle 0x6378
movq -0x18(%rbp), %rcx
movl 0x24(%rcx), %eax
subl 0x20(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x637f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ekg[P]fastahack/disorder.c
// Function: initialize_lib()
static void
initialize_lib()
{
  int i = 0;
  if(1==LIBDISORDER_INITIALIZED)
    return;

  m_num_tokens = 0;

  for(i=0;i<LIBDO_MAX_BYTES;i++)
  {
    m_token_freqs[i]=0;
    m_token_probs[i]=0.0;
  }

  LIBDISORDER_INITIALIZED = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl $0x1, %eax
cmpl 0x6eea(%rip), %eax      # 0x143e0
jne 0xd4fa
jmp 0xd54e
movl $0x0, 0x6ee8(%rip)      # 0x143ec
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0xd544
movslq -0x4(%rbp), %rcx
leaq 0x6ed1(%rip), %rax      # 0x143f0
movl $0x0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x72bf(%rip), %rax      # 0x147f0
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd50b
movl $0x1, 0x6e92(%rip)      # 0x143e0
popq %rbp
retq
// File: ekg[P]fastahack/disorder.c
// Function: get_token_frequencies(char*, long long)
static void
get_token_frequencies(char* buf, 
		      long long length)
{
  int i=0;
  char* itr=NULL;
  unsigned char c=0;

  itr = buf;

  //reset number of tokens
  m_num_tokens = 0;

  //make sure freqency and probability arrays are cleared
  for(i=0;i<LIBDO_MAX_BYTES;i++)
  {
    m_token_freqs[i] = 0;
    m_token_probs[i] = 0.0;
  }

  for(i=0;i<length;i++)
  {
    c = (unsigned char)*itr;
    //assert(0<=c<LIBDO_MAX_BYTES);
    m_token_freqs[c]++;
    itr++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, 0x6e6b(%rip)      # 0x143ec
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0xd5c1
movslq -0x14(%rbp), %rcx
leaq 0x6e54(%rip), %rax      # 0x143f0
movl $0x0, (%rax,%rcx,4)
movslq -0x14(%rbp), %rcx
leaq 0x7242(%rip), %rax      # 0x147f0
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd588
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0xd60f
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
leaq 0x6e08(%rip), %rax      # 0x143f0
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x6dfb(%rip), %rax      # 0x143f0
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd5c8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ekg[P]fastahack/disorder.c
// Function: count_num_tokens()
static void
count_num_tokens()
{
  int i = 0;
  int counter = 0;
  for(i=0;i<LIBDO_MAX_BYTES;i++)
  {
    if(0!=m_token_freqs[i])
    {
      counter++;
    }
  }
  m_num_tokens = counter;
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0xd66a
movslq -0x4(%rbp), %rdx
xorl %eax, %eax
leaq 0x6da1(%rip), %rcx      # 0x143f0
cmpl (%rcx,%rdx,4), %eax
je 0xd65d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xd65f
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd639
movl -0x8(%rbp), %eax
movl %eax, 0x6d79(%rip)      # 0x143ec
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day06/ex01/main.cpp
// Function: serialize()
void	*serialize(void)
{
	const char	alph[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
	char		*res = new char[16 + sizeof(int)];

	for (int i = 0; i < 8; i++)
		res[i] = alph[std::rand() % 62];
	*reinterpret_cast<int*>(res + 8) = std::rand();
	for (int i = 8 + sizeof(int); (unsigned int)i < 16 + sizeof(int); i++)
		res[i] = alph[std::rand() % 62];
	return ((void*)res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x40(%rbp), %rdi
leaq 0xd3d(%rip), %rsi       # 0x2010
movl $0x3f, %edx
callq 0x1060
movl $0x14, %edi
callq 0x1030
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
cmpl $0x8, -0x4c(%rbp)
jge 0x1322
callq 0x1040
movl $0x3e, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movb -0x40(%rbp,%rax), %dl
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x12f2
callq 0x1040
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0xc, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpq $0x14, %rax
jae 0x136a
callq 0x1040
movl $0x3e, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movb -0x40(%rbp,%rax), %dl
movq -0x48(%rbp), %rax
movslq -0x50(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x1337
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day06/ex01/main.cpp
// Function: deserialize(void*)
Data 	*deserialize(void *addr)
{
	Data	*data = new Data;
	char	*raw = reinterpret_cast<char*>(addr);

	data->s1 = std::string(raw, 8);
	data->s2 = std::string(raw + 8 + sizeof(int), 8);
	data->n = *reinterpret_cast<int *>(raw + 8);
	return (data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x48, %edi
callq 0x10c0
movq %rax, %rdi
movq %rdi, -0x90(%rbp)
callq 0x15e0
movq -0x90(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1170
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x8, %edx
callq 0x1100
jmp 0x13ee
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x1110
movq -0xa8(%rbp), %rdi
callq 0x1050
leaq -0x39(%rbp), %rdi
callq 0x10f0
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0xa0(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1170
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rcx
leaq -0x70(%rbp), %rdi
movl $0x8, %edx
callq 0x1100
jmp 0x1454
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
leaq -0x70(%rbp), %rsi
callq 0x1110
leaq -0x70(%rbp), %rdi
callq 0x1050
leaq -0x71(%rbp), %rdi
callq 0x10f0
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x10f0
jmp 0x14be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x71(%rbp), %rdi
callq 0x10f0
movq -0x48(%rbp), %rdi
callq 0x1160
nopw (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day06/ex01/main.cpp
// Function: main
int		main(void)
{
	void	*addr = serialize();
	Data	*data = deserialize(addr);

	std::srand(time(0));
	std::cout << "s1: " << data->s1 << std::endl;
	std::cout << "s2: " << data->s2 << std::endl;
	std::cout << "n : " << data->n << std::endl;

	delete []reinterpret_cast<char*>(addr);
	delete data;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
callq 0x12c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1380
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x10a0
movq 0x2acc(%rip), %rdi      # 0x3fd8
leaq 0xb3c(%rip), %rsi       # 0x204f
callq 0x10b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1080
movq %rax, %rdi
movq 0x2a9a(%rip), %rsi      # 0x3fc8
callq 0x10e0
movq 0x2a9e(%rip), %rdi      # 0x3fd8
leaq 0xb13(%rip), %rsi       # 0x2054
callq 0x10b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x1080
movq %rax, %rdi
movq 0x2a68(%rip), %rsi      # 0x3fc8
callq 0x10e0
movq 0x2a6c(%rip), %rdi      # 0x3fd8
leaq 0xae6(%rip), %rsi       # 0x2059
callq 0x10b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x1150
movq %rax, %rdi
movq 0x2a37(%rip), %rsi      # 0x3fc8
callq 0x10e0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x15ad
movq -0x20(%rbp), %rdi
callq 0x1120
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x15d2
movq -0x28(%rbp), %rdi
callq 0x1610
movq -0x28(%rbp), %rdi
movl $0x48, %esi
callq 0x10d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ikatanic[P]lcskpp/./utils.h
// Function: product_fits_in_63bits(unsigned long, unsigned long, unsigned long*)
bool product_fits_in_63bits(uint64_t a, uint64_t b, uint64_t* c) {
  if (a <= LLONG_MAX / b) {
    *c = a * b;
    return true;
  }
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rsp)
movq %rax, %rcx
movq -0x28(%rsp), %rax
cmpq %rcx, %rax
ja 0x2473
movq -0x10(%rsp), %rcx
imulq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rsp)
jmp 0x2478
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: ikatanic[P]lcskpp/./utils.h
// Function: power_fits_in_63bits(unsigned long, unsigned long, unsigned long*)
bool power_fits_in_63bits(uint64_t a, uint64_t b, uint64_t* c) {
  *c = 1;
  while (b > 0) {
    if (!product_fits_in_63bits(*c, a, c)) return false;
    b--;
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x1, (%rax)
cmpq $0x0, 0x10(%rsp)
jbe 0x24d9
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2420
testb $0x1, %al
jne 0x24c9
movb $0x0, 0x27(%rsp)
jmp 0x24de
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x249f
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: mindbeast[P]rnes/main.cpp
// Function: Rnes::getUserHomeDir[abi:cxx11]()
std::string getUserHomeDir() {
  struct passwd pwd = {0};
  struct passwd *pwdRet;
  char buf[1024];

  getpwuid_r(getuid(), &pwd, buf, sizeof(buf), &pwdRet);

  using namespace std;
  string homeDir(pwdRet->pw_dir);
  return homeDir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp            # imm = 0x490
movq %rdi, -0x480(%rbp)
movq %rdi, %rax
movq %rax, -0x488(%rbp)
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
callq 0xe460
movl %eax, %edi
leaq -0x40(%rbp), %rsi
leaq -0x450(%rbp), %rdx
movl $0x400, %ecx            # imm = 0x400
leaq -0x48(%rbp), %r8
callq 0xe790
movb $0x0, -0x451(%rbp)
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x478(%rbp)
leaq -0x452(%rbp), %rdi
movq %rdi, -0x470(%rbp)
callq 0xea50
movq -0x480(%rbp), %rdi
movq -0x478(%rbp), %rsi
movq -0x470(%rbp), %rdx
callq 0x19b90
jmp 0x18454
leaq -0x452(%rbp), %rdi
callq 0xed50
movb $0x1, -0x451(%rbp)
testb $0x1, -0x451(%rbp)
jne 0x1849e
jmp 0x18492
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x460(%rbp)
movl %eax, -0x464(%rbp)
leaq -0x452(%rbp), %rdi
callq 0xed50
jmp 0x184ae
movq -0x480(%rbp), %rdi
callq 0xed78
movq -0x488(%rbp), %rax
addq $0x490, %rsp            # imm = 0x490
popq %rbp
retq
movq -0x460(%rbp), %rdi
callq 0xe700
nopw (%rax,%rax)
// File: mindbeast[P]rnes/main.cpp
// Function: Rnes::setupDirectories(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void setupDirectories(std::string romMd5) {
  namespace fs = boost::filesystem;

  fs::path homeDir(getUserHomeDir());
  fs::path rnesDir(homeDir);
  rnesDir /= ".rnes";

  if (not fs::exists(rnesDir)) {
    fs::create_directories(rnesDir);
  }

  fs::path gamePath(rnesDir);
  gamePath /= fs::path(romMd5);
  if (not fs::exists(gamePath)) {
    fs::create_directories(gamePath);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x183c0
movq -0xc0(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x19f00
jmp 0x18658
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x19f30
jmp 0x18670
leaq 0x4f9e5(%rip), %rsi     # 0x6805c
leaq -0x78(%rbp), %rdi
callq 0xe9e0
jmp 0x18682
leaq -0x78(%rbp), %rdi
callq 0x19f60
movb %al, -0xc9(%rbp)
jmp 0x18693
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x186e8
jmp 0x1869f
leaq -0x78(%rbp), %rdi
callq 0x19f90
jmp 0x186aa
jmp 0x186e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xed78
jmp 0x187cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x187c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x187bb
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x19f30
jmp 0x186fa
movq -0xc8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x19fc0
jmp 0x1870f
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0xec30
jmp 0x18724
leaq -0xb8(%rbp), %rdi
callq 0x19ff0
leaq -0x98(%rbp), %rdi
callq 0x19f60
movb %al, -0xca(%rbp)
jmp 0x18744
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x18788
jmp 0x18750
leaq -0x98(%rbp), %rdi
callq 0x19f90
jmp 0x1875e
jmp 0x18788
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x187af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x19ff0
jmp 0x187af
leaq -0x98(%rbp), %rdi
callq 0x19ff0
leaq -0x78(%rbp), %rdi
callq 0x19ff0
leaq -0x28(%rbp), %rdi
callq 0x19ff0
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x98(%rbp), %rdi
callq 0x19ff0
leaq -0x78(%rbp), %rdi
callq 0x19ff0
leaq -0x28(%rbp), %rdi
callq 0x19ff0
movq -0x50(%rbp), %rdi
callq 0xe700
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/main.cpp
// Function: Rnes::verifyRomExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void verifyRomExists(std::string romFile) {
  namespace fs = boost::filesystem;
  using namespace std;

  fs::path path(romFile);
  if (not fs::exists(path) or not fs::is_regular_file(path)) {
    cerr << "specified rom file does not exist: " << romFile << endl;
    exit(-1);
  }
  cerr << "rom md5: " << md5OfFile(romFile) << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, %rsi
movq %rsi, -0x90(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x19fc0
movq -0x88(%rbp), %rdi
callq 0x19f60
movb %al, -0x79(%rbp)
jmp 0x1881a
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x18823
jmp 0x18840
leaq -0x28(%rbp), %rdi
callq 0x1a010
movb %al, -0x91(%rbp)
jmp 0x18834
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x188a8
jmp 0x18840
movq 0x797a1(%rip), %rdi     # 0x91fe8
leaq 0x4f814(%rip), %rsi     # 0x68062
callq 0xe680
movq %rax, -0xa0(%rbp)
jmp 0x1885c
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0xe3e0
movq %rax, -0xa8(%rbp)
jmp 0x18878
movq -0xa8(%rbp), %rdi
movq 0x79752(%rip), %rsi     # 0x91fd8
callq 0xeae0
jmp 0x1888d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xe730
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x18963
movq 0x79739(%rip), %rdi     # 0x91fe8
leaq 0x4f7d0(%rip), %rsi     # 0x68086
callq 0xe680
movq %rax, -0xb0(%rbp)
jmp 0x188c4
movq -0x90(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xe1a0
jmp 0x188d6
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x180f0
jmp 0x188e5
movq -0xb0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe3e0
movq %rax, -0xb8(%rbp)
jmp 0x188fe
movq -0xb8(%rbp), %rdi
movq 0x796cc(%rip), %rsi     # 0x91fd8
callq 0xeae0
jmp 0x18913
leaq -0x58(%rbp), %rdi
callq 0xed78
leaq -0x78(%rbp), %rdi
callq 0xed78
leaq -0x28(%rbp), %rdi
callq 0x19ff0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1895a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xed78
leaq -0x78(%rbp), %rdi
callq 0xed78
leaq -0x28(%rbp), %rdi
callq 0x19ff0
movq -0x30(%rbp), %rdi
callq 0xe700
nopw %cs:(%rax,%rax)