LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>::append_attribute(rapidxml::xml_attribute<char>*)
void append_attribute(xml_attribute<Ch> *attribute)
        {
            assert(attribute && !attribute->parent());
            if (first_attribute())
            {
                attribute->m_prev_attribute = m_last_attribute;
                m_last_attribute->m_next_attribute = attribute;
            }
            else
            {
                attribute->m_prev_attribute = 0;
                m_first_attribute = attribute;
            }
            m_last_attribute = attribute;
            attribute->m_parent = this;
            attribute->m_next_attribute = 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x9529
movq -0x10(%rbp), %rdi
callq 0x9db0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x9532
jmp 0x9534
jmp 0x9553
leaq 0x2f22(%rip), %rdi      # 0xc45d
leaq 0x2dff(%rip), %rsi      # 0xc341
movl $0x4c3, %edx            # imm = 0x4C3
leaq 0x2f31(%rip), %rcx      # 0xc47f
callq 0x31a0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x5e30
cmpq $0x0, %rax
je 0x958c
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x28(%rcx)
movq -0x10(%rbp), %rcx
movq 0x48(%rax), %rax
movq %rcx, 0x30(%rax)
jmp 0x95a4
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, 0x28(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, 0x48(%rcx)
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: bool rapidxml::internal::compare<char>(char const*, unsigned long, char const*, unsigned long, bool)
inline bool compare(const Ch *p1, std::size_t size1, const Ch *p2, std::size_t size2, bool case_sensitive)
        {
            if (size1 != size2)
                return false;
            if (case_sensitive)
            {
                for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
                    if (*p1 != *p2)
                        return false;
            }
            else
            {
                for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
                    if (lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p1)] != lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p2)])
                        return false;
            }
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xa71f
movb $0x0, -0x1(%rbp)
jmp 0xa7de
testb $0x1, -0x29(%rbp)
je 0xa774
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xa772
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xa756
movb $0x0, -0x1(%rbp)
jmp 0xa7de
jmp 0xa758
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa731
jmp 0xa7da
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xa7d8
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x28a6(%rip), %rax      # 0xd040
movzbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %edx
leaq 0x2892(%rip), %rcx      # 0xd040
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xa7bc
movb $0x0, -0x1(%rbp)
jmp 0xa7de
jmp 0xa7be
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa780
jmp 0xa7da
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Matlock42[P]Jeopardy/jQuestion.cpp
// Function: Question::Question(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Question::Question(std::string aCat, int aPrice, std::string aQuestion)
{
	this->mCategory = aCat;
	this->mPrice = aPrice;
	this->mQuestion = aQuestion;
	this->mPlayed = false;
	for(int i = 0; i < 4; i++)
		mAns[i] = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3390
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3390
movq -0x50(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x48(%rbp)
movq %rax, %rcx
addq $0x80, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3390
movq -0x70(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0xaffe
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x3040
jmp 0xb02f
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x20(%rdi)
addq $0x28, %rdi
callq 0x3040
jmp 0xb048
movq -0x50(%rbp), %rax
movb $0x0, 0xcc(%rax)
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0xb0a9
movq -0x50(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x5, %rcx
leaq 0x48(%rax,%rcx), %rdi
leaq 0xfd5(%rip), %rsi       # 0xc04d
callq 0x3380
jmp 0xb07f
jmp 0xb081
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xb05a
movq %rdx, %rcx
movq %rax, %rdx
movq -0x48(%rbp), %rax
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
addq $0x80, %rax
movq %rax, -0x78(%rbp)
jmp 0xb0b2
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x80(%rbp)
callq 0x3180
movq -0x48(%rbp), %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x78(%rbp)
jne 0xb0b2
movq -0x58(%rbp), %rdi
callq 0x3180
movq -0x50(%rbp), %rdi
callq 0x3180
movq -0x28(%rbp), %rdi
callq 0x34a0
nop
// File: Matlock42[P]Jeopardy/jQuestion.cpp
// Function: Question::addAnswer(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Question::addAnswer(int aPos, std::string aAns)
{
	if(aPos > 3 || aPos < 0)
		return false;
	if(this->mAns[aPos] != "")
		return false;
	this->mAns[aPos] = aAns;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x3, -0x14(%rbp)
jg 0xb18b
cmpl $0x0, -0x14(%rbp)
jge 0xb191
movb $0x0, -0x1(%rbp)
jmp 0xb1dc
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
leaq 0xea2(%rip), %rsi       # 0xc04d
callq 0x38c0
testb $0x1, %al
jne 0xb1b6
jmp 0xb1bc
movb $0x0, -0x1(%rbp)
jmp 0xb1dc
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Matlock42[P]Jeopardy/jQuestion.cpp
// Function: Question::showAnswers()
int Question::showAnswers()
{
	int i;
	// There are 4 possible answers loop through them
	for (i = 1; i <= 4; i++)
	{
		cout << (i) << ". " << this->mAns[(i-1)] << "\n";
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jg 0xb338
movl -0xc(%rbp), %esi
movq 0x6cdd(%rip), %rdi      # 0x11fc8
callq 0x3480
movq %rax, %rdi
leaq 0x1e46(%rip), %rsi      # 0xd140
callq 0x3280
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x48, %rsi
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltq
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3230
movq %rax, %rdi
leaq 0xe6a(%rip), %rsi       # 0xc192
callq 0x3280
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb2db
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: girdhari9[P]mTORRENT/ClientServer.cpp
// Function: ReadLogFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ReadLogFile(string ClientLog){
	ifstream TrackerFile(ClientLog.c_str(), ifstream::binary);
    if (TrackerFile.is_open()){
    	string detail;
    	while(getline (TrackerFile,detail)){
    		stringstream Log(detail); // Used for breaking words 
            string mtorrentfilename,SHA,FilePath; // to store individual words 
            	Log >> mtorrentfilename;
                LogVector.push_back(mtorrentfilename);
		        Log >> SHA;
		        LogVector.push_back(SHA);
		        Log >> FilePath;
		        LogVector.push_back(FilePath);
    	}
        TrackerFile.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
callq 0x41f0
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movq %rdi, -0x438(%rbp)
movl $0x4, %edx
callq 0x4740
movq -0x438(%rbp), %rdi
callq 0x4650
movb %al, -0x429(%rbp)
jmp 0x5b93
movb -0x429(%rbp), %al
testb $0x1, %al
jne 0x5ba2
jmp 0x5da0
leaq -0x240(%rbp), %rdi
callq 0x45a0
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x4100
movq %rax, -0x440(%rbp)
jmp 0x5bca
movq -0x440(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4510
movb %al, -0x441(%rbp)
jmp 0x5be8
movb -0x441(%rbp), %al
testb $0x1, %al
jne 0x5bf7
jmp 0x5d76
movl $0x10, %edi
movl $0x8, %esi
callq 0x7490
movl %eax, -0x448(%rbp)
jmp 0x5c0e
movl -0x448(%rbp), %edx
leaq -0x3c8(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x4640
jmp 0x5c29
leaq -0x3e8(%rbp), %rdi
movq %rdi, -0x450(%rbp)
callq 0x45a0
leaq -0x408(%rbp), %rdi
callq 0x45a0
leaq -0x428(%rbp), %rdi
callq 0x45a0
movq -0x450(%rbp), %rsi
leaq -0x3c8(%rbp), %rdi
callq 0x4540
jmp 0x5c69
leaq 0x1bcc0(%rip), %rdi     # 0x21930
leaq -0x3e8(%rbp), %rsi
callq 0x6eb0
jmp 0x5c7e
leaq -0x3c8(%rbp), %rdi
leaq -0x408(%rbp), %rsi
callq 0x4540
jmp 0x5c93
leaq 0x1bc96(%rip), %rdi     # 0x21930
leaq -0x408(%rbp), %rsi
callq 0x6eb0
jmp 0x5ca8
leaq -0x3c8(%rbp), %rdi
leaq -0x428(%rbp), %rsi
callq 0x4540
jmp 0x5cbd
leaq 0x1bc6c(%rip), %rdi     # 0x21930
leaq -0x428(%rbp), %rsi
callq 0x6eb0
jmp 0x5cd2
leaq -0x428(%rbp), %rdi
callq 0x47e8
leaq -0x408(%rbp), %rdi
callq 0x47e8
leaq -0x3e8(%rbp), %rdi
callq 0x47e8
leaq -0x3c8(%rbp), %rdi
callq 0x4320
jmp 0x5bae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x5db5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x5d92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x428(%rbp), %rdi
callq 0x47e8
leaq -0x408(%rbp), %rdi
callq 0x47e8
leaq -0x3e8(%rbp), %rdi
callq 0x47e8
leaq -0x3c8(%rbp), %rdi
callq 0x4320
jmp 0x5d92
leaq -0x210(%rbp), %rdi
callq 0x4110
jmp 0x5d84
leaq -0x240(%rbp), %rdi
callq 0x47e8
jmp 0x5da0
leaq -0x240(%rbp), %rdi
callq 0x47e8
jmp 0x5db5
leaq -0x210(%rbp), %rdi
callq 0x4150
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x4150
movq -0x218(%rbp), %rdi
callq 0x4700
nopl (%rax)
// File: girdhari9[P]mTORRENT/ClientServer.cpp
// Function: UpdateToTracker()
void UpdateToTracker(){
	for(unsigned int i = 0; i < LogVector.size(); i += 3){
		string mtorrentfilename, SHA, root_path;
		mtorrentfilename = LogVector.front(); LogVector.pop_back();
		SHA = LogVector.front(); LogVector.pop_back();
		root_path = LogVector.front(); LogVector.pop_back();
		thread client (FunctionCalling, cref(mtorrentfilename),1,SHA,root_path);
		client.join();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x98(%rbp)
leaq 0x1bb3d(%rip), %rdi     # 0x21930
callq 0x72a0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f6f
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x45a0
leaq -0x48(%rbp), %rdi
callq 0x45a0
leaq -0x68(%rbp), %rdi
callq 0x45a0
leaq 0x1bafc(%rip), %rdi     # 0x21930
callq 0x74b0
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x4050
jmp 0x5e4a
leaq 0x1badf(%rip), %rdi     # 0x21930
movq %rdi, -0xa8(%rbp)
callq 0x74e0
movq -0xa8(%rbp), %rdi
callq 0x74b0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x4050
jmp 0x5e77
leaq 0x1bab2(%rip), %rdi     # 0x21930
movq %rdi, -0xb0(%rbp)
callq 0x74e0
movq -0xb0(%rbp), %rdi
callq 0x74b0
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x4050
jmp 0x5ea4
leaq 0x1ba85(%rip), %rdi     # 0x21930
callq 0x74e0
leaq -0x28(%rbp), %rdi
callq 0x6f90
movq %rax, -0x88(%rbp)
movl $0x1, -0x8c(%rbp)
leaq 0x4e5f(%rip), %rsi      # 0xad30
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rdx
leaq -0x8c(%rbp), %rcx
leaq -0x48(%rbp), %r8
leaq -0x68(%rbp), %r9
callq 0x7510
jmp 0x5ef2
leaq -0x80(%rbp), %rdi
callq 0x46c0
jmp 0x5efd
leaq -0x80(%rbp), %rdi
callq 0x7160
leaq -0x68(%rbp), %rdi
callq 0x47e8
leaq -0x48(%rbp), %rdi
callq 0x47e8
leaq -0x28(%rbp), %rdi
callq 0x47e8
movl -0x4(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x5de2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x5f52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x7160
leaq -0x68(%rbp), %rdi
callq 0x47e8
leaq -0x48(%rbp), %rdi
callq 0x47e8
leaq -0x28(%rbp), %rdi
callq 0x47e8
jmp 0x5f78
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x4700
nopw %cs:(%rax,%rax)
// File: girdhari9[P]mTORRENT/ClientServer.cpp
// Function: ShowDownloadDetail()
void ShowDownloadDetail(){
	ifstream TrackerFile(DOWNLOADLOG.c_str(), ifstream::binary);
    if (TrackerFile.is_open()){
    	string detail;
    	while(getline (TrackerFile,detail)){
    		cout<<detail<<"\n";
    	}
        TrackerFile.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
leaq 0x1a946(%rip), %rdi     # 0x214c8
callq 0x41f0
movq %rax, %rsi
leaq -0x208(%rbp), %rdi
movq %rdi, -0x248(%rbp)
movl $0x4, %edx
callq 0x4740
movq -0x248(%rbp), %rdi
callq 0x4650
movb %al, -0x239(%rbp)
jmp 0x6bb6
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x6bc5
jmp 0x6c98
leaq -0x238(%rbp), %rdi
callq 0x45a0
leaq -0x208(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x4100
movq %rax, -0x250(%rbp)
jmp 0x6bed
movq -0x250(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4510
movb %al, -0x251(%rbp)
jmp 0x6c0b
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x6c17
jmp 0x6c7e
movq 0x1a3aa(%rip), %rdi     # 0x20fc8
leaq -0x238(%rbp), %rsi
callq 0x43c0
movq %rax, -0x260(%rbp)
jmp 0x6c33
movq -0x260(%rbp), %rdi
leaq 0xf7fd(%rip), %rsi      # 0x1643e
callq 0x43f0
jmp 0x6c48
jmp 0x6bd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x6cad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x47e8
jmp 0x6cad
leaq -0x208(%rbp), %rdi
callq 0x4110
jmp 0x6c8c
leaq -0x238(%rbp), %rdi
callq 0x47e8
leaq -0x208(%rbp), %rdi
callq 0x4150
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x208(%rbp), %rdi
callq 0x4150
movq -0x210(%rbp), %rdi
callq 0x4700
nopw %cs:(%rax,%rax)
nop
// File: girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: TrackerConnection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int TrackerConnection(string IPaddress,int PORT){
    int sock = 0; 
    struct sockaddr_in serv_addr;
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
    { 
        printf("\n Socket creation error \n"); 
        return -1; 
    } 
    memset(&serv_addr, '0', sizeof(serv_addr)); 
    serv_addr.sin_family = AF_INET; 
    serv_addr.sin_port = htons(PORT); 
    
    if(inet_pton(AF_INET, IPaddress.c_str() , &serv_addr.sin_addr)<=0){ 
        printf("\nInvalid address/ Address not supported \n"); 
        return -1; 
    } 
   
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){ 
        printf("\nConnection Failed \n"); 
        return -1; 
    }
    return sock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x4130
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jge 0xc35d
leaq 0xa09d(%rip), %rdi      # 0x163e7
movb $0x0, %al
callq 0x4070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc3f2
leaq -0x28(%rbp), %rdi
movl $0x30, %esi
movl $0x10, %edx
callq 0x4260
movw $0x2, -0x28(%rbp)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x4090
movq -0x30(%rbp), %rdi
movw %ax, -0x26(%rbp)
callq 0x41f0
movq %rax, %rsi
leaq -0x28(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x4760
cmpl $0x0, %eax
jg 0xc3bf
leaq 0xa052(%rip), %rdi      # 0x16401
movb $0x0, %al
callq 0x4070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc3f2
movl -0x18(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x10, %edx
callq 0x4360
cmpl $0x0, %eax
jge 0xc3ec
leaq 0xa04f(%rip), %rdi      # 0x1642b
movb $0x0, %al
callq 0x4070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc3f2
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: SendToSeederList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void SendToSeederList(string filename, string SHA, int sock, string root_path,int RequestType){
    char sendBuffer[BUFFER_SIZE];
    memset(&sendBuffer, '\0',BUFFER_SIZE);

    cout<<"[+]system started...\n"; 
    cout<<"[+]system connecting...\n";

    string IP = MYIP, FilePath;
    int IPsize = IP.size(), RootPathSize = root_path.size();

    send(sock , &RequestType , sizeof(int) , 0 );
    send(sock , SHA.c_str() , SHA_DIGEST_LENGTH, 0 );

    send(sock , &IPsize, sizeof(int), 0 );
    send(sock , IP.c_str() , IPsize, 0 );
    send(sock , &PORT , sizeof(int) , 0 );
    send(sock , &RootPathSize , sizeof(int) , 0 );
    send(sock , root_path.c_str() , RootPathSize , 0 );

    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x890, %rsp            # imm = 0x890
movq %rsi, -0x878(%rbp)
movq %rcx, -0x860(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq -0x800(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0x858(%rbp)
movl $0x7d0, %edx            # imm = 0x7D0
callq 0x4260
movq 0x14b7c(%rip), %rdi     # 0x20fc8
movq %rdi, -0x870(%rbp)
leaq 0xa021(%rip), %rsi      # 0x1647b
callq 0x43f0
movq -0x870(%rbp), %rdi
leaq 0xa024(%rip), %rsi      # 0x16491
callq 0x43f0
leaq 0x14fcf(%rip), %rsi     # 0x21448
leaq -0x820(%rbp), %rdi
movq %rdi, -0x868(%rbp)
callq 0x4200
leaq -0x840(%rbp), %rdi
callq 0x45a0
movq -0x868(%rbp), %rdi
callq 0x42f0
movq -0x860(%rbp), %rdi
movl %eax, -0x844(%rbp)
callq 0x42f0
movl -0x858(%rbp), %ecx
movl %eax, -0x848(%rbp)
movl -0x14(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0x4230
jmp 0xc4d5
movq -0x878(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x87c(%rbp)
callq 0x41f0
movl -0x87c(%rbp), %edi
movq %rax, %rsi
movl $0x14, %edx
xorl %ecx, %ecx
callq 0x4230
jmp 0xc501
movl -0x14(%rbp), %edi
leaq -0x844(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x4230
jmp 0xc519
movl -0x14(%rbp), %eax
movl %eax, -0x880(%rbp)
leaq -0x820(%rbp), %rdi
callq 0x41f0
movl -0x880(%rbp), %edi
movq %rax, %rsi
movslq -0x844(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4230
jmp 0xc547
movl -0x14(%rbp), %edi
leaq 0x14eef(%rip), %rsi     # 0x21440
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x4230
jmp 0xc55f
movl -0x14(%rbp), %edi
leaq -0x848(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x4230
jmp 0xc577
movq -0x860(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x884(%rbp)
callq 0x41f0
movl -0x884(%rbp), %edi
movq %rax, %rsi
movslq -0x848(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4230
jmp 0xc5a5
leaq -0x840(%rbp), %rdi
callq 0x47e8
leaq -0x820(%rbp), %rdi
callq 0x47e8
addq $0x890, %rsp            # imm = 0x890
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x850(%rbp)
movl %eax, -0x854(%rbp)
leaq -0x840(%rbp), %rdi
callq 0x47e8
leaq -0x820(%rbp), %rdi
callq 0x47e8
movq -0x850(%rbp), %rdi
callq 0x4700
nopl (%rax)
// File: girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: ReadSHA[abi:cxx11](int)
string ReadSHA(int TorrentFileD){
    char sendBuffer[BUFFER_SIZE];

    int read_size = read(TorrentFileD, sendBuffer, SHA_DIGEST_LENGTH);
    if(read_size == SHA_DIGEST_LENGTH){
        return sendBuffer;
    }
    return "-1";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movq %rdi, -0x808(%rbp)
movq %rdi, %rax
movq %rax, -0x800(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq -0x7e0(%rbp), %rsi
movl $0x14, %edx
callq 0x45c0
movl %eax, -0x7e4(%rbp)
cmpl $0x14, -0x7e4(%rbp)
jne 0xc6a3
leaq -0x7e5(%rbp), %rdi
movq %rdi, -0x810(%rbp)
callq 0x4710
movq -0x808(%rbp), %rdi
movq -0x810(%rbp), %rdx
leaq -0x7e0(%rbp), %rsi
callq 0x6d90
jmp 0xc675
leaq -0x7e5(%rbp), %rdi
callq 0x4450
jmp 0xc700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x7f0(%rbp)
movl %eax, -0x7f4(%rbp)
leaq -0x7e5(%rbp), %rdi
callq 0x4450
jmp 0xc710
leaq -0x7f5(%rbp), %rdi
movq %rdi, -0x818(%rbp)
callq 0x4710
movq -0x808(%rbp), %rdi
movq -0x818(%rbp), %rdx
leaq 0x9dad(%rip), %rsi      # 0x16478
callq 0x6d90
jmp 0xc6d2
leaq -0x7f5(%rbp), %rdi
callq 0x4450
jmp 0xc700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x7f0(%rbp)
movl %eax, -0x7f4(%rbp)
leaq -0x7f5(%rbp), %rdi
callq 0x4450
jmp 0xc710
movq -0x800(%rbp), %rax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
movq -0x7f0(%rbp), %rdi
callq 0x4700
nopl (%rax)
// File: girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: Connection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int Connection(string IPaddress,int PORT){
    int sock = 0; 
    struct sockaddr_in serv_addr;
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
    { 
        printf("\n Socket creation error \n"); 
        return -1; 
    } 
    memset(&serv_addr, '0', sizeof(serv_addr)); 
    serv_addr.sin_family = AF_INET; 
    serv_addr.sin_port = htons(PORT); 
    
    if(inet_pton(AF_INET, IPaddress.c_str() , &serv_addr.sin_addr)<=0){ 
        printf("\nInvalid address/ Address not supported \n"); 
        return -1; 
    } 
   
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){ 
        printf("\nConnection Failed \n"); 
        return -1; 
    }
    else{
        sem_wait(&mutex1);
            cout<<"> You are connected with: "<<IPaddress<<":"<<PORT<<"\n";
        sem_post(&mutex1);
    }
    return sock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x4130
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jge 0xd96d
leaq 0x8a8d(%rip), %rdi      # 0x163e7
movb $0x0, %al
callq 0x4070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xda65
leaq -0x28(%rbp), %rdi
movl $0x30, %esi
movl $0x10, %edx
callq 0x4260
movw $0x2, -0x28(%rbp)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x4090
movq -0x30(%rbp), %rdi
movw %ax, -0x26(%rbp)
callq 0x41f0
movq %rax, %rsi
leaq -0x28(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x4760
cmpl $0x0, %eax
jg 0xd9d2
leaq 0x8a42(%rip), %rdi      # 0x16401
movb $0x0, %al
callq 0x4070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xda65
movl -0x18(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x10, %edx
callq 0x4360
cmpl $0x0, %eax
jge 0xd9ff
leaq 0x8a3c(%rip), %rdi      # 0x1642b
movb $0x0, %al
callq 0x4070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xda65
leaq 0x13faa(%rip), %rdi     # 0x219b0
callq 0x4280
movq 0x135b6(%rip), %rdi     # 0x20fc8
leaq 0x8a91(%rip), %rsi      # 0x164aa
callq 0x43f0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x43c0
movq %rax, %rdi
leaq 0x86a2(%rip), %rsi      # 0x160d6
callq 0x43f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x46e0
movq %rax, %rdi
leaq 0x89f0(%rip), %rsi      # 0x1643e
callq 0x43f0
leaq 0x13f56(%rip), %rdi     # 0x219b0
callq 0x46a0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: girdhari9[P]mTORRENT/ServerConnection.cpp
// Function: ServerConnection()
void ServerConnection(){
    int server_fd; 
    struct sockaddr_in address; 
    int opt = 1; 
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0){ 
        perror("socket failed"); 
        exit(EXIT_FAILURE); 
    } 
       
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,&opt, sizeof(opt))){ 
        perror("setsockopt"); 
        exit(EXIT_FAILURE); 
    } 
    address.sin_family = AF_INET; 
    address.sin_addr.s_addr = INADDR_ANY; 
    address.sin_port = htons( PORT ); 
       
    if (bind(server_fd, (struct sockaddr *)&address,sizeof(address))<0){ 
        perror("bind failed"); 
        exit(EXIT_FAILURE); 
    } 
    if (listen(server_fd, 3) < 0){ 
        perror("listen"); 
        exit(EXIT_FAILURE); printf("[+]server started...\n");
    }
    Communication(server_fd,address);
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x1, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x4130
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jne 0x13bde
leaq 0x2acd(%rip), %rdi      # 0x1669c
callq 0x4370
movl $0x1, %edi
callq 0x44e0
movl -0x4(%rbp), %edi
movl $0x1, %esi
movl $0xf, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x4720
cmpl $0x0, %eax
je 0x13c15
leaq 0x2aa4(%rip), %rdi      # 0x166aa
callq 0x4370
movl $0x1, %edi
callq 0x44e0
movw $0x2, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0xd817(%rip), %rax      # 0x21440
movl (%rax), %eax
movzwl %ax, %edi
callq 0x4090
movw %ax, -0x12(%rbp)
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rsi
movl $0x10, %edx
callq 0x40c0
cmpl $0x0, %eax
jge 0x13c63
leaq 0x2a61(%rip), %rdi      # 0x166b5
callq 0x4370
movl $0x1, %edi
callq 0x44e0
movl -0x4(%rbp), %edi
movl $0x3, %esi
callq 0x4490
cmpl $0x0, %eax
jge 0x13c8b
leaq 0x2a45(%rip), %rdi      # 0x166c1
callq 0x4370
movl $0x1, %edi
callq 0x44e0
movl -0x4(%rbp), %edi
movq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13cc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: girdhari9[P]mTORRENT/ServerConnection.cpp
// Function: Communication(int, sockaddr_in)
void Communication(int server_fd,struct sockaddr_in address){
    int new_socket,addrlen = sizeof(address), RequestType;
    printf("[+]server started...\n");
    while(1){
        printf("[+]Listening...\n");
        if ((new_socket = accept(server_fd, (struct sockaddr *)&address,(socklen_t*)&addrlen))<0){ 
            perror("accept"); 
            exit(EXIT_FAILURE); 
        } 
        read(new_socket, &RequestType, sizeof(int));
        if(RequestType == 1)
            BitVectorDetailSend(new_socket);
        else
            SendData(new_socket);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movl $0x10, -0x1c(%rbp)
leaq 0x29e7(%rip), %rdi      # 0x166c8
movb $0x0, %al
callq 0x4070
leaq 0x29ef(%rip), %rdi      # 0x166de
movb $0x0, %al
callq 0x4070
movl -0x14(%rbp), %edi
leaq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x41a0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jge 0x13d24
leaq 0x29da(%rip), %rdi      # 0x166ef
callq 0x4370
movl $0x1, %edi
callq 0x44e0
movl -0x18(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x45c0
cmpl $0x1, -0x20(%rbp)
jne 0x13d45
movl -0x18(%rbp), %edi
callq 0x13d50
jmp 0x13d4d
movl -0x18(%rbp), %edi
callq 0x13f50
jmp 0x13ce8
nop
// File: girdhari9[P]mTORRENT/ServerConnection.cpp
// Function: BitVectorDetailSend(int)
void BitVectorDetailSend(int new_socket){
    if(fork() == 0){
        int ack, TotalPacket;
        char SHA[20];

        printf("Client is ready...\n");

        read(new_socket, &TotalPacket,sizeof(int));

        read(new_socket, SHA ,20);
        string BitBuffer = TotalFile[(string)SHA];

        send(new_socket, BitBuffer.c_str(), BitBuffer.size(), 0);

        int AvlPack = 0;
        for(int i = 0; i < TotalPacket; i++){
            if((BitBuffer[i]-'0')) AvlPack++;
        }
        send(new_socket, &AvlPack, sizeof(int), 0);
        read(new_socket, &ack, sizeof(int));
        
        close(new_socket);
        exit(0);
    }
    else{
        cout<<"[+]server busy...\n";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
callq 0x4160
cmpl $0x0, %eax
jne 0x13f29
leaq 0x2983(%rip), %rdi      # 0x166f6
xorl %eax, %eax
callq 0x4070
movl -0x4(%rbp), %edi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x45c0
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x90(%rbp)
movl $0x14, %edx
callq 0x45c0
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4710
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x6d90
jmp 0x13dcc
leaq 0xd715(%rip), %rdi      # 0x214e8
leaq -0x60(%rbp), %rsi
callq 0x143e0
movq %rax, -0x98(%rbp)
jmp 0x13de5
movq -0x98(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x13df7
leaq -0x60(%rbp), %rdi
callq 0x47e8
leaq -0x61(%rbp), %rdi
callq 0x4450
movl -0x4(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x41f0
movq -0xb0(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x42f0
movl -0xa4(%rbp), %edi
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x4230
jmp 0x13e4e
movl $0x0, -0x78(%rbp)
movl $0x0, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13ef0
movslq -0x7c(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x47d0
movq %rax, -0xb8(%rbp)
jmp 0x13e7e
movq -0xb8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cmpl $0x0, %eax
je 0x13ee0
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x13ee0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x13ebe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x47e8
leaq -0x61(%rbp), %rdi
callq 0x4450
jmp 0x13f45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x47e8
jmp 0x13f45
jmp 0x13ee2
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x13e5c
movl -0x4(%rbp), %edi
leaq -0x78(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x4230
jmp 0x13f05
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %rsi
movl $0x4, %edx
callq 0x45c0
jmp 0x13f18
movl -0x4(%rbp), %edi
callq 0x47b0
jmp 0x13f22
xorl %edi, %edi
callq 0x44e0
movq 0xd098(%rip), %rdi      # 0x20fc8
leaq 0x27d3(%rip), %rsi      # 0x1670a
callq 0x43f0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x4700
nop
// File: girdhari9[P]mTORRENT/ServerConnection.cpp
// Function: SetBitMap(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SetBitMap(int TotalPacket, int flag, string SHA){
    char *BitBuffer = new char[TotalPacket];
    if(flag){
        for(int i=0; i<TotalPacket; i++)
            BitBuffer[i] = '1';
    }
    else{
        for(int i=0; i<TotalPacket; i++)
            BitBuffer[i] = '0';
    }
    TotalFile[SHA] = (string)BitBuffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x60(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movslq -0x4(%rbp), %rdi
callq 0x4030
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x14314
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x14312
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x31, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x142f3
jmp 0x1433c
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1433a
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x30, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1431b
jmp 0x1433c
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4710
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6d90
jmp 0x14364
movq -0x60(%rbp), %rsi
leaq 0xd179(%rip), %rdi      # 0x214e8
callq 0xe0d0
movq %rax, -0x78(%rbp)
jmp 0x1437a
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x44f0
leaq -0x40(%rbp), %rdi
callq 0x47e8
leaq -0x41(%rbp), %rdi
callq 0x4450
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x143c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x47e8
leaq -0x41(%rbp), %rdi
callq 0x4450
movq -0x50(%rbp), %rdi
callq 0x4700
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_15.cc
// Function: connect(Destination*)
Connection connect(Destination* pDest)
{
	shared_ptr<Connection> pConn(new Connection(pDest->ip, pDest->port));

	// ...

	cout << "Creat connection(" << pConn.use_count() << ")" << endl;

	return *pConn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x20d0
movq %rax, -0x58(%rbp)
movb $0x1, -0x4d(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2060
jmp 0x230f
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movswl 0x20(%rax), %edx
leaq -0x40(%rbp), %rsi
callq 0x2d80
jmp 0x2326
movq -0x58(%rbp), %rsi
movb $0x0, -0x4d(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2dc0
jmp 0x2339
leaq -0x40(%rbp), %rdi
callq 0x2070
movq 0x4c8f(%rip), %rdi      # 0x6fd8
leaq 0x1cb4(%rip), %rsi      # 0x4004
callq 0x20c0
movq %rax, -0x70(%rbp)
jmp 0x235b
leaq -0x20(%rbp), %rdi
callq 0x2df0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x2180
movq %rax, -0x78(%rbp)
jmp 0x2376
movq -0x78(%rbp), %rdi
leaq 0x1c95(%rip), %rsi      # 0x4016
callq 0x20c0
movq %rax, -0x80(%rbp)
jmp 0x238c
movq -0x80(%rbp), %rdi
movq 0x4c29(%rip), %rsi      # 0x6fc0
callq 0x20f0
jmp 0x239e
leaq -0x20(%rbp), %rdi
callq 0x2e10
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x2e40
jmp 0x23b5
leaq -0x20(%rbp), %rdi
callq 0x2e80
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x23ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2070
testb $0x1, -0x4d(%rbp)
jne 0x23f6
jmp 0x2404
movq -0x58(%rbp), %rdi
movl $0x28, %esi
callq 0x20e0
jmp 0x241b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2e80
movq -0x48(%rbp), %rdi
callq 0x2160
nopw %cs:(%rax,%rax)
// File: theuni[P]libutreexo/crypto/sha256.cpp
// Function: (anonymous namespace)::sha256::Initialize(unsigned int*)
void inline Initialize(uint32_t* s)
{
    s[0] = 0x6a09e667ul;
    s[1] = 0xbb67ae85ul;
    s[2] = 0x3c6ef372ul;
    s[3] = 0xa54ff53aul;
    s[4] = 0x510e527ful;
    s[5] = 0x9b05688cul;
    s[6] = 0x1f83d9abul;
    s[7] = 0x5be0cd19ul;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x6a09e667, (%rax)     # imm = 0x6A09E667
movq -0x8(%rbp), %rax
movl $0xbb67ae85, 0x4(%rax)  # imm = 0xBB67AE85
movq -0x8(%rbp), %rax
movl $0x3c6ef372, 0x8(%rax)  # imm = 0x3C6EF372
movq -0x8(%rbp), %rax
movl $0xa54ff53a, 0xc(%rax)  # imm = 0xA54FF53A
movq -0x8(%rbp), %rax
movl $0x510e527f, 0x10(%rax) # imm = 0x510E527F
movq -0x8(%rbp), %rax
movl $0x9b05688c, 0x14(%rax) # imm = 0x9B05688C
movq -0x8(%rbp), %rax
movl $0x1f83d9ab, 0x18(%rax) # imm = 0x1F83D9AB
movq -0x8(%rbp), %rax
movl $0x5be0cd19, 0x1c(%rax) # imm = 0x5BE0CD19
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: theuni[P]libutreexo/crypto/sha256.cpp
// Function: CSHA256::Write(unsigned char const*, unsigned long)
CSHA256& CSHA256::Write(const unsigned char* data, size_t len)
{
    const unsigned char* end = data + len;
    size_t bufsize = bytes % 64;
    if (bufsize && bufsize + len >= 64) {
        // Fill the buffer, and process it.
        memcpy(buf + bufsize, data, 64 - bufsize);
        bytes += 64 - bufsize;
        data += 64 - bufsize;
        Transform(s, buf, 1);
        bufsize = 0;
    }
    if (end - data >= 64) {
        size_t blocks = (end - data) / 64;
        Transform(s, data, blocks);
        data += 64 * blocks;
        bytes += 64 * blocks;
    }
    if (end > data) {
        // Fill the buffer with what remains.
        memcpy(buf + bufsize, data, end - data);
        bytes += end - data;
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x60(%rax), %rax
andq $0x3f, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1cca
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
cmpq $0x40, %rax
jb 0x1cca
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
subq -0x28(%rbp), %rdx
callq 0x1090
movq -0x38(%rbp), %rdi
movl $0x40, %eax
subq -0x28(%rbp), %rax
addq 0x60(%rdi), %rax
movq %rax, 0x60(%rdi)
movl $0x40, %eax
subq -0x28(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x533ec(%rip), %rax     # 0x550a0
movq %rdi, %rsi
addq $0x20, %rsi
movl $0x1, %edx
callq *%rax
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x40, %rax
jl 0x1d2d
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl $0x40, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq 0x533a1(%rip), %rax     # 0x550a0
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq *%rax
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x6, %rcx
addq -0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x30(%rbp), %rcx
shlq $0x6, %rcx
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x1d6e
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x1090
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq %rdx, %rcx
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: theuni[P]libutreexo/crypto/sha256.cpp
// Function: CSHA256::Finalize(unsigned char*)
void CSHA256::Finalize(unsigned char hash[OUTPUT_SIZE])
{
    static const unsigned char pad[64] = {0x80};
    unsigned char sizedesc[8];
    WriteBE64(sizedesc, bytes << 3);
    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
    Write(sizedesc, 8);
    WriteBE32(hash, s[0]);
    WriteBE32(hash + 4, s[1]);
    WriteBE32(hash + 8, s[2]);
    WriteBE32(hash + 12, s[3]);
    WriteBE32(hash + 16, s[4]);
    WriteBE32(hash + 20, s[5]);
    WriteBE32(hash + 24, s[6]);
    WriteBE32(hash + 28, s[7]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
movq 0x60(%rax), %rsi
shlq $0x3, %rsi
callq 0x1e90
movq -0x20(%rbp), %rdi
movq 0x60(%rdi), %rax
andq $0x3f, %rax
movl $0x77, %edx
subq %rax, %rdx
andq $0x3f, %rdx
addq $0x1, %rdx
leaq 0x502d4(%rip), %rsi     # 0x520a0
callq 0x1c20
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x1c20
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl (%rax), %esi
callq 0x1ec0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movl 0x4(%rax), %esi
callq 0x1ec0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl 0x8(%rax), %esi
callq 0x1ec0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
movl 0xc(%rax), %esi
callq 0x1ec0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl 0x10(%rax), %esi
callq 0x1ec0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0x14, %rdi
movl 0x14(%rax), %esi
callq 0x1ec0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movl 0x18(%rax), %esi
callq 0x1ec0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0x1c, %rdi
movl 0x1c(%rax), %esi
callq 0x1ec0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: theuni[P]libutreexo/crypto/sha256.cpp
// Function: SHA256D64(unsigned char*, unsigned char const*, unsigned long)
void SHA256D64(unsigned char* out, const unsigned char* in, size_t blocks)
{
    if (TransformD64_8way) {
        while (blocks >= 8) {
            TransformD64_8way(out, in);
            out += 256;
            in += 512;
            blocks -= 8;
        }
    }
    if (TransformD64_4way) {
        while (blocks >= 4) {
            TransformD64_4way(out, in);
            out += 128;
            in += 256;
            blocks -= 4;
        }
    }
    if (TransformD64_2way) {
        while (blocks >= 2) {
            TransformD64_2way(out, in);
            out += 64;
            in += 128;
            blocks -= 2;
        }
    }
    while (blocks) {
        TransformD64(out, in);
        out += 32;
        in += 64;
        --blocks;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x5318c(%rip)     # 0x550c8
je 0x1f84
jmp 0x1f40
cmpq $0x8, -0x18(%rbp)
jb 0x1f82
movq 0x5317a(%rip), %rax     # 0x550c8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x1f40
jmp 0x1f84
cmpq $0x0, 0x53134(%rip)     # 0x550c0
je 0x1fd4
jmp 0x1f90
cmpq $0x4, -0x18(%rbp)
jb 0x1fd2
movq 0x53122(%rip), %rax     # 0x550c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x1f90
jmp 0x1fd4
cmpq $0x0, 0x530dc(%rip)     # 0x550b8
je 0x2022
jmp 0x1fe0
cmpq $0x2, -0x18(%rbp)
jb 0x2020
movq 0x530ca(%rip), %rax     # 0x550b8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x1fe0
jmp 0x2022
jmp 0x2024
cmpq $0x0, -0x18(%rbp)
je 0x2062
movq 0x53076(%rip), %rax     # 0x550a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2024
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: theuni[P]libutreexo/crypto/sha256.cpp
// Function: (anonymous namespace)::sha256::Round(unsigned int, unsigned int, unsigned int, unsigned int&, unsigned int, unsigned int, unsigned int, unsigned int&, unsigned int)
void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t& d, uint32_t e, uint32_t f, uint32_t g, uint32_t& h, uint32_t k)
{
    uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
    uint32_t t2 = Sigma0(a) + Maj(a, b, c);
    d += t1;
    h = t1 + t2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq 0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %edi
callq 0x4a60
movl %eax, %ecx
movl -0x34(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movl 0x10(%rbp), %edx
callq 0x4aa0
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl %ecx, %eax
addl 0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %edi
callq 0x4ac0
movl %eax, -0x2c(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x4b00
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movq 0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: theuni[P]libutreexo/crypto/sha256_avx2.cpp
// Function: sha256d64_avx2::(anonymous namespace)::Write8(unsigned char*, int, long long vector[4])
void inline Write8(unsigned char* out, int offset, __m256i v) {
    v = _mm256_shuffle_epi8(v, _mm256_set_epi32(0x0C0D0E0FUL, 0x08090A0BUL, 0x04050607UL, 0x00010203UL, 0x0C0D0E0FUL, 0x08090A0BUL, 0x04050607UL, 0x00010203UL));
    WriteLE32(out + 0 + offset, _mm256_extract_epi32(v, 7));
    WriteLE32(out + 32 + offset, _mm256_extract_epi32(v, 6));
    WriteLE32(out + 64 + offset, _mm256_extract_epi32(v, 5));
    WriteLE32(out + 96 + offset, _mm256_extract_epi32(v, 4));
    WriteLE32(out + 128 + offset, _mm256_extract_epi32(v, 3));
    WriteLE32(out + 160 + offset, _mm256_extract_epi32(v, 2));
    WriteLE32(out + 192 + offset, _mm256_extract_epi32(v, 1));
    WriteLE32(out + 224 + offset, _mm256_extract_epi32(v, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xe0, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
movl $0xc0d0e0f, 0x7c(%rsp)  # imm = 0xC0D0E0F
movl $0x8090a0b, 0x78(%rsp)  # imm = 0x8090A0B
movl $0x4050607, 0x74(%rsp)  # imm = 0x4050607
movl $0x10203, 0x70(%rsp)    # imm = 0x10203
movl $0xc0d0e0f, 0x6c(%rsp)  # imm = 0xC0D0E0F
movl $0x8090a0b, 0x68(%rsp)  # imm = 0x8090A0B
movl $0x4050607, 0x64(%rsp)  # imm = 0x4050607
movl $0x10203, 0x60(%rsp)    # imm = 0x10203
movl 0x64(%rsp), %r8d
movl 0x68(%rsp), %edi
movl 0x6c(%rsp), %esi
movl 0x74(%rsp), %edx
movl 0x78(%rsp), %ecx
movl 0x7c(%rsp), %eax
vmovd 0x60(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm0
vmovd 0x70(%rsp), %xmm2
vpinsrd $0x1, %edx, %xmm2, %xmm2
vpinsrd $0x2, %ecx, %xmm2, %xmm2
vpinsrd $0x3, %eax, %xmm2, %xmm2
vmovdqa %xmm2, 0x50(%rsp)
vmovdqa %xmm0, 0x40(%rsp)
vmovaps 0x40(%rsp), %ymm0
vmovaps %ymm1, 0xa0(%rsp)
vmovaps %ymm0, 0x80(%rsp)
vmovaps 0xa0(%rsp), %ymm0
vmovaps 0x80(%rsp), %ymm1
vpshufb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
movq 0x38(%rsp), %rdi
movslq 0x34(%rsp), %rax
addq %rax, %rdi
movl 0x1c(%rsp), %esi
vzeroupper
callq 0x286a0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
leaq 0x20(%rax,%rcx), %rdi
movl 0x18(%rsp), %esi
callq 0x286a0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
leaq 0x40(%rax,%rcx), %rdi
movl 0x14(%rsp), %esi
callq 0x286a0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
leaq 0x60(%rax,%rcx), %rdi
movl 0x10(%rsp), %esi
callq 0x286a0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
leaq 0x80(%rax,%rcx), %rdi
movl 0xc(%rsp), %esi
callq 0x286a0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
leaq 0xa0(%rax,%rcx), %rdi
movl 0x8(%rsp), %esi
callq 0x286a0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
leaq 0xc0(%rax,%rcx), %rdi
movl 0x4(%rsp), %esi
callq 0x286a0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
leaq 0xe0(%rax,%rcx), %rdi
movl (%rsp), %esi
callq 0x286a0
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)