LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: main
int main(int argc, char* argv[]) {
  if (argc != 2) {
    std::cout << "usage: ./headerFileAnalysys path/to/project/" << std::endl;
    exit(0);
  }

  std::string base_dir {argv[1]};

  WalkMan walkMan(base_dir);
  walkMan.start();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x8b48
movq 0x5b492(%rip), %rdi     # 0x63fb8
leaq 0x3aaa7(%rip), %rsi     # 0x435d4
callq 0x6470
movq %rax, %rdi
movq 0x5b454(%rip), %rsi     # 0x63f90
callq 0x64e0
xorl %edi, %edi
callq 0x65c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x6790
movq -0x1a8(%rbp), %rsi
movq -0x1a0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x8c40
jmp 0x8b80
leaq -0x31(%rbp), %rdi
callq 0x6500
leaq -0x198(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7b30
jmp 0x8b9b
leaq -0x198(%rbp), %rdi
callq 0x89f0
jmp 0x8ba9
movl $0x0, -0x4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x7bd0
leaq -0x30(%rbp), %rdi
callq 0x6310
movl -0x4(%rbp), %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x6500
jmp 0x8c17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8c0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x7bd0
leaq -0x30(%rbp), %rdi
callq 0x6310
movq -0x40(%rbp), %rdi
callq 0x6780
// File: lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::RaidSystem(FileHandler*)
RaidSystem::RaidSystem(FileHandler *fileHandler)
{
	handle = fileHandler;
	raidSystem = Raid_unknown;
	stripeSize = -1;
	lostImages = -1;
	raidSystem = Raid_unknown;
	srand(time(NULL));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x10, %rdi
callq 0x9be0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl $0x5, 0x8(%rax)
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movl $0x5, 0x8(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x63d0
movl %eax, %edi
callq 0x6410
addq $0x18, %rsp
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::setRaid(int)
void RaidSystem::setRaid(int i)
{
	if (i == 0)
		raidSystem = Raid0;
	if (i == 1)
		raidSystem = Raid1;
	if (i == 5)
		raidSystem = Raid5_user;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x0, -0xc(%rsp)
jne 0x6be6
movq -0x18(%rsp), %rax
movl $0x0, 0x8(%rax)
cmpl $0x1, -0xc(%rsp)
jne 0x6bf9
movq -0x18(%rsp), %rax
movl $0x1, 0x8(%rax)
cmpl $0x5, -0xc(%rsp)
jne 0x6c0c
movq -0x18(%rsp), %rax
movl $0x2, 0x8(%rax)
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::calculateStripeSize()
bool RaidSystem::calculateStripeSize()
{
	int ret = handle->estimateStripeSize();
	if (ret == -1)
		return false;
	this->stripeSize = ret;
	return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
callq 0xd120
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x89dd
movb $0x0, 0x27(%rsp)
jmp 0x89ee
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::checkForNull(char*, unsigned long)
bool RaidSystem::checkForNull(char *in, size_t size)
{
	for (size_t i = 0; i < size; ++i)
	{
		if (in[i] > 0)
			return false;
	}
	return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x9b20
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jle 0x9b0e
movb $0x0, -0x1(%rsp)
jmp 0x9b25
jmp 0x9b10
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x9ae8
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::checkForEqual(char*, char*, unsigned long)
bool RaidSystem::checkForEqual(char *buf, char *in, size_t size)
{
	unsigned int count = 0;
	for (size_t i = 0; i < size; ++i)
	{
		if (in[i] != buf[i])
			++count;
	}
	//A few errors are tolerated
	if (count > (size/1000))
		return false;

	return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0x9b9e
movq -0x20(%rsp), %rax
movq -0x38(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movq -0x38(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x9b8c
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x9b8e
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x9b55
movl -0x2c(%rsp), %eax
movq %rax, -0x40(%rsp)
movq -0x28(%rsp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x40(%rsp), %rax
cmpq %rcx, %rax
jbe 0x9bca
movb $0x0, -0x1(%rsp)
jmp 0x9bcf
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileHandler.cpp
// Function: FileHandler::getFileReader(unsigned long)
FileReader * FileHandler::getFileReader(size_t num)
{
	if (num >= inFiles.size())
	{
		std::cerr << "ERROR in FileHandler::getFileReader - num smaller than available Images" << std::endl;
		return NULL;
	}
	return inFiles.at(num);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
callq 0x9d50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0xcd04
movq 0x47312(%rip), %rdi     # 0x53ff0
leaq 0x2e62f(%rip), %rsi     # 0x3b314
callq 0x6420
movq %rax, %rdi
movq 0x4727c(%rip), %rsi     # 0x53f70
callq 0x6470
movq $0x0, 0x20(%rsp)
jmp 0xcd1e
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x10(%rsp), %rsi
callq 0x9d70
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileHandler.cpp
// Function: FileHandler::addImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileHandler::addImage(std::string path)
{
	if (inFiles.size()==0)
	{
		maxBufferSize = (BUFLENGTH/1+1)/2*2;
		maxBufferSize = maxBufferSize/BLOCKSIZE;
		maxBufferSize = maxBufferSize*BLOCKSIZE;
		maxBufferSize = std::min(maxBufferSize,256*1024*1024);
		FileReader *a = new FileReader(path,maxBufferSize);
		inFiles.push_back(a);
	}
	else
	{
		FileReader *a = new FileReader(path,maxBufferSize);
		inFiles.push_back(a);
	}
}

// Assembly:
subq $0xa8, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x40, %rdi
callq 0x9d50
cmpq $0x0, %rax
jne 0xce8c
movl $0x40000000, 0x47702(%rip) # imm = 0x40000000
leaq 0x476fb(%rip), %rdi     # 0x54488
movl 0x476f5(%rip), %eax     # 0x54488
movl %eax, %ecx
addl $0x1ff, %ecx            # imm = 0x1FF
testl %eax, %eax
cmovsl %ecx, %eax
sarl $0x9, %eax
movl %eax, 0x476df(%rip)     # 0x54488
movl 0x476d9(%rip), %eax     # 0x54488
shll $0x9, %eax
movl %eax, 0x476d0(%rip)     # 0x54488
movl $0x10000000, 0x94(%rsp) # imm = 0x10000000
leaq 0x94(%rsp), %rsi
callq 0x19140
movl (%rax), %eax
movl %eax, 0x476b0(%rip)     # 0x54488
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x6430
movq 0x18(%rsp), %rsi
movq %rax, 0x10(%rsp)
movb $0x1, 0x5b(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x6190
jmp 0xcdfd
movq 0x10(%rsp), %rdi
movslq 0x4767f(%rip), %rdx     # 0x54488
leaq 0x68(%rsp), %rsi
callq 0x2fbb0
jmp 0xce15
movb $0x0, 0x5b(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x6260
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x88(%rsp)
addq $0x40, %rdi
leaq 0x88(%rsp), %rsi
callq 0x19070
jmp 0xcf34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xce74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x6260
testb $0x1, 0x5b(%rsp)
jne 0xce7d
jmp 0xce87
movq 0x10(%rsp), %rdi
callq 0x63f0
jmp 0xcf3c
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x6430
movq 0x18(%rsp), %rsi
movq %rax, 0x8(%rsp)
movb $0x1, 0x2f(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6190
jmp 0xceb1
movq 0x8(%rsp), %rdi
movslq 0x475cb(%rip), %rdx     # 0x54488
leaq 0x30(%rsp), %rsi
callq 0x2fbb0
jmp 0xcec9
movb $0x0, 0x2f(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6260
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x50(%rsp)
addq $0x40, %rdi
leaq 0x50(%rsp), %rsi
callq 0x19070
jmp 0xcf34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xcf1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6260
testb $0x1, 0x2f(%rsp)
jne 0xcf28
jmp 0xcf32
movq 0x8(%rsp), %rdi
callq 0x63f0
jmp 0xcf3c
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileHandler.cpp
// Function: FileHandler::findGoodBlock()
bool FileHandler::findGoodBlock()
{
	int64_t sample=inFiles.at(0)->findFirstNonemptyBlock();
	if (sample == -1)
	{
		std::cout << "Couldn't load any good blocks anymore." << std::endl;
		return false;
	}
	//Set offset on the other images
	for (size_t i = 0; i < inFiles.size(); ++i)
	{
		inFiles.at(i)->setOffset(sample);
	}
	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9d70
movq (%rax), %rdi
callq 0x30180
movq %rax, 0x20(%rsp)
cmpq $-0x1, 0x20(%rsp)
jne 0xcfae
movq 0x47024(%rip), %rdi     # 0x53fb0
leaq 0x2e3c9(%rip), %rsi     # 0x3b35c
callq 0x6420
movq %rax, %rdi
movq 0x46fce(%rip), %rsi     # 0x53f70
callq 0x6470
movb $0x0, 0x37(%rsp)
jmp 0xd011
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
callq 0x9d50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xd00c
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
movq 0x18(%rsp), %rsi
callq 0x9d70
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x2fcf0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xcfb7
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/fileHandler.cpp
// Function: FileHandler::reloadBuffers()
bool FileHandler::reloadBuffers()
{
	for (unsigned int i = 0; i < inFiles.size(); ++i)
	{
		if (inFiles.at(i)->reloadBuffer()==false)
			return false;
	}
	return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movq %rax, (%rsp)
addq $0x40, %rdi
callq 0x9d50
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xd099
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9d70
movq (%rax), %rdi
callq 0x2fe00
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd08a
movb $0x0, 0x27(%rsp)
jmp 0xd09e
jmp 0xd08c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xd03b
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::setOffset(unsigned long)
void FileReader::setOffset(size_t off)
{
	offset = off - getGlobalAdress();
	while (static_cast<size_t>(offset)+blockSize > getNumberOfElements())
	{
		reloadBuffer();
		offset = off - getGlobalAdress();
	}
	this->readSize = std::min(blockSize, getNumberOfElements()-offset);
	block = &getBuffer()[offset];
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x312f0
movq 0x20(%rsp), %rcx
movq %rax, %rdx
movq 0x28(%rsp), %rax
subq %rdx, %rcx
movq %rcx, 0x2a8(%rax)
movq 0x28(%rsp), %rdi
movq 0x2a8(%rdi), %rax
addq 0x2b0(%rdi), %rax
movq %rax, 0x18(%rsp)
callq 0x31240
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2fd8f
movq 0x28(%rsp), %rdi
callq 0x2fe00
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x312f0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x28(%rsp), %rax
subq %rdx, %rcx
movq %rcx, 0x2a8(%rax)
jmp 0x2fd2e
movq 0x28(%rsp), %rdi
movq %rdi, %rax
addq $0x2b0, %rax            # imm = 0x2B0
movq %rax, 0x8(%rsp)
callq 0x31240
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rcx
subq 0x2a8(%rcx), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0xbe00
movq 0x28(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x2a0(%rdi)
callq 0x31280
movq %rax, %rcx
movq 0x28(%rsp), %rax
addq 0x2a8(%rax), %rcx
movq %rcx, 0x298(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::reloadBuffer()
bool FileReader::reloadBuffer()
{
	bool ret = Buffered_FileReader::reloadBuffer();
	offset = 0;
	block = Buffered_FileReader::getBuffer();
	readSize = std::min(blockSize, Buffered_FileReader::getNumberOfElements()-blockSize);
	return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x31170
movq 0x8(%rsp), %rdi
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq $0x0, 0x2a8(%rdi)
callq 0x31280
movq 0x8(%rsp), %rdi
movq %rax, 0x298(%rdi)
movq %rdi, %rax
addq $0x2b0, %rax            # imm = 0x2B0
movq %rax, (%rsp)
callq 0x31240
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
subq 0x2b0(%rcx), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0xbe00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x2a0(%rax)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::calcEntropyOfCurrentBlock()
float FileReader::calcEntropyOfCurrentBlock()
{
	float ret = 0.0f;
	unsigned int possibleVals[256]={};
	for (unsigned int i = 0; i < readSize; ++i)
	{
		possibleVals[(unsigned char)block[i]] += 1;
	}
	float tmp;
	if (possibleVals[0] == readSize)
		return 0.0f;
	for (unsigned int i = 0; i < 256; ++i)
	{
		tmp = (float)possibleVals[i]/(float)readSize;
		if (tmp>0)
			ret += -tmp * std::log2(tmp);
	}
	return ret;
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rdi, 0x438(%rsp)
movq 0x438(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x434(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x6200
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpq 0x2a0(%rcx), %rax
jae 0x2ffbf
movq 0x18(%rsp), %rax
movq 0x298(%rax), %rax
movl 0x2c(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl 0x30(%rsp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rsp,%rax,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2ff81
movq 0x18(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpq 0x2a0(%rcx), %rax
jne 0x2ffe2
xorps %xmm0, %xmm0
movss %xmm0, 0x444(%rsp)
jmp 0x300df
movl $0x0, 0x24(%rsp)
cmpl $0x100, 0x24(%rsp)      # imm = 0x100
jae 0x300cd
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movl 0x30(%rsp,%rcx,4), %ecx
cvtsi2ss %rcx, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x2a0(%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x10(%rsp)
testq %rax, %rax
movss %xmm0, 0x14(%rsp)
js 0x30050
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0xc(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x28(%rsp)
movss 0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x300bb
movss 0x28(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x28(%rsp), %xmm0
callq 0x308c0
movaps %xmm0, %xmm2
movss 0x8(%rsp), %xmm0
movss 0x434(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x434(%rsp)
jmp 0x300bd
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2ffea
movss 0x434(%rsp), %xmm0
movss %xmm0, 0x444(%rsp)
movss 0x444(%rsp), %xmm0
addq $0x448, %rsp            # imm = 0x448
retq
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::emptyBlock()
bool FileReader::emptyBlock()
{
	char *tmp = getBuffer();
	for (size_t i = 0; i < getNumberOfElements(); ++i)
		if (tmp[i] > 0)
			return false;
	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x31280
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x31240
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x30163
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jle 0x30151
movb $0x0, 0x37(%rsp)
jmp 0x30168
jmp 0x30153
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x30116
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::findFirstNonemptyBlock()
int64_t FileReader::findFirstNonemptyBlock()
{
	while (newBlock()==true)
	{
		for (size_t j = 0; j < readSize; ++j)
		{
			if (block[j] > 0)
			{
				return (int64_t)getCurrentAdress();
			}
		}
	}
	return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x30220
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x30202
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq 0x2a0(%rcx), %rax
jae 0x30200
movq 0x8(%rsp), %rax
movq 0x298(%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jle 0x301ee
movq 0x8(%rsp), %rdi
callq 0x30320
movq %rax, 0x20(%rsp)
jmp 0x3020b
jmp 0x301f0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x301b0
jmp 0x30193
movq $-0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::newBlock()
bool FileReader::newBlock()
{
	offset += readSize;
	readSize = std::min(getNumberOfElements(), std::min(blockSize, getNumberOfElements()-offset));
	if (readSize == 0)
	{
		bool ret = reloadBuffer();
		block = getBuffer();
		return ret;
	}
	block = &getBuffer()[offset];
	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x2a0(%rdi), %rax
addq 0x2a8(%rdi), %rax
movq %rax, 0x2a8(%rdi)
callq 0x31240
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdi, %rax
addq $0x2b0, %rax            # imm = 0x2B0
movq %rax, (%rsp)
callq 0x31240
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
subq 0x2a8(%rcx), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xbe00
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0xbe00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x2a0(%rax)
cmpq $0x0, 0x2a0(%rax)
jne 0x302e6
movq 0x8(%rsp), %rdi
callq 0x2fe00
movq 0x8(%rsp), %rdi
andb $0x1, %al
movb %al, 0x17(%rsp)
callq 0x31280
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x298(%rax)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x3030b
movq 0x8(%rsp), %rdi
callq 0x31280
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq 0x2a8(%rax), %rcx
movq %rcx, 0x298(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::findFirstEmptyBlock()
int64_t FileReader::findFirstEmptyBlock()
{
	while (newBlock()==true)
	{
		bool zero = true;
		for (size_t j = 0; j < readSize; ++j)
		{
			if (block[j] > 0)
			{
				zero = false;
				break;
			}
		}
		if (zero == true)
			return (int64_t)getCurrentAdress();
	}
	return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x30220
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x303ea
movb $0x1, 0x17(%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq 0x2a0(%rcx), %rax
jae 0x303c7
movq (%rsp), %rax
movq 0x298(%rax), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jle 0x303b5
movb $0x0, 0x17(%rsp)
jmp 0x303c7
jmp 0x303b7
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x30383
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x303e5
movq (%rsp), %rdi
callq 0x30320
movq %rax, 0x20(%rsp)
jmp 0x303f3
jmp 0x30362
movq $-0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::reset()
void FileReader::reset()
{
	Buffered_FileReader::reset();
	offset = 0;
	readSize = std::min(blockSize, Buffered_FileReader::getNumberOfElements());
	block = Buffered_FileReader::getBuffer();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x314e0
movq 0x10(%rsp), %rdi
movq $0x0, 0x2a8(%rdi)
movq %rdi, %rax
addq $0x2b0, %rax            # imm = 0x2B0
movq %rax, 0x8(%rsp)
callq 0x31240
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xbe00
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x2a0(%rdi)
callq 0x31280
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x298(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileReader.cpp
// Function: FileReader::printBlock()
void FileReader::printBlock()
{
	for (unsigned int i = 0; i < readSize; i = i+16)
	{
		for (int j = 0; j < 16; ++j)
		{
			if (block[i+j] == 0)
			{
				std::cout << ".";
			}
			else
				std::cout << block[i+j];
		}
		std::cout << std::endl;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpq 0x2a0(%rcx), %rax
jae 0x305a8
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0x30585
movq (%rsp), %rax
movq 0x298(%rax), %rax
movl 0xc(%rsp), %ecx
addl 0x8(%rsp), %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x30551
movq 0x23a6d(%rip), %rdi     # 0x53fb0
leaq 0xbdc8(%rip), %rsi      # 0x3c312
callq 0x6420
jmp 0x30576
movq (%rsp), %rax
movq 0x298(%rax), %rax
movl 0xc(%rsp), %ecx
addl 0x8(%rsp), %ecx
movl %ecx, %ecx
movq 0x23a43(%rip), %rdi     # 0x53fb0
movsbl (%rax,%rcx), %esi
callq 0x64e0
jmp 0x30578
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x30517
movq 0x23a24(%rip), %rdi     # 0x53fb0
movq 0x239dd(%rip), %rsi     # 0x53f70
callq 0x6470
movl 0xc(%rsp), %eax
addl $0x10, %eax
movl %eax, 0xc(%rsp)
jmp 0x304fa
addq $0x18, %rsp
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/bufferedFileReader.cpp
// Function: Buffered_FileReader::reloadBuffer()
bool Buffered_FileReader::reloadBuffer()
{
	//Lambda function
	auto lambda = [&] () -> bool
	{
		HDD_Avail.lock();
		if (m_fs.is_open())
		{
			m_fs.read((char *)m_loadBuffer, m_bufferSize);
			m_loadedElements = m_fs.gcount();
		}
		HDD_Avail.unlock();
		m_localMtx.unlock();
		if (m_loadedElements == 0)
			return false;
		return true;
	};

	//Swap buffers
	m_localMtx.lock();
	char *tmp = m_loadBuffer;
	m_loadBuffer = m_workBuffer;
	m_workBuffer = tmp;
	m_globalAdress += m_elements;
	m_elements = m_loadedElements;

	//Reload buffer async
	m_threadSync = std::async(std::launch::async, lambda);
	if (m_elements == 0)
		return false;
	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movq %rdi, 0x20(%rsp)
addq $0x270, %rdi            # imm = 0x270
callq 0x33cd0
movq (%rsp), %rax
movq 0x250(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x258(%rax), %rcx
movq %rcx, 0x250(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x258(%rax)
movq 0x238(%rax), %rcx
addq 0x248(%rax), %rcx
movq %rcx, 0x248(%rax)
movq 0x240(%rax), %rcx
movq %rcx, 0x238(%rax)
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
callq 0x31310
movq (%rsp), %rdi
addq $0x260, %rdi            # imm = 0x260
leaq 0x8(%rsp), %rsi
callq 0x33d00
leaq 0x8(%rsp), %rdi
callq 0x30a70
movq (%rsp), %rax
cmpq $0x0, 0x238(%rax)
jne 0x31228
movb $0x0, 0x37(%rsp)
jmp 0x3122d
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: lrq3000[P]rfrb/./src/bufferedFileReader.cpp
// Function: Buffered_FileReader::reset()
void Buffered_FileReader::reset()
{
	m_localMtx.lock();
	m_fs.clear();
	m_fs.seekg(0, m_fs.beg);
	m_elements = m_loadedElements = 0;
	m_globalAdress = 0;
	m_localMtx.unlock();
	reloadBuffer();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x270, %rdi            # imm = 0x270
callq 0x33cd0
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x66f0
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x6590
movq 0x8(%rsp), %rdi
movq $0x0, 0x240(%rdi)
movq $0x0, 0x238(%rdi)
movq $0x0, 0x248(%rdi)
addq $0x270, %rdi            # imm = 0x270
callq 0x33d50
movq 0x8(%rsp), %rdi
callq 0x31170
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/bufferedFileReader.cpp
// Function: Buffered_FileReader::closeFile()
void Buffered_FileReader::closeFile()
{
	m_localMtx.lock();
	if (m_fs.is_open())
	{
		m_fs.close();
	}
	m_localMtx.unlock();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x270, %rdi            # imm = 0x270
callq 0x33cd0
movq 0x8(%rsp), %rdi
callq 0x6690
testb $0x1, %al
jne 0x3159f
jmp 0x315a9
movq 0x8(%rsp), %rdi
callq 0x60d0
movq 0x8(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0x33d50
addq $0x18, %rsp
retq
nop
// File: lrq3000[P]rfrb/./src/fileWriter.cpp
// Function: FileWriter::FileWriter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
FileWriter::FileWriter(std::string path, size_t bufferS)
{
	outPath = path;
	init = true;
	bufferSize = bufferS;
	workBuffer = new char[bufferSize];
	writeBuffer = new char[bufferSize];
	pos = 0;
	startTime = endTime = 0.0f;
	written = 0;
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x6710
movq 0x20(%rsp), %rdi
addq $0x200, %rdi            # imm = 0x200
movq %rdi, 0x30(%rsp)
callq 0x65c0
movq 0x20(%rsp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0x33c90
movq 0x20(%rsp), %rdi
addq $0x280, %rdi            # imm = 0x280
movq %rdi, 0x28(%rsp)
callq 0x37610
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6050
jmp 0x3460d
movq 0x18(%rsp), %rax
movb $0x1, 0x240(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x238(%rax)
movq 0x238(%rax), %rdi
callq 0x6030
movq %rax, 0x10(%rsp)
jmp 0x34638
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x290(%rax)
movq 0x238(%rax), %rdi
callq 0x6030
movq %rax, 0x8(%rsp)
jmp 0x3465c
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x298(%rax)
movq $0x0, 0x248(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x228(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x220(%rax)
movq $0x0, 0x230(%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x37620
movq 0x30(%rsp), %rdi
callq 0x6260
movq 0x20(%rsp), %rdi
callq 0x6620
movq 0x48(%rsp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileWriter.cpp
// Function: FileWriter::getTransferRate()
double FileWriter::getTransferRate()
{
	double tmp = endTime - startTime;
	tmp = written/(double)tmp;
	tmp /= 1024.0f;
	tmp *= 1000.0f;
	tmp /= 1024.0f;
	tmp *= 1000.0f;
	return tmp;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movsd 0x220(%rax), %xmm1
movsd 0x228(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movq 0x230(%rax), %xmm0
movaps 0x587d(%rip), %xmm1     # 0x3a020
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x5881(%rip), %xmm1     # 0x3a030
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
divsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
movsd 0x7638(%rip), %xmm1     # 0x3be10
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x761e(%rip), %xmm0     # 0x3be08
mulsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
movsd 0x760c(%rip), %xmm1     # 0x3be10
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x75f2(%rip), %xmm0     # 0x3be08
mulsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
retq
nopl (%rax)
// File: lrq3000[P]rfrb/./src/fileWriter.cpp
// Function: FileWriter::writeToFile(char*, unsigned long)
bool FileWriter::writeToFile(char *buf, size_t size)
{
	//Buffer is written async
	size_t counter = 0;
	while (counter < size)
	{
		if (pos >= bufferSize)
		{
			//If the first buffer should be written, the file has to be opened
			if (init == true)
			{
				startTime = endTime = timeU();
				fs.open(outPath.c_str(), std::fstream::out);
				if (!(fs))
				{
					std::cerr << "ERROR FileWriter::FileWriter - Couldnt open file: " << outPath << std::endl;
					exit(EXIT_FAILURE);
				}
				init = false;
			}
			if (writeAsync() == false)
			{
				std::cerr << "Something went terribly wrong! " << std::endl;
				return false;
			}
			continue;
		}
		workBuffer[pos] = buf[counter];
		++pos;
		++counter;
	}
	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x349c4
movq 0x8(%rsp), %rcx
movq 0x248(%rcx), %rax
cmpq 0x238(%rcx), %rax
jb 0x3497a
movq 0x8(%rsp), %rax
movb 0x240(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x34938
movq 0x8(%rsp), %rdi
callq 0x349e0
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x228(%rdi)
movsd %xmm0, 0x220(%rdi)
addq $0x200, %rdi            # imm = 0x200
callq 0x6180
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x6070
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x61b0
testb $0x1, %al
jne 0x348ec
jmp 0x3492c
movq 0x1f6fd(%rip), %rdi     # 0x53ff0
leaq 0x78c1(%rip), %rsi      # 0x3c1bb
callq 0x6420
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x200, %rsi            # imm = 0x200
callq 0x6390
movq %rax, %rdi
movq 0x1f653(%rip), %rsi     # 0x53f70
callq 0x6470
movl $0x1, %edi
callq 0x6500
movq 0x8(%rsp), %rax
movb $0x0, 0x240(%rax)
movq 0x8(%rsp), %rdi
callq 0x34a30
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x34975
movq 0x1f69d(%rip), %rdi     # 0x53ff0
leaq 0x7894(%rip), %rsi      # 0x3c1ee
callq 0x6420
movq %rax, %rdi
movq 0x1f607(%rip), %rsi     # 0x53f70
callq 0x6470
movb $0x0, 0x37(%rsp)
jmp 0x349c9
jmp 0x34856
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdx
movb (%rcx,%rdx), %sil
movq 0x290(%rax), %rcx
movq 0x248(%rax), %rdx
movb %sil, (%rcx,%rdx)
movq 0x248(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x248(%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x34856
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileWriter.cpp
// Function: FileWriter::writeAsync()
bool FileWriter::writeAsync()
{
	auto lambda = [&] () -> void
	{
		write();
		localMtx.unlock();
	};

	localMtx.lock();
	char *tmp = writeBuffer;
	writeBuffer = workBuffer;
	workBuffer = tmp;
	toWrite = pos;
	pos = 0;
	//Threads are started with the lambda function
	futureObj = std::async(std::launch::async, lambda);
	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, 0x28(%rsp)
addq $0x258, %rdi            # imm = 0x258
callq 0x33cd0
movq 0x8(%rsp), %rax
movq 0x298(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x290(%rax), %rcx
movq %rcx, 0x298(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x290(%rax)
movq 0x248(%rax), %rcx
movq %rcx, 0x250(%rax)
movq $0x0, 0x248(%rax)
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
callq 0x34d10
movq 0x8(%rsp), %rdi
addq $0x280, %rdi            # imm = 0x280
leaq 0x10(%rsp), %rsi
callq 0x37630
leaq 0x10(%rsp), %rdi
callq 0x37620
movb $0x1, %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileWriter.cpp
// Function: FileWriter::closeFile()
bool FileWriter::closeFile()
{
	//Check if file is open
	if (fs.is_open())
	{
		writeAsync();
		localMtx.lock();
		fs.close();
		localMtx.unlock();
		//Using Unix, the hashsums are calculated
#ifndef WINDOWS
		std::string sys = "md5sum ";
		sys += outPath;
		std::cout << std::endl;
		std::cout << "Hash5 for " << outPath << ":" << std::endl;
		if (system(sys.c_str()))
		{}
		std::cout << std::endl;
#endif
	}
	return true;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x6310
testb $0x1, %al
jne 0x34b01
jmp 0x34c6b
movq 0x30(%rsp), %rdi
callq 0x34a30
movq 0x30(%rsp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq %rdi, 0x20(%rsp)
callq 0x33cd0
movq 0x30(%rsp), %rdi
callq 0x65e0
movq 0x20(%rsp), %rdi
callq 0x33d50
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x6760
movq 0x28(%rsp), %rdx
leaq 0x67b1(%rip), %rsi      # 0x3b301
leaq 0x50(%rsp), %rdi
callq 0x65b0
jmp 0x34b5c
leaq 0x4f(%rsp), %rdi
callq 0x6490
movq 0x30(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq 0x50(%rsp), %rdi
callq 0x6530
jmp 0x34b7e
movq 0x1f42b(%rip), %rdi     # 0x53fb0
movq 0x1f3e4(%rip), %rsi     # 0x53f70
callq 0x6470
jmp 0x34b93
movq 0x1f416(%rip), %rdi     # 0x53fb0
leaq 0x6768(%rip), %rsi      # 0x3b309
callq 0x6420
movq %rax, 0x18(%rsp)
jmp 0x34bad
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x200, %rsi            # imm = 0x200
callq 0x6390
movq %rax, 0x10(%rsp)
jmp 0x34bca
movq 0x10(%rsp), %rdi
leaq 0x5933(%rip), %rsi      # 0x3a509
callq 0x6420
movq %rax, 0x8(%rsp)
jmp 0x34be2
movq 0x8(%rsp), %rdi
movq 0x1f382(%rip), %rsi     # 0x53f70
callq 0x6470
jmp 0x34bf5
leaq 0x50(%rsp), %rdi
callq 0x6180
movq %rax, %rdi
callq 0x6360
movl %eax, 0x4(%rsp)
jmp 0x34c0d
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
je 0x34c4c
jmp 0x34c4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x6490
jmp 0x34c74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x6260
jmp 0x34c74
movq 0x1f35d(%rip), %rdi     # 0x53fb0
movq 0x1f316(%rip), %rsi     # 0x53f70
callq 0x6470
jmp 0x34c61
leaq 0x50(%rsp), %rdi
callq 0x6260
movb $0x1, %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x6750
nop
// File: lrq3000[P]rfrb/./src/fileWriter.cpp
// Function: FileWriter::setPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileWriter::setPath(std::string path)
{
	closeFile();
	pos = 0;
	outPath = path;
	init = true;
}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x34ae0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq $0x0, 0x248(%rdi)
addq $0x200, %rdi            # imm = 0x200
callq 0x6050
movq 0x10(%rsp), %rax
movb $0x1, 0x240(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/fileWriter.cpp
// Function: FileWriter::write()
bool FileWriter::write()
{
	//If file is valid, write
	mtx.lock();
	if(fs.is_open() && fs.good())
	{
		fs.write(writeBuffer, toWrite);
		written += toWrite;
		endTime = timeU();
	}
	mtx.unlock();

	if (fs.bad())
	{
		std::cerr << "Writer is bad" << std::endl;
		return false;
	}
	return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x1f567(%rip), %rdi     # 0x54460
callq 0x33cd0
movq (%rsp), %rdi
callq 0x6310
testb $0x1, %al
jne 0x34f0d
jmp 0x34f64
movq (%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x6700
testb $0x1, %al
jne 0x34f23
jmp 0x34f64
movq (%rsp), %rdi
movq 0x298(%rdi), %rsi
movq 0x250(%rdi), %rdx
callq 0x6570
movq (%rsp), %rdi
movq 0x250(%rdi), %rax
addq 0x230(%rdi), %rax
movq %rax, 0x230(%rdi)
callq 0x349e0
movq (%rsp), %rax
movsd %xmm0, 0x228(%rax)
leaq 0x1f4f5(%rip), %rdi     # 0x54460
callq 0x33d50
movq (%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x6780
testb $0x1, %al
jne 0x34f86
jmp 0x34faf
movq 0x1f063(%rip), %rdi     # 0x53ff0
leaq 0x727a(%rip), %rsi      # 0x3c20e
callq 0x6420
movq %rax, %rdi
movq 0x1efcd(%rip), %rsi     # 0x53f70
callq 0x6470
movb $0x0, 0x17(%rsp)
jmp 0x34fb4
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: lrq3000[P]rfrb/./src/raidRecover.cpp
// Function: RaidRecover::RaidRecover(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
RaidRecover::RaidRecover(std::string inPath, std::string outPath)
{
	outP = outPath;
	inP = inPath;
	handle = new FileHandler(inPath, outPath);
	system = new RaidSystem(handle);
}

// Assembly:
subq $0xa8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x65c0
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x20(%rsp)
callq 0x65c0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x6050
jmp 0x37e07
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x6050
jmp 0x37e1c
movl $0x68, %edi
callq 0x6430
movq %rax, 0x8(%rsp)
jmp 0x37e2d
movq 0x10(%rsp), %rsi
movb $0x1, 0x3f(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x6190
jmp 0x37e43
movq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x6190
jmp 0x37e54
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xc400
jmp 0x37e6a
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x3f(%rsp)
movq %rcx, 0x40(%rax)
leaq 0x40(%rsp), %rdi
callq 0x6260
leaq 0x60(%rsp), %rdi
callq 0x6260
movl $0x30, %edi
callq 0x6430
movq %rax, (%rsp)
jmp 0x37ea1
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x6b50
jmp 0x37eb5
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x48(%rax)
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x37f69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x37f37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x37f2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x6260
leaq 0x60(%rsp), %rdi
callq 0x6260
testb $0x1, 0x3f(%rsp)
jne 0x37f40
jmp 0x37f4a
movq 0x8(%rsp), %rdi
callq 0x63f0
jmp 0x37f69
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0x63f0
movq 0x20(%rsp), %rdi
callq 0x6260
movq 0x28(%rsp), %rdi
callq 0x6260
movq 0x88(%rsp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: lrq3000[P]rfrb/./src/raidRecover.cpp
// Function: RaidRecover::RaidRecover(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>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
RaidRecover::RaidRecover(std::vector<std::string> paths, std::string outPath)
{
	outP = outPath;
	handle = new FileHandler(outPath);
	for (size_t i = 0; i < paths.size(); ++i)
	{
		handle->addImage(paths.at(i));
	}
	system = new RaidSystem(handle);
}

// Assembly:
subq $0xc8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
callq 0x65c0
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x38(%rsp)
callq 0x65c0
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x6050
jmp 0x37ff7
movl $0x68, %edi
callq 0x6430
movq %rax, 0x20(%rsp)
jmp 0x38008
movq 0x48(%rsp), %rsi
movb $0x1, 0x7f(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6190
jmp 0x38021
movq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xc2c0
jmp 0x38035
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movb $0x0, 0x7f(%rsp)
movq %rcx, 0x40(%rax)
leaq 0x80(%rsp), %rdi
callq 0x6260
movq $0x0, 0x70(%rsp)
movq 0x28(%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x18fc0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x3816b
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rsi
callq 0x19030
movq %rax, 0x10(%rsp)
jmp 0x380a7
movq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x6190
jmp 0x380b8
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xcd40
jmp 0x380c9
leaq 0x50(%rsp), %rdi
callq 0x6260
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x3805e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x381c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x38136
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6260
testb $0x1, 0x7f(%rsp)
jne 0x3813f
jmp 0x38149
movq 0x20(%rsp), %rdi
callq 0x63f0
jmp 0x381c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x6260
jmp 0x381c1
movl $0x30, %edi
callq 0x6430
movq %rax, (%rsp)
jmp 0x3817b
movq (%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x6b50
jmp 0x3818f
movq 0x30(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x48(%rax)
addq $0xc8, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x63f0
movq 0x38(%rsp), %rdi
callq 0x6260
movq 0x40(%rsp), %rdi
callq 0x6260
movq 0xa8(%rsp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: lrq3000[P]rfrb/./src/raidRecover.cpp
// Function: RaidRecover::run()
void RaidRecover::run()
{
	//Set name for recovered dataImage
	std::string o = outP+"dataImage.dd";

	//Start with analysing the case und recover lost data (if possible)
	bool found = system->raidCheck(o);
	std::cout << std::endl;

	//Check if everything went fine
	if (found==true)
		std::cout << "Recovery successful!" << std::endl;
	else
		std::cout << "Recovery was aborted!" << std::endl;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rsi
movq %rsi, 0x20(%rsp)
leaq 0x3faa(%rip), %rdx      # 0x3c24d
leaq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x18e60
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rsi
movq 0x48(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6190
jmp 0x382d1
movq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x73a0
movb %al, 0x1f(%rsp)
jmp 0x382e6
leaq 0x48(%rsp), %rdi
callq 0x6260
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq 0x1bcaf(%rip), %rdi     # 0x53fb0
movq 0x1bc68(%rip), %rsi     # 0x53f70
callq 0x6470
jmp 0x3830f
movb 0x6f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x38376
movq 0x1bc8c(%rip), %rdi     # 0x53fb0
leaq 0x3f2f(%rip), %rsi      # 0x3c25a
callq 0x6420
movq %rax, 0x10(%rsp)
jmp 0x38337
movq 0x10(%rsp), %rdi
movq 0x1bc2d(%rip), %rsi     # 0x53f70
callq 0x6470
jmp 0x3834a
jmp 0x383a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x383b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6260
jmp 0x383b7
movq 0x1bc33(%rip), %rdi     # 0x53fb0
leaq 0x3eeb(%rip), %rsi      # 0x3c26f
callq 0x6420
movq %rax, 0x8(%rsp)
jmp 0x38390
movq 0x8(%rsp), %rdi
movq 0x1bbd4(%rip), %rsi     # 0x53f70
callq 0x6470
jmp 0x383a3
jmp 0x383a5
leaq 0x70(%rsp), %rdi
callq 0x6260
addq $0x98, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x6260
movq 0x40(%rsp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: ericprud[P]sean-parent-concept-based-polymorphism/./doc-library.hh
// Function: draw(history_t const&, std::ostream&, unsigned long)
void draw(const history_t& h, std::ostream& out, size_t position)
    {
        out << std::string(position, ' ') << "<history>" << std::endl;
        for (const auto& doc : h.documents)
            draw(doc, out, position + 2);
        out << std::string(position, ' ') << "</history>" << std::endl;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2240
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x20, %edx
callq 0x4520
jmp 0x2a8b
movq -0xb0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2130
movq %rax, -0xb8(%rbp)
jmp 0x2aa4
movq -0xb8(%rbp), %rdi
leaq 0x7608(%rip), %rsi      # 0xa0ba
callq 0x2140
movq %rax, -0xc0(%rbp)
jmp 0x2ac0
movq -0xc0(%rbp), %rdi
movq 0xe4f2(%rip), %rsi      # 0x10fc0
callq 0x2170
jmp 0x2ad5
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x39(%rbp), %rdi
callq 0x2190
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x4590
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x45c0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x45f0
testb $0x1, %al
jne 0x2b1c
jmp 0x2b7a
leaq -0x60(%rbp), %rdi
callq 0x4630
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x2, %rdx
callq 0x4650
leaq -0x60(%rbp), %rdi
callq 0x48a0
jmp 0x2b09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2b6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x39(%rbp), %rdi
callq 0x2190
jmp 0x2c64
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x2240
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rcx
leaq -0x90(%rbp), %rdi
movl $0x20, %edx
callq 0x4520
jmp 0x2bc4
movq -0xd8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2130
movq %rax, -0xe0(%rbp)
jmp 0x2be0
movq -0xe0(%rbp), %rdi
leaq 0x74d6(%rip), %rsi      # 0xa0c4
callq 0x2140
movq %rax, -0xe8(%rbp)
jmp 0x2bfc
movq -0xe8(%rbp), %rdi
movq 0xe3b6(%rip), %rsi      # 0x10fc0
callq 0x2170
jmp 0x2c11
leaq -0x90(%rbp), %rdi
callq 0x20b0
leaq -0x91(%rbp), %rdi
callq 0x2190
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2c58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x20b0
leaq -0x91(%rbp), %rdi
callq 0x2190
movq -0x48(%rbp), %rdi
callq 0x2230
nopl (%rax)