LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: marcellapantarotto[P]pseudoSO/memory.cpp
// Function: Memory::allocation(unsigned int, int)
unsigned int Memory::allocation(unsigned int qtd, int tipo_p){
	unsigned int offset = MAX_MEM;
	switch(tipo_p){
		case REAL_TIME:
			if(qtd > MAX_REAL){
				offset = 1025;
				return offset;
			}
			offset = verification(qtd,START,MAX_REAL);
		  break;
		default:
			if(qtd > USER_MAX){
				offset = 1025;
				return offset;
			}
			offset = verification(qtd,MAX_REAL,MAX_MEM);
			break;
	}

	if(offset!=MAX_MEM)
		for(int i=offset;i<qtd + offset;i++){
			memoir[i] = 1;
		}
	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x400, -0x1c(%rbp)     # imm = 0x400
movl -0x18(%rbp), %eax
testl %eax, %eax
jne 0x3d6a
jmp 0x3d3a
cmpl $0x40, -0x14(%rbp)
jbe 0x3d52
movl $0x401, -0x1c(%rbp)     # imm = 0x401
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3df2
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
movl $0x40, %ecx
callq 0x3e00
movl %eax, -0x1c(%rbp)
jmp 0x3d9b
cmpl $0x3c0, -0x14(%rbp)     # imm = 0x3C0
jbe 0x3d82
movl $0x401, -0x1c(%rbp)     # imm = 0x401
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3df2
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x40, %edx
movl $0x400, %ecx            # imm = 0x400
callq 0x3e00
movl %eax, -0x1c(%rbp)
cmpl $0x400, -0x1c(%rbp)     # imm = 0x400
je 0x3dec
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jae 0x3dea
movq -0x38(%rbp), %rsi
movslq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3f60
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3fa0
leaq -0x30(%rbp), %rdi
callq 0x4010
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3daa
jmp 0x3dec
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: marcellapantarotto[P]pseudoSO/memory.cpp
// Function: Memory::verification(unsigned int, unsigned int, unsigned int)
unsigned int Memory::verification(unsigned int qtd, unsigned int start, unsigned int end){
	unsigned int offset = MAX_MEM;
	int j;

	for(int i = start; i < end; i++) {
		j = i;
		while (memoir[j] == 0 && j < qtd + i) j++;
		if (j == qtd + i){
			offset = i;
			break;
		}
		else i = j;
	}
	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x400, -0x18(%rbp)     # imm = 0x400
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x3ec4
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3f60
leaq -0x30(%rbp), %rdi
callq 0x4020
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
jne 0x3e76
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
movb %al, -0x3a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4010
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x3e8e
jmp 0x3e99
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3e3c
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3eae
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3ec4
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3eb6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3e2a
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: marcellapantarotto[P]pseudoSO/memory.cpp
// Function: Memory::deallocation(unsigned int, unsigned int)
void Memory::deallocation(unsigned int offset,unsigned int qtd){
	int i = offset;
	while(i<qtd+offset) {
		memoir[i] = 0;
		i++;
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jae 0x3f2d
movq -0x30(%rbp), %rsi
movslq -0x14(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x3f60
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x3fa0
leaq -0x28(%rbp), %rdi
callq 0x4010
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3ef0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: marcellapantarotto[P]pseudoSO/resource.cpp
// Function: InitializeSemaphores()
void InitializeSemaphores()
{
	// sem_init() inicializa o semáforo
	// primeiro argumento determina se o semáforo é compartilhado ou não:
	// 			0 = compartilhado entre threas de um processo; !0 = compartilhado entre pocessos
	// segundo argumento indica o valor do semáforo
	sem_init(&scanner, 0, 1);
	sem_init(&printer, 0, 2);
	sem_init(&modem, 0, 1);
	sem_init(&sata, 0, 2);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xafdd(%rip), %rdi      # 0xf178
xorl %esi, %esi
movl $0x1, %edx
callq 0x2110
leaq 0xafea(%rip), %rdi      # 0xf198
xorl %esi, %esi
movl $0x2, %edx
callq 0x2110
leaq 0xaff7(%rip), %rdi      # 0xf1b8
xorl %esi, %esi
movl $0x1, %edx
callq 0x2110
leaq 0xb004(%rip), %rdi      # 0xf1d8
xorl %esi, %esi
movl $0x2, %edx
callq 0x2110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marcellapantarotto[P]pseudoSO/resource.cpp
// Function: blockResource(int)
int blockResource(int resource)
{
	int blo = 0;
	switch(resource)
	{
		// sem_trywait() bloqueia um semáforo se ele já não estiver bloqueado
		// tem que ser positivo
		case SCANNER:
			if(sem_trywait(&scanner) == 0)
				blo = 1;
			break;
		case PRINTER:
			if(sem_trywait(&printer) == 0)
				blo = 1;
			break;
		case MODEM:
			if(sem_trywait(&modem) == 0)
				blo = 1;
			break;
		case SATA:
			if(sem_trywait(&sata) == 0)
				blo = 1;
			break;
		default:
			break;
	}
	return blo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x428e
movq -0x10(%rbp), %rax
leaq 0x5eb3(%rip), %rcx      # 0xa0d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xaf4b(%rip), %rdi      # 0xf178
callq 0x2050
cmpl $0x0, %eax
jne 0x423e
movl $0x1, -0x8(%rbp)
jmp 0x4290
leaq 0xaf51(%rip), %rdi      # 0xf198
callq 0x2050
cmpl $0x0, %eax
jne 0x4258
movl $0x1, -0x8(%rbp)
jmp 0x4290
leaq 0xaf57(%rip), %rdi      # 0xf1b8
callq 0x2050
cmpl $0x0, %eax
jne 0x4272
movl $0x1, -0x8(%rbp)
jmp 0x4290
leaq 0xaf5d(%rip), %rdi      # 0xf1d8
callq 0x2050
cmpl $0x0, %eax
jne 0x428c
movl $0x1, -0x8(%rbp)
jmp 0x4290
jmp 0x4290
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: marcellapantarotto[P]pseudoSO/resource.cpp
// Function: freeResource(int)
void freeResource(int resource)
{
	switch(resource)
	{
		//sem_post() libera o semáforo
		case PRINTER:
			sem_post(&printer);
			break;
		case SCANNER:
			sem_post(&scanner);
			break;
		case MODEM:
			sem_post(&modem);
			break;
		case SATA:
			sem_post(&sata);
			break;
		default:
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x4307
movq -0x10(%rbp), %rax
leaq 0x5e1a(%rip), %rcx      # 0xa0e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xaec2(%rip), %rdi      # 0xf198
callq 0x2260
jmp 0x4309
leaq 0xae94(%rip), %rdi      # 0xf178
callq 0x2260
jmp 0x4309
leaq 0xaec6(%rip), %rdi      # 0xf1b8
callq 0x2260
jmp 0x4309
leaq 0xaed8(%rip), %rdi      # 0xf1d8
callq 0x2260
jmp 0x4309
jmp 0x4309
addq $0x10, %rsp
popq %rbp
retq
nop
// File: marcellapantarotto[P]pseudoSO/scheduler.cpp
// Function: Scheduler::addEndQueue(Process)
void Scheduler::addEndQueue(Process p) {
	switch(p.getPriority()) {
		case REAL_TIME:
			realTIME.push(p);
			break;
		case USER_P1:
			userP1.push(p);
			break;
		case USER_P2:
			userP2.push(p);
			break;
		case USER_P3:
			userP3.push(p);
			break;

	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x3710
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x43c3
movq -0x10(%rbp), %rax
leaq 0x5d86(%rip), %rcx      # 0xa0f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x56d0
jmp 0x43c3
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x56d0
jmp 0x43c3
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x56d0
jmp 0x43c3
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
callq 0x56d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: marcellapantarotto[P]pseudoSO/scheduler.cpp
// Function: Scheduler::fillQueue()
void Scheduler::fillQueue() {
	int i = 0;
	Process p;

	while(i < (int)processes.size() && processes[i].getInitTime() < clock + 1) {
		p = processes[i];
		addEndQueue(p);
		i++;
	}

	processes.erase(processes.begin(),processes.begin()+i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x5700
movq -0x88(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x90(%rbp)
addq $0x8, %rdi
callq 0x5710
movl -0x90(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x89(%rbp)
jge 0x445a
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5730
movq %rax, %rdi
callq 0x37d0
movq -0x88(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x4469
jmp 0x44fc
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5730
movq -0x88(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x2c(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x24(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x1c(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x14(%rbp)
movq -0x2c(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x4330
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x43fa
movq -0x88(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
addq $0x8, %rdi
callq 0x57e0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5810
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x57e0
movq %rax, -0x78(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x5850
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x5810
movq -0x98(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x5750
movq %rax, -0x80(%rbp)
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: marcellapantarotto[P]pseudoSO/scheduler.cpp
// Function: Scheduler::executesProcess(Process&)
void Scheduler::executesProcess(Process& p) {
	switch(p.getPriority()){
		case REAL_TIME:
			clock += p.getExecutionTime();
			sleep(p.getExecutionTime()-QUANTUM);
			p.setExecutionTime(0);
			break;

		case USER_P1:
		case USER_P2:
		case USER_P3:
			p.gives();
			clock += QUANTUM;
			break;

		default:			// percorre até o final do processo
			int i = 0;
			while(!p.getBlockedResource()) {
				p.gives();
				i++;
			}
			clock += QUANTUM*i;
			sleep((QUANTUM*i - 1));
			p.setExecutionTime(p.getExecutionTime() - QUANTUM*i);
			break;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3710
movl %eax, %ecx
movl %ecx, -0x18(%rbp)
testl %eax, %eax
je 0x45b8
jmp 0x45ac
movl -0x18(%rbp), %eax
decl %eax
subl $0x3, %eax
jb 0x45ee
jmp 0x4604
movq -0x10(%rbp), %rdi
callq 0x3810
movl %eax, %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3810
movl %eax, %edi
subl $0x1, %edi
callq 0x20f0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3830
jmp 0x4676
movq -0x10(%rbp), %rdi
callq 0x3990
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4676
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3950
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4622
jmp 0x4636
movq -0x10(%rbp), %rdi
callq 0x3990
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x460b
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x0, %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %edi
shll $0x0, %edi
subl $0x1, %edi
callq 0x20f0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3810
movq -0x28(%rbp), %rdi
movl %eax, %esi
movl -0x14(%rbp), %eax
shll $0x0, %eax
subl %eax, %esi
callq 0x3830
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: marcellapantarotto[P]pseudoSO/scheduler.cpp
// Function: Scheduler::dispatcher(Process&)
void Scheduler::dispatcher(Process& p) {
	cout << "\n Dispatcher =>" << '\n';
	cout << p << endl;
	executesProcess(p);
	displayExecution(p);
	sleep(QUANTUM);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xa2f1(%rip), %rdi      # 0xefd0
leaq 0x54c6(%rip), %rsi      # 0xa1ac
callq 0x2170
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
movq -0x10(%rbp), %rsi
movq 0xa2cd(%rip), %rdi      # 0xefd0
callq 0x3500
movq %rax, %rdi
movq 0xa2ae(%rip), %rsi      # 0xefc0
callq 0x2190
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4580
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x4d90
movl $0x1, %edi
callq 0x20f0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marcellapantarotto[P]pseudoSO/scheduler.cpp
// Function: Scheduler::displayExecution(Process)
void Scheduler::displayExecution(Process p) {
	cout << "\n  Process " << p.getPID() << " => " << endl;
	cout << "\tPriority: " << p.getPriority() << endl;
	cout << "\tTime Since Arrival: " << clock - p.getInitTime() << endl;
	cout << "\tTime Left To Execute: " << p.getExecutionTime() << endl;
	cout << "\tHolds Any Resources: ";

	switch(p.getBlockedResource()) {
		case WITHOUT_RESOURCES:
			cout << "No";
			break;
		case PRINTER:
			cout << "Printer";
			break;
		case SCANNER:
			cout << "Scanner";
			break;
		case SATA:
			cout << "Sata";
			break;
		case MODEM:
			cout << "Modem";
			break;
	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0xa21d(%rip), %rdi      # 0xefd0
movq %rdi, -0x20(%rbp)
leaq 0x53fe(%rip), %rsi      # 0xa1bc
callq 0x2170
movq -0x18(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x36e0
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x2270
movq %rax, %rdi
leaq 0x53e3(%rip), %rsi      # 0xa1c8
callq 0x2170
movq %rax, %rdi
movq 0xa1cc(%rip), %rsi      # 0xefc0
movq %rsi, -0x28(%rbp)
callq 0x2190
movq -0x20(%rbp), %rdi
leaq 0x5247(%rip), %rsi      # 0xa04f
callq 0x2170
movq -0x18(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x3710
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x2270
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
leaq 0x5391(%rip), %rsi      # 0xa1cd
callq 0x2170
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
callq 0x37d0
movl -0x3c(%rbp), %esi
movq -0x38(%rbp), %rdi
subl %eax, %esi
callq 0x2270
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
leaq 0x5364(%rip), %rsi      # 0xa1e3
callq 0x2170
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x3810
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x2270
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
leaq 0x5348(%rip), %rsi      # 0xa1fb
callq 0x2170
movq -0x18(%rbp), %rdi
callq 0x3950
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x4, %eax
ja 0x4f47
movq -0x10(%rbp), %rax
leaq 0x5229(%rip), %rcx      # 0xa100
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xa0e9(%rip), %rdi      # 0xefd0
leaq 0x5324(%rip), %rsi      # 0xa212
callq 0x2170
jmp 0x4f47
movq 0xa0d4(%rip), %rdi      # 0xefd0
leaq 0x5312(%rip), %rsi      # 0xa215
callq 0x2170
jmp 0x4f47
movq 0xa0bf(%rip), %rdi      # 0xefd0
leaq 0x5305(%rip), %rsi      # 0xa21d
callq 0x2170
jmp 0x4f47
movq 0xa0aa(%rip), %rdi      # 0xefd0
leaq 0x52f8(%rip), %rsi      # 0xa225
callq 0x2170
jmp 0x4f47
movq 0xa095(%rip), %rdi      # 0xefd0
leaq 0x52e8(%rip), %rsi      # 0xa22a
callq 0x2170
movq 0xa082(%rip), %rdi      # 0xefd0
movq 0xa06b(%rip), %rsi      # 0xefc0
callq 0x2190
addq $0x60, %rsp
popq %rbp
retq
// File: bchu7796[P]p2p-file-sharing/client.cpp
// Function: main
int main(void){
    client client_instance;
    if(client_instance.execute()!= 0){
        perror("server execution fault");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x5(%rbp), %rdi
callq 0x5bc0
cmpl $0x0, %eax
je 0x36c9
leaq 0x9940(%rip), %rdi      # 0xd004
callq 0x3250
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bchu7796[P]p2p-file-sharing/peers.cpp
// Function: client::calculate_chunk_number(unsigned int)
int client::calculate_chunk_number(uint32_t file_length){
    int chunk_number = file_length / CHUNK_SIZE;
    //round up
    if((CHUNK_SIZE * chunk_number) < file_length){
        chunk_number += 1;
    }
    return chunk_number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0xa, %eax
cmpl -0xc(%rbp), %eax
jae 0x3708
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: bchu7796[P]p2p-file-sharing/peers.cpp
// Function: client::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>&, char)
void client::split(const std::string& s, std::vector<std::string>& parameters, const char delim = ' ') {
    parameters.clear();
    std::istringstream iss(s);
    std::string temp;

    while (std::getline(iss, temp, delim)) {
        parameters.emplace_back(std::move(temp));
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x60d0
movq -0x10(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
movl $0x8, %edx
callq 0x3460
leaq -0x1c0(%rbp), %rdi
callq 0x33c0
movsbl -0x19(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x34c0
movq %rax, -0x1d8(%rbp)
jmp 0x3f66
movq -0x1d8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3360
movb %al, -0x1d9(%rbp)
jmp 0x3f84
movb -0x1d9(%rbp), %al
testb $0x1, %al
jne 0x3f90
jmp 0x3fd0
movq -0x18(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x60f0
jmp 0x3fa2
jmp 0x3f46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x31d0
leaq -0x1a0(%rbp), %rdi
callq 0x3160
jmp 0x3ff1
leaq -0x1c0(%rbp), %rdi
callq 0x31d0
leaq -0x1a0(%rbp), %rdi
callq 0x3160
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x34a0
nopl (%rax)
// File: bchu7796[P]p2p-file-sharing/peers.cpp
// Function: client::write_log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<chunk, std::allocator<chunk>>)
int client::write_log(std::string file_name, std::vector<chunk> chunks){
    std::ofstream log;
    log.open((file_name + ".log").c_str());
    for(int i = 0; i < chunks.size(); i++){
        if(chunks[i].is_possessed == true){
            log<<chunks[i].index<<"\n";
        }
    }
    log.close();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rsi, -0x250(%rbp)
movq %rdx, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3470
movq -0x250(%rbp), %rsi
leaq 0x8ff7(%rip), %rdx      # 0xd086
leaq -0x238(%rbp), %rdi
callq 0x6170
jmp 0x409d
leaq -0x238(%rbp), %rdi
callq 0x3120
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x3040
jmp 0x40bf
leaq -0x238(%rbp), %rdi
callq 0x31d0
movl $0x0, -0x248(%rbp)
movq -0x258(%rbp), %rdi
movslq -0x248(%rbp), %rax
movq %rax, -0x260(%rbp)
callq 0x6000
movq %rax, %rcx
movq -0x260(%rbp), %rax
cmpq %rcx, %rax
jae 0x41ad
movq -0x258(%rbp), %rdi
movslq -0x248(%rbp), %rsi
callq 0x6020
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4197
movq -0x258(%rbp), %rdi
movslq -0x248(%rbp), %rsi
callq 0x6020
movl (%rax), %esi
leaq -0x218(%rbp), %rdi
callq 0x3390
movq %rax, -0x268(%rbp)
jmp 0x414c
movq -0x268(%rbp), %rdi
leaq 0x8f31(%rip), %rsi      # 0xd08b
callq 0x32d0
jmp 0x4161
jmp 0x4197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x41d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x31d0
jmp 0x41d2
jmp 0x4199
movl -0x248(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x248(%rbp)
jmp 0x40d5
leaq -0x218(%rbp), %rdi
callq 0x33d0
jmp 0x41bb
leaq -0x218(%rbp), %rdi
callq 0x3400
xorl %eax, %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x3400
movq -0x240(%rbp), %rdi
callq 0x34a0
nopw (%rax,%rax)
// File: bchu7796[P]p2p-file-sharing/peers.cpp
// Function: client::select_chunk(std::vector<chunk, std::allocator<chunk>>)
std::vector<int> client::select_chunk(std::vector<chunk> chunks){
    std::vector<int> min;
    int min_number = INT_MAX;
    int min_index = 0;
    bool flag = false;
    for(int i = 0; i<4; i++){
        for(int j=0; j<chunks.size(); j++){
            if((chunks[j].peers.size() < min_number) && (!chunks[j].is_possessed)){
                min_number = chunks[j].peers.size();
                min_index = j;
                flag = true;
            }
        }
        if(flag){
            min.push_back(min_index);
            chunks[min_index].is_possessed = true;
            min_number = INT_MAX;
            flag = false;
        }
    }
    return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x6290
movl $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
movl $0x0, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jge 0x4658
movl $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x6000
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x45fe
movq -0x58(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x6020
movq %rax, %rdi
addq $0x8, %rdi
callq 0x62b0
movslq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x45ee
movq -0x58(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x6020
testb $0x1, 0x4(%rax)
jne 0x45ee
movq -0x58(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x6020
movq %rax, %rdi
addq $0x8, %rdi
callq 0x62b0
movl %eax, -0x20(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
movb $0x1, -0x25(%rbp)
jmp 0x45f0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4576
testb $0x1, -0x25(%rbp)
je 0x4648
movq -0x50(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x62d0
jmp 0x4613
movq -0x58(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6020
movb $0x1, 0x4(%rax)
movl $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
movb $0x0, -0x25(%rbp)
jmp 0x4648
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6340
jmp 0x4675
jmp 0x464a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4565
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x466b
movq -0x50(%rbp), %rdi
callq 0x6340
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34a0
nop
// File: bchu7796[P]p2p-file-sharing/peers.cpp
// Function: client::user_interface()
void client::user_interface(){
    char buffer[1024];
    while(1){
        std::string command;
        std::cout<<">";
        std::cin.getline(buffer, 1024);
        command = buffer;
        parse_command(command);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x468(%rbp)
leaq -0x430(%rbp), %rdi
callq 0x33c0
movq 0xe5e3(%rip), %rdi      # 0x13fd0
leaq 0x76f6(%rip), %rsi      # 0xd0ea
callq 0x32d0
jmp 0x59fb
movq 0xe5de(%rip), %rdi      # 0x13fe0
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x30d0
jmp 0x5a15
leaq -0x430(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x33b0
jmp 0x5a2a
leaq -0x460(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x3130
jmp 0x5a3f
movq -0x468(%rbp), %rdi
leaq -0x460(%rbp), %rsi
callq 0x55e0
jmp 0x5a54
leaq -0x460(%rbp), %rdi
callq 0x31d0
leaq -0x430(%rbp), %rdi
callq 0x31d0
jmp 0x59da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x438(%rbp)
movl %eax, -0x43c(%rbp)
jmp 0x5aa3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x438(%rbp)
movl %eax, -0x43c(%rbp)
leaq -0x460(%rbp), %rdi
callq 0x31d0
leaq -0x430(%rbp), %rdi
callq 0x31d0
movq -0x438(%rbp), %rdi
callq 0x34a0
nopl (%rax,%rax)
// File: bchu7796[P]p2p-file-sharing/peers.cpp
// Function: client::handle_request(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void client::handle_request(int process_fd, std::string file_name, int chunk_index){
    char buffer[CHUNK_SIZE];
    std::ifstream upload_file;
    int chunk_size = CHUNK_SIZE;

    upload_file.open(file_name);
    upload_file.seekg(chunk_size * chunk_index, std::ios::beg);
    upload_file.read(buffer, sizeof(buffer));

    send(process_fd, &buffer, sizeof(buffer), 0);
    upload_file.close();
    close(process_fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x650, %rsp            # imm = 0x650
movq %rdx, -0x648(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0x628(%rbp), %rdi
movq %rdi, -0x650(%rbp)
callq 0x3330
movq -0x650(%rbp), %rdi
movq -0x648(%rbp), %rsi
movl $0x400, -0x62c(%rbp)    # imm = 0x400
movl $0x8, %edx
callq 0x3260
jmp 0x5b17
movl -0x62c(%rbp), %eax
movl -0x1c(%rbp), %ecx
imull %ecx, %eax
movslq %eax, %rsi
leaq -0x628(%rbp), %rdi
xorl %edx, %edx
callq 0x33a0
jmp 0x5b36
leaq -0x628(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3370
jmp 0x5b50
movl -0xc(%rbp), %edi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x3180
jmp 0x5b68
leaq -0x628(%rbp), %rdi
callq 0x3070
jmp 0x5b76
movl -0xc(%rbp), %edi
callq 0x3510
jmp 0x5b80
leaq -0x628(%rbp), %rdi
callq 0x3090
addq $0x650, %rsp            # imm = 0x650
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x638(%rbp)
movl %eax, -0x63c(%rbp)
leaq -0x628(%rbp), %rdi
callq 0x3090
movq -0x638(%rbp), %rdi
callq 0x34a0
nop
// File: adamnovak[P]rlcsa/rlcsa_test.cpp
// Function: totalSize(std::vector<Pattern, std::allocator<Pattern>> const&)
usint
totalSize(const std::vector<Pattern>& patterns)
{
  double total = 0;
  for(std::vector<Pattern>::const_iterator iter = patterns.begin(); iter != patterns.end(); ++iter)
  {
    total += iter->pattern.length();
  }
  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb000
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xafc0
testb $0x1, %al
jne 0x9af1
jmp 0x9b3e
leaq -0x18(%rbp), %rdi
callq 0xb030
movq %rax, %rdi
callq 0x4500
movq %rax, %xmm0
movaps 0x32512(%rip), %xmm1    # 0x3c020
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x32516(%rip), %xmm1    # 0x3c030
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb050
jmp 0x9ad1
cvttsd2si -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa_test.cpp
// Function: totalOcc(std::vector<Pattern, std::allocator<Pattern>> const&)
usint
totalOcc(const std::vector<Pattern>& patterns)
{
  double total = 0;
  for(std::vector<Pattern>::const_iterator iter = patterns.begin(); iter != patterns.end(); ++iter)
  {
    total += iter->occ();
  }
  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb000
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xafc0
testb $0x1, %al
jne 0x9b91
jmp 0x9bbe
leaq -0x18(%rbp), %rdi
callq 0xb030
movq %rax, %rdi
callq 0xa900
movl %eax, %eax
cvtsi2sd %rax, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb050
jmp 0x9b71
cvttsd2si -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa_test.cpp
// Function: totalSteps(std::vector<Pattern, std::allocator<Pattern>> const&)
usint
totalSteps(const std::vector<Pattern>& patterns)
{
  double total = 0;
  for(std::vector<Pattern>::const_iterator iter = patterns.begin(); iter != patterns.end(); ++iter)
  {
    total += iter->steps;
  }
  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb000
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xafc0
testb $0x1, %al
jne 0x9c11
jmp 0x9c37
leaq -0x18(%rbp), %rdi
callq 0xb030
movl 0x2c(%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb050
jmp 0x9bf1
cvttsd2si -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa_test.cpp
// Function: totalFound(std::vector<Pattern, std::allocator<Pattern>> const&)
usint
totalFound(const std::vector<Pattern>& patterns)
{
  double total = 0;
  for(std::vector<Pattern>::const_iterator iter = patterns.begin(); iter != patterns.end(); ++iter)
  {
    if(iter->found()) { total++; }
  }
  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb000
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xafc0
testb $0x1, %al
jne 0x9c91
jmp 0x9cc7
leaq -0x18(%rbp), %rdi
callq 0xb030
movq %rax, %rdi
callq 0xa8d0
testb $0x1, %al
jne 0x9ca8
jmp 0x9cba
movsd 0x32360(%rip), %xmm0    # 0x3c010
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x9cbc
leaq -0x18(%rbp), %rdi
callq 0xb050
jmp 0x9c71
cvttsd2si -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa_test.cpp
// Function: totalDocc(std::vector<Pattern, std::allocator<Pattern>> const&)
usint
totalDocc(const std::vector<Pattern>& patterns)
{
  double total = 0;
  for(std::vector<Pattern>::const_iterator iter = patterns.begin(); iter != patterns.end(); ++iter)
  {
    total += iter->docc;
  }
  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb000
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xafc0
testb $0x1, %al
jne 0x9d21
jmp 0x9d47
leaq -0x18(%rbp), %rdi
callq 0xb030
movl 0x30(%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb050
jmp 0x9d01
cvttsd2si -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa_test.cpp
// Function: printPatterns(std::vector<Pattern, std::allocator<Pattern>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void
printPatterns(std::vector<Pattern>& patterns, const std::string& file_name, bool only_found)
{
  if(patterns.empty()) { return; }

  std::ofstream output(file_name.c_str(), std::ios_base::binary);
  if(!output)
  {
    std::cerr << "Error: Cannot open file " << file_name << " for writing patterns!" << std::endl;
    return;
  }

  for(std::vector<Pattern>::iterator iter = patterns.begin(); iter != patterns.end(); ++iter)
  {
    if(!only_found || iter->found()) { output << iter->pattern << std::endl; }
  }
  output.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0xac40
testb $0x1, %al
jne 0x9d89
jmp 0x9d8e
jmp 0x9f4b
movq -0x10(%rbp), %rdi
callq 0x4150
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x4, %edx
callq 0x43a0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x4180
movb %al, -0x239(%rbp)
jmp 0x9dcb
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x9dda
jmp 0x9e72
movq 0x4720f(%rip), %rdi     # 0x50ff0
leaq 0x329a6(%rip), %rsi     # 0x3c78e
callq 0x4300
movq %rax, -0x248(%rbp)
jmp 0x9df6
movq -0x248(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42b0
movq %rax, -0x250(%rbp)
jmp 0x9e0f
movq -0x250(%rbp), %rdi
leaq 0x3298a(%rip), %rsi     # 0x3c7a7
callq 0x4300
movq %rax, -0x258(%rbp)
jmp 0x9e2b
movq -0x258(%rbp), %rdi
movq 0x47177(%rip), %rsi     # 0x50fb0
callq 0x4370
jmp 0x9e40
movl $0x1, -0x228(%rbp)
jmp 0x9f3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x44e0
jmp 0x9f54
movq -0x8(%rbp), %rdi
callq 0xa540
movq %rax, -0x230(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa5b0
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0xa570
testb $0x1, %al
jne 0x9eab
jmp 0x9f27
testb $0x1, -0x11(%rbp)
je 0x9ed9
leaq -0x230(%rbp), %rdi
callq 0xa5e0
movq %rax, %rdi
callq 0xa8d0
movb %al, -0x259(%rbp)
jmp 0x9ecd
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x9ed9
jmp 0x9f14
leaq -0x230(%rbp), %rdi
callq 0xa5e0
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
callq 0x42b0
movq %rax, -0x268(%rbp)
jmp 0x9efd
movq -0x268(%rbp), %rdi
movq 0x470a5(%rip), %rsi     # 0x50fb0
callq 0x4370
jmp 0x9f12
jmp 0x9f14
jmp 0x9f16
leaq -0x230(%rbp), %rdi
callq 0xa600
jmp 0x9e82
leaq -0x218(%rbp), %rdi
callq 0x44c0
jmp 0x9f35
movl $0x0, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x44e0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x45c0
// File: adamnovak[P]rlcsa/rlcsa_test.cpp
// Function: Pattern::Pattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, unsigned int)
Pattern(const std::string& _pattern, bool ignore_tab, usint ignore) :
    pattern(_pattern), weight(1), range(EMPTY_PAIR), steps(0), docc(0)
  {
    if(ignore_tab)
    {
      usint pos = this->pattern.find('\t');
      this->weight = atoi(this->pattern.substr(0, pos).c_str());
      this->pattern = this->pattern.substr(pos + 1);
    }
    else if(ignore > 0)
    {
      this->weight = atoi(this->pattern.substr(0, ignore).c_str());
      this->pattern = this->pattern.substr(ignore);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4160
movq -0xb8(%rbp), %rax
movl $0x1, 0x20(%rax)
movq 0x3133a(%rip), %rcx     # 0x3c0f0
movq %rcx, 0x24(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x30(%rax)
testb $0x1, -0x11(%rbp)
je 0xae9a
movq -0xb8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xc0(%rbp)
movl $0x9, %esi
callq 0x4460
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq -0x40(%rbp), %rdi
callq 0x4350
jmp 0xae0f
leaq -0x40(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x4150
movq %rax, %rdi
callq 0x4540
movq -0xc8(%rbp), %rdi
movl %eax, %ecx
movq -0xb8(%rbp), %rax
movl %ecx, 0x20(%rax)
callq 0x4688
movq -0xb8(%rbp), %rsi
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
movq $-0x1, %rcx
callq 0x4350
jmp 0xae5f
movq -0xb8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4400
leaq -0x70(%rbp), %rdi
callq 0x4688
jmp 0xaf37
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x4688
jmp 0xaf40
cmpl $0x0, -0x18(%rbp)
jbe 0xaf35
movq -0xb8(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
leaq -0x90(%rbp), %rdi
callq 0x4350
jmp 0xaec2
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4150
movq %rax, %rdi
callq 0x4540
movq -0xd0(%rbp), %rdi
movl %eax, %ecx
movq -0xb8(%rbp), %rax
movl %ecx, 0x20(%rax)
callq 0x4688
movq -0xb8(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
leaq -0xb0(%rbp), %rdi
movq $-0x1, %rcx
callq 0x4350
jmp 0xaf16
movq -0xb8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x4400
leaq -0xb0(%rbp), %rdi
callq 0x4688
jmp 0xaf37
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x45c0
nopl (%rax)
// File: adamnovak[P]rlcsa/adaptive_samples.cpp
// Function: CSA::AdaptiveSamples::addSample(std::pair<unsigned int, unsigned int>)
void
AdaptiveSamples::addSample(sample_type sample)
{
  key_type i = this->hash(sample.first);
  if(this->samples[i].first >= this->index.getSize()) { this->items++; }
  else if(this->use_candidates) { this->addCandidate(this->samples[i]); }
  this->samples[i] = sample;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x8(%rbp), %esi
callq 0x251f0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x8(%rax), %rcx
movl -0x14(%rbp), %edx
movl (%rcx,%rdx,8), %ecx
movl %ecx, -0x20(%rbp)
movq (%rax), %rdi
callq 0xa410
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jb 0x24b06
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x24b2e
movq -0x28(%rbp), %rax
testb $0x1, 0x34(%rax)
je 0x24b2c
movq -0x28(%rbp), %rdi
movq 0x8(%rdi), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1c(%rbp)
movq -0x1c(%rbp), %rsi
callq 0x255b0
jmp 0x24b2e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x8(%rbp), %rsi
callq 0xcad0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/adaptive_samples.cpp
// Function: CSA::AdaptiveSamples::~AdaptiveSamples()
AdaptiveSamples::~AdaptiveSamples()
{
  delete[] samples; samples = 0;
  delete[] candidate_samples; candidate_samples = 0;
  delete   regular_samples; regular_samples = 0;
  delete[] window; window = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x24b7b
movq -0x10(%rbp), %rdi
callq 0x4450
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x24b9e
movq -0x20(%rbp), %rdi
callq 0x4450
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x24bcf
movq -0x28(%rbp), %rdi
callq 0x1c5c0
movq -0x28(%rbp), %rdi
movl $0x30, %esi
callq 0x4330
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x24bf2
movq -0x30(%rbp), %rdi
callq 0x4450
movq -0x18(%rbp), %rax
movq $0x0, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/adaptive_samples.cpp
// Function: CSA::AdaptiveSamples::reportSize() const
usint
AdaptiveSamples::reportSize() const
{
  usint temp = sizeof(*this) + this->size * sizeof(sample_type);
  if(this->use_candidates) { temp += this->size * sizeof(sample_type); }
  if(this->half_greedy) { temp += this->regular_samples->reportSize(); }
  if(this->promote_probability > 0.0) { temp += this->window_size * sizeof(key_type); }
  return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x10(%rax), %ecx
shlq $0x3, %rcx
addq $0x60, %rcx
movl %ecx, -0xc(%rbp)
testb $0x1, 0x34(%rax)
je 0x24d4e
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
shlq $0x3, %rcx
movl -0xc(%rbp), %eax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x35(%rax)
je 0x24d6b
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1ca90
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x24d93
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, %ecx
shlq $0x2, %rcx
movl -0xc(%rbp), %eax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/adaptive_samples.cpp
// Function: CSA::AdaptiveSamples::report() const
void
AdaptiveSamples::report() const
{
  std::cout << "Adaptive samples:" << std::endl;
  std::cout << "Size:     " << this->reportSize() / (double)MEGABYTE << " MB" << std::endl;
  std::cout << "Load:     " << this->getLoad() << " (" << this->getPrimaryLoad() << " / " << this->getCandidateLoad() << ")" << std::endl;

  std::cout << "Options: ";
  if(this->use_candidates) { std::cout << " candidates"; }
  if(this->half_greedy) { std::cout << " half-greedy"; }
  if(this->promote_probability > 0.0)
  {
    std::cout << " random(" << this->promote_probability << ", " << this->window_size << ")";
  }
  std::cout << std::endl;

  std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x2c215(%rip), %rdi     # 0x50fd0
movq %rdi, -0x38(%rbp)
leaq 0x1801c(%rip), %rsi     # 0x3cde2
callq 0x4300
movq %rax, %rdi
movq 0x2c1db(%rip), %rsi     # 0x50fb0
callq 0x4370
movq -0x38(%rbp), %rdi
leaq 0x1800f(%rip), %rsi     # 0x3cdf4
callq 0x4300
movq -0x10(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x24d10
movq -0x30(%rbp), %rdi
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd 0x17a3e(%rip), %xmm1    # 0x3c848
divsd %xmm1, %xmm0
callq 0x4600
movq %rax, %rdi
leaq 0x174ef(%rip), %rsi     # 0x3c30c
callq 0x4300
movq %rax, %rdi
movq 0x2c184(%rip), %rsi     # 0x50fb0
callq 0x4370
movq 0x2c198(%rip), %rdi     # 0x50fd0
leaq 0x17fc0(%rip), %rsi     # 0x3cdff
callq 0x4300
movq -0x10(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x24c50
movq -0x28(%rbp), %rdi
callq 0x4600
movq %rax, %rdi
leaq 0x18054(%rip), %rsi     # 0x3ceb8
callq 0x4300
movq -0x10(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x24cb0
movq -0x20(%rbp), %rdi
callq 0x4600
movq %rax, %rdi
leaq 0x17c6f(%rip), %rsi     # 0x3caf8
callq 0x4300
movq -0x10(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x24ce0
movq -0x18(%rbp), %rdi
callq 0x4600
movq %rax, %rdi
leaq 0x173a0(%rip), %rsi     # 0x3c24e
callq 0x4300
movq %rax, %rdi
movq 0x2c0f3(%rip), %rsi     # 0x50fb0
callq 0x4370
movq 0x2c107(%rip), %rdi     # 0x50fd0
leaq 0x17f3a(%rip), %rsi     # 0x3ce0a
callq 0x4300
movq -0x10(%rbp), %rax
testb $0x1, 0x34(%rax)
je 0x24ef2
movq 0x2c0ea(%rip), %rdi     # 0x50fd0
leaq 0x17f27(%rip), %rsi     # 0x3ce14
callq 0x4300
movq -0x10(%rbp), %rax
testb $0x1, 0x35(%rax)
je 0x24f0f
movq 0x2c0cd(%rip), %rdi     # 0x50fd0
leaq 0x17f16(%rip), %rsi     # 0x3ce20
callq 0x4300
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x24f72
movq 0x2c0a8(%rip), %rdi     # 0x50fd0
leaq 0x17efe(%rip), %rsi     # 0x3ce2d
callq 0x4300
movq %rax, %rdi
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
callq 0x4600
movq %rax, %rdi
leaq 0x1746a(%rip), %rsi     # 0x3c3b9
callq 0x4300
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x4480
movq %rax, %rdi
leaq 0x172e1(%rip), %rsi     # 0x3c24e
callq 0x4300
movq 0x2c057(%rip), %rdi     # 0x50fd0
movq 0x2c030(%rip), %rsi     # 0x50fb0
callq 0x4370
movq 0x2c044(%rip), %rdi     # 0x50fd0
movq 0x2c01d(%rip), %rsi     # 0x50fb0
callq 0x4370
addq $0x40, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/adaptive_samples.cpp
// Function: CSA::AdaptiveSamples::hash(unsigned int)
AdaptiveSamples::key_type
AdaptiveSamples::hash(key_type key)
{
  key = ~key + (key << 15);
  key = key ^ (key >> 12);
  key = key + (key << 2);
  key = key ^ (key >> 4);
  key = key * 2057;
  key = key ^ (key >> 16);
  return key % this->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %eax
xorl $-0x1, %eax
movl -0xc(%rbp), %edx
shll $0xf, %edx
addl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %edx
shrl $0xc, %edx
xorl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %edx
shll $0x2, %edx
addl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %edx
shrl $0x4, %edx
xorl %edx, %eax
movl %eax, -0xc(%rbp)
imull $0x809, -0xc(%rbp), %eax # imm = 0x809
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %edx
shrl $0x10, %edx
xorl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
xorl %edx, %edx
divl 0x10(%rcx)
movl %edx, %eax
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/adaptive_samples.cpp
// Function: CSA::AdaptiveSamples::secondaryHash(unsigned int)
AdaptiveSamples::key_type
AdaptiveSamples::secondaryHash(key_type key)
{
  key = (key + 0x7ed55d16) + (key << 12);
  key = (key ^ 0xc761c23c) ^ (key >> 19);
  key = (key + 0x165667b1) + (key << 5);
  key = (key + 0xd3a2646c) ^ (key << 9);
  key = (key + 0xfd7046c5) + (key << 3);
  key = (key ^ 0xb55a4f09) ^ (key >> 16);
  return key % this->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %eax
addl $0x7ed55d16, %eax       # imm = 0x7ED55D16
movl -0xc(%rbp), %edx
shll $0xc, %edx
addl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
xorl $0xc761c23c, %eax       # imm = 0xC761C23C
movl -0xc(%rbp), %edx
shrl $0x13, %edx
xorl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x165667b1, %eax       # imm = 0x165667B1
movl -0xc(%rbp), %edx
shll $0x5, %edx
addl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0xd3a2646c, %eax       # imm = 0xD3A2646C
movl -0xc(%rbp), %edx
shll $0x9, %edx
xorl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0xfd7046c5, %eax       # imm = 0xFD7046C5
movl -0xc(%rbp), %edx
shll $0x3, %edx
addl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
xorl $0xb55a4f09, %eax       # imm = 0xB55A4F09
movl -0xc(%rbp), %edx
shrl $0x10, %edx
xorl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
xorl %edx, %edx
divl 0x10(%rcx)
movl %edx, %eax
popq %rbp
retq
nopl (%rax)