LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: void rapidxml::xml_document<char>::parse<0>(char*)
void parse(Ch *text)
        {
            assert(text);
            
            // Remove current contents
            this->remove_all_nodes();
            this->remove_all_attributes();
            
            // Parse BOM, if any
            parse_bom<Flags>(text);
            
            // Parse children
            while (1)
            {
                // Skip whitespace before node
                skip<whitespace_pred, Flags>(text);
                if (*text == 0)
                    break;

                // Parse and append new child
                if (*text == Ch('<'))
                {
                    ++text;     // Skip '<'
                    if (xml_node<Ch> *node = parse_node<Flags>(text))
                        this->append_node(node);
                }
                else
                    RAPIDXML_PARSE_ERROR("expected <", text);
            }

        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, -0x20(%rbp)
testq %rsi, %rsi
je 0x418b
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x40b3
movq $0x0, 0x20(%rax)
movq 0x58(%rax), %rax
jmp 0x40a0
movq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x40d2
movq $0x0, 0x20(%rax)
movq 0x30(%rax), %rax
jmp 0x40bf
movq $0x0, 0x40(%rbx)
cmpb $-0x11, (%rsi)
jne 0x40f3
cmpb $-0x45, 0x1(%rsi)
jne 0x40f3
cmpb $-0x41, 0x2(%rsi)
jne 0x40f3
addq $0x3, %rsi
movq %rsi, -0x20(%rbp)
leaq 0x2536(%rip), %r15      # 0x6630
leaq -0x20(%rbp), %r14
movq %rsi, %rax
movzbl (%rsi), %ecx
incq %rsi
cmpb $0x0, (%rcx,%r15)
jne 0x40fe
movq %rax, -0x20(%rbp)
movzbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x413f
movq %rsi, -0x20(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4646
testq %rax, %rax
je 0x4139
movq %rbx, %rdi
movq %rax, %rsi
callq 0x480e
movq -0x20(%rbp), %rsi
jmp 0x40fe
testl %eax, %eax
jne 0x414e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x20d0
movq -0x20(%rbp), %rcx
leaq 0x4c1d(%rip), %rdx      # 0x8d80
movq %rdx, (%rax)
leaq 0x2252(%rip), %rdx      # 0x63bf
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x4bdc(%rip), %rsi      # 0x8d58
movq 0x4e55(%rip), %rdx      # 0x8fd8
movq %rax, %rdi
callq 0x2330
leaq 0x21ce(%rip), %rdi      # 0x6360
leaq 0x21cc(%rip), %rsi      # 0x6365
leaq 0x21dd(%rip), %rcx      # 0x637d
movl $0x567, %edx            # imm = 0x567
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>::first_node(char const*, unsigned long, bool) const
xml_node<Ch> *first_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *child = m_first_node; child; child = child->next_sibling())
                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
                        return child;
                return 0;
            }
            else
                return m_first_node;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x4268
testq %rdx, %rdx
jne 0x41d4
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%rsi,%rax)
movq %rdx, %rax
jne 0x41c6
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4264
leaq 0x501b(%rip), %rdi      # 0x9203
leaq 0x2b41(%rip), %r8       # 0x6d30
movq (%rax), %r10
testq %r10, %r10
je 0x4200
movq %r10, %r9
movq 0x10(%rax), %r10
jmp 0x4203
movq %rdi, %r9
cmpq %rdx, %r10
jne 0x4254
leaq (%r9,%rdx), %r10
testb %cl, %cl
je 0x422d
testq %rdx, %rdx
jle 0x426c
movq %rsi, %r11
movb (%r9), %bl
cmpb (%r11), %bl
jne 0x4254
incq %r9
incq %r11
cmpq %r10, %r9
jb 0x4218
jmp 0x426c
testq %rdx, %rdx
jle 0x426c
movq %rsi, %r11
movzbl (%r9), %ebx
movb (%rbx,%r8), %bl
movzbl (%r11), %r14d
cmpb (%r14,%r8), %bl
jne 0x4254
incq %r9
incq %r11
cmpq %r10, %r9
jb 0x4235
jmp 0x426c
cmpq $0x0, 0x20(%rax)
je 0x4271
movq 0x58(%rax), %rax
testq %rax, %rax
jne 0x41ef
xorl %eax, %eax
jmp 0x426c
movq 0x30(%rdi), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x230b(%rip), %rdi      # 0x6583
leaq 0x20e6(%rip), %rsi      # 0x6365
leaq 0x230c(%rip), %rcx      # 0x6592
movl $0x3ee, %edx            # imm = 0x3EE
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>::first_attribute(char const*, unsigned long, bool) const
xml_attribute<Ch> *first_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_attribute<Ch> *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute)
                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
                        return attribute;
                return 0;
            }
            else
                return m_first_attribute;
        }

// Assembly:
testq %rsi, %rsi
je 0x434a
testq %rdx, %rdx
jne 0x42b3
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%rsi,%rax)
movq %rdx, %rax
jne 0x42a5
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x434f
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x4f35(%rip), %rdi      # 0x9203
leaq 0x2a5b(%rip), %r8       # 0x6d30
movq (%rax), %r10
testq %r10, %r10
je 0x42e6
movq %r10, %r9
movq 0x10(%rax), %r10
jmp 0x42e9
movq %rdi, %r9
cmpq %rdx, %r10
jne 0x433a
leaq (%r9,%rdx), %r10
testb %cl, %cl
je 0x4313
testq %rdx, %rdx
jle 0x4345
movq %rsi, %r11
movb (%r9), %bl
cmpb (%r11), %bl
jne 0x433a
incq %r9
incq %r11
cmpq %r10, %r9
jb 0x42fe
jmp 0x4345
testq %rdx, %rdx
jle 0x4345
movq %rsi, %r11
movzbl (%r9), %ebx
movb (%rbx,%r8), %bl
movzbl (%r11), %r14d
cmpb (%r14,%r8), %bl
jne 0x433a
incq %r9
incq %r11
cmpq %r10, %r9
jb 0x431b
jmp 0x4345
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0x42d5
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40(%rdi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::clear()
void clear()
        {
            while (m_begin != m_static_memory)
            {
                char *previous_begin = reinterpret_cast<header *>(align(m_begin))->previous_begin;
                if (m_free_func)
                    m_free_func(m_begin);
                else
                    delete[] m_begin;
                m_begin = previous_begin;
            }
            init();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq (%rdi), %rdi
cmpq %r14, %rdi
je 0x4396
movl %edi, %eax
negl %eax
andl $0x7, %eax
movq (%rdi,%rax), %r15
movq 0x10020(%rbx), %rax
testq %rax, %rax
je 0x4386
callq *%rax
jmp 0x438b
callq 0x2280
movq %r15, (%rbx)
movq %r15, %rdi
cmpq %r14, %r15
jne 0x436b
movq %r14, (%rbx)
movq %r14, 0x8(%rbx)
leaq 0x10018(%rbx), %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>::append_node(rapidxml::xml_node<char>*)
void append_node(xml_node<Ch> *child)
        {
            assert(child && !child->parent() && child->type() != node_document);
            if (first_node())
            {
                child->m_prev_sibling = m_last_node;
                m_last_node->m_next_sibling = child;
            }
            else
            {
                child->m_prev_sibling = 0;
                m_first_node = child;
            }
            m_last_node = child;
            child->m_parent = this;
            child->m_next_sibling = 0;
        }

// Assembly:
testq %rsi, %rsi
je 0x4853
cmpq $0x0, 0x20(%rsi)
jne 0x4853
cmpl $0x0, 0x28(%rsi)
je 0x4853
leaq 0x30(%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rdx
leaq 0x58(%rdx), %r8
testq %rcx, %rcx
cmoveq %rax, %r8
cmoveq %rcx, %rdx
movq %rsi, (%r8)
movq %rdx, 0x50(%rsi)
movq %rsi, 0x38(%rdi)
movq %rdi, 0x20(%rsi)
movq $0x0, 0x58(%rsi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1ca6(%rip), %rdi      # 0x6504
leaq 0x1b00(%rip), %rsi      # 0x6365
leaq 0x1cd4(%rip), %rcx      # 0x6540
movl $0x44b, %edx            # imm = 0x44B
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_xml_declaration<0>(char*&)
xml_node<Ch> *parse_xml_declaration(Ch *&text)
        {
            // If parsing of declaration is disabled
            if (!(Flags & parse_declaration_node))
            {
                // Skip until end of declaration
                while (text[0] != Ch('?') || text[1] != Ch('>'))
                {
                    if (!text[0])
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 2;    // Skip '?>'
                return 0;
            }

            // Create declaration
            xml_node<Ch> *declaration = this->allocate_node(node_declaration);

            // Skip whitespace before attributes or ?>
            skip<whitespace_pred, Flags>(text);

            // Parse declaration attributes
            parse_node_attributes<Flags>(text, declaration);
            
            // Skip ?>
            if (text[0] != Ch('?') || text[1] != Ch('>'))
                RAPIDXML_PARSE_ERROR("expected ?>", text);
            text += 2;
            
            return declaration;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x3f, %ecx
je 0x49f4
testl %ecx, %ecx
jne 0x49f9
jmp 0x4a0d
cmpb $0x3e, (%rax)
je 0x49fe
movq %rax, (%rbx)
jmp 0x49e2
incq %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x18, %edi
callq 0x20d0
movq (%rbx), %rcx
leaq 0x435f(%rip), %rdx      # 0x8d80
movq %rdx, (%rax)
leaq 0x199f(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x431e(%rip), %rsi      # 0x8d58
movq 0x4597(%rip), %rdx      # 0x8fd8
movq %rax, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_comment<0>(char*&)
xml_node<Ch> *parse_comment(Ch *&text)
        {
            // If parsing of comments is disabled
            if (!(Flags & parse_comment_nodes))
            {
                // Skip until end of comment
                while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
                {
                    if (!text[0])
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 3;     // Skip '-->'
                return 0;      // Do not produce comment node
            }

            // Remember value start
            Ch *value = text;

            // Skip until end of comment
            while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
            {
                if (!text[0])
                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                ++text;
            }

            // Create comment node
            xml_node<Ch> *comment = this->allocate_node(node_comment);
            comment->value(value, text - value);
            
            // Place zero terminator after comment value
            if (!(Flags & parse_no_string_terminators))
                *text = Ch('\0');
            
            text += 3;     // Skip '-->'
            return comment;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x2d, %ecx
je 0x4adc
testl %ecx, %ecx
jne 0x4ae7
jmp 0x4afc
cmpb $0x2d, (%rax)
jne 0x4ae7
cmpb $0x3e, 0x1(%rax)
je 0x4aec
movq %rax, (%rbx)
jmp 0x4aca
addq $0x2, %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x18, %edi
callq 0x20d0
movq (%rbx), %rcx
leaq 0x4270(%rip), %rdx      # 0x8d80
movq %rdx, (%rax)
leaq 0x18b0(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x422f(%rip), %rsi      # 0x8d58
movq 0x44a8(%rip), %rdx      # 0x8fd8
movq %rax, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_cdata<0>(char*&)
xml_node<Ch> *parse_cdata(Ch *&text)
        {
            // If CDATA is disabled
            if (Flags & parse_no_data_nodes)
            {
                // Skip until end of cdata
                while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
                {
                    if (!text[0])
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 3;      // Skip ]]>
                return 0;       // Do not produce CDATA node
            }

            // Skip until end of cdata
            Ch *value = text;
            while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
            {
                if (!text[0])
                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                ++text;
            }

            // Create new cdata node
            xml_node<Ch> *cdata = this->allocate_node(node_cdata);
            cdata->value(value, text - value);

            // Place zero terminator after value
            if (!(Flags & parse_no_string_terminators))
                *text = Ch('\0');

            text += 3;      // Skip ]]>
            return cdata;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %r14
leaq 0x1(%r14), %rax
movzbl -0x1(%rax), %ecx
cmpl $0x5d, %ecx
je 0x4b58
testl %ecx, %ecx
jne 0x4b63
jmp 0x4bb1
cmpb $0x5d, (%rax)
jne 0x4b63
cmpb $0x3e, 0x1(%rax)
je 0x4b6b
movq %rax, (%rbx)
incq %rax
jmp 0x4b49
addq $0x60, %rdi
movl $0x60, %esi
callq 0x4ff0
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x3, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rcx, 0x40(%rax)
movq (%rbx), %rcx
subq %r14, %rcx
movq %r14, 0x8(%rax)
movq %rcx, 0x18(%rax)
movq (%rbx), %rcx
movb $0x0, (%rcx)
addq $0x3, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x18, %edi
callq 0x20d0
movq (%rbx), %rcx
leaq 0x41bb(%rip), %rdx      # 0x8d80
movq %rdx, (%rax)
leaq 0x17fb(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x417a(%rip), %rsi      # 0x8d58
movq 0x43f3(%rip), %rdx      # 0x8fd8
movq %rax, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::allocate_raw(unsigned long)
char *allocate_raw(std::size_t size)
        {
            // Allocate
            void *memory;   
            if (m_alloc_func)   // Allocate memory using either user-specified allocation function or global operator new[]
            {
                memory = m_alloc_func(size);
                assert(memory); // Allocator is not allowed to return 0, on failure it must either throw, stop the program or use longjmp
            }
            else
            {
                memory = new char[size];
#ifdef RAPIDXML_NO_EXCEPTIONS
                if (!memory)            // If exceptions are disabled, verify memory allocation, because new will not be able to throw bad_alloc
                    RAPIDXML_PARSE_ERROR("out of memory", 0);
#endif
            }
            return static_cast<char *>(memory);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10018(%rdi), %rax
movq %rsi, %rdi
testq %rax, %rax
je 0x5096
callq *%rax
testq %rax, %rax
je 0x509c
popq %rbp
retq
popq %rbp
jmp 0x2030
leaq 0x135f(%rip), %rdi      # 0x6402
leaq 0x12bb(%rip), %rsi      # 0x6365
leaq 0x1358(%rip), %rcx      # 0x6409
movl $0x24a, %edx            # imm = 0x24A
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x50fb
cmpq $0x0, 0x20(%rsi)
jne 0x50fb
leaq 0x40(%rdi), %rax
movq 0x40(%rdi), %rcx
movq 0x48(%rdi), %rdx
leaq 0x30(%rdx), %r8
testq %rcx, %rcx
cmoveq %rax, %r8
cmoveq %rcx, %rdx
movq %rsi, (%r8)
movq %rdx, 0x28(%rsi)
movq %rsi, 0x48(%rdi)
movq %rdi, 0x20(%rsi)
movq $0x0, 0x30(%rsi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1363(%rip), %rdi      # 0x6469
leaq 0x1258(%rip), %rsi      # 0x6365
leaq 0x1377(%rip), %rcx      # 0x648b
movl $0x4c3, %edx            # imm = 0x4C3
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movl %edx, %r12d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movl $0x58, %eax
leaq (%rbx,%rax), %rcx
movq %rcx, -0x10(%rbx,%rax)
movq $0x0, -0x8(%rbx,%rax)
movb $0x0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0xd8, %rax
jne 0x5c42
movq %rbx, %rdi
callq 0x20f0
movl %r12d, 0x20(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x20f0
leaq 0x48(%rbx), %r15
movb $0x0, 0xcc(%rbx)
movl $0x4, %r13d
leaq 0x3de(%rip), %r12       # 0x6071
movq 0x8(%r15), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x22e0
addq $0x20, %r15
decq %r13
jne 0x5c93
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5cc1
movq %rax, %r15
movl $0xb8, %r12d
leaq (%rbx,%r12), %rax
movq -0x10(%rbx,%r12), %rdi
cmpq %rdi, %rax
je 0x5ce3
movq (%rax), %rsi
incq %rsi
callq 0x2200
addq $-0x20, %r12
cmpq $0x38, %r12
jne 0x5cca
movq (%r14), %rdi
cmpq -0x30(%rbp), %rdi
je 0x5d05
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x5d1d
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq %r15, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x3, %esi
jbe 0x5d9a
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %eax
shlq $0x5, %rax
leaq (%rdi,%rax), %r14
addq $0x48, %r14
leaq 0x2b8(%rip), %rsi       # 0x6071
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x5dc9
xorl %eax, %eax
jmp 0x5dd6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x40e0
testl %eax, %eax
js 0x93f1
movl %eax, %ebx
leaq 0x4(%rsp), %rdx
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, (%rdx)
movl $0x30303030, 0x8(%rdx)  # imm = 0x30303030
movw $0x2, -0x4(%rdx)
rolw $0x8, %bp
movw %bp, -0x2(%rdx)
movq (%r14), %rsi
movl $0x2, %edi
callq 0x4630
testl %eax, %eax
jle 0x93fa
movq %rsp, %rsi
movl %ebx, %edi
movl $0x10, %edx
callq 0x42b0
testl %eax, %eax
jns 0x940b
leaq 0x4105(%rip), %rdi      # 0xd4f4
jmp 0x9401
leaq 0x4139(%rip), %rdi      # 0xd531
jmp 0x9401
leaq 0x4107(%rip), %rdi      # 0xd508
callq 0x44f0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
leaq 0x34(%rsp), %r12
movl %r8d, (%r12)
movq 0x8b94(%rip), %r13      # 0x11fd0
leaq 0x3fc5(%rip), %rsi      # 0xd408
movl $0x15, %edx
movq %r13, %rdi
callq 0x43c0
leaq 0x3fc7(%rip), %rsi      # 0xd41e
movl $0x18, %edx
movq %r13, %rdi
callq 0x43c0
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8f24(%rip), %rax      # 0x12398
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x74cc
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
movl 0x8(%r13), %eax
movl %eax, 0xc(%rsp)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsp)
movl $0x4, %edx
movl %ebx, %edi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x41c0
movq (%r15), %rsi
movl $0x14, %edx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41c0
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41c0
movq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41c0
leaq 0x8e91(%rip), %rsi      # 0x12390
movl $0x4, %edx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41c0
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41c0
movq (%r14), %rsi
movslq 0x8(%rsp), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41c0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x9548
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4350
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9564
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4350
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x958d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4350
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x95a9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4350
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
movl %esi, %eax
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x14, %edx
movl %eax, %edi
callq 0x44a0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
cmpl $0x14, %eax
jne 0x95f2
movq %rsp, %r14
movq %r14, %rdi
callq 0x41a0
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x9603
leaq 0x3e0c(%rip), %rsi      # 0xd405
leaq 0x3e07(%rip), %rdx      # 0xd407
movq %rbx, %rdi
callq 0x7562
movq %rbx, %rax
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x40e0
testl %eax, %eax
js 0xa415
movl %eax, %ebx
leaq 0x4(%rsp), %rdx
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, (%rdx)
movl $0x30303030, 0x8(%rdx)  # imm = 0x30303030
movw $0x2, -0x4(%rdx)
movl %ebp, %eax
rolw $0x8, %ax
movw %ax, -0x2(%rdx)
movq (%r14), %rsi
movl $0x2, %edi
callq 0x4630
testl %eax, %eax
jle 0xa41e
movq %rsp, %rsi
movl %ebx, %edi
movl $0x10, %edx
callq 0x42b0
testl %eax, %eax
js 0xa427
leaq 0x855c(%rip), %r15      # 0x12900
movq %r15, %rdi
callq 0x4210
movq 0x7c1d(%rip), %r12      # 0x11fd0
leaq 0x307d(%rip), %rsi      # 0xd437
movl $0x1a, %edx
movq %r12, %rdi
callq 0x43c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x43c0
movq %rax, %r14
leaq 0x2d12(%rip), %rsi      # 0xd0f2
movl $0x1, %edx
movq %rax, %rdi
callq 0x43c0
movq %r14, %rdi
movl %ebp, %esi
callq 0x45b0
leaq 0x2fe8(%rip), %rsi      # 0xd3e6
movl $0x1, %edx
movq %rax, %rdi
callq 0x43c0
movq %r15, %rdi
callq 0x4580
jmp 0xa438
leaq 0x3115(%rip), %rdi      # 0xd531
jmp 0xa42e
leaq 0x30e3(%rip), %rdi      # 0xd508
jmp 0xa42e
leaq 0x30c6(%rip), %rdi      # 0xd4f4
callq 0x44f0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movl $0x1, 0xc(%rsp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x40e0
testl %eax, %eax
jne 0xb5a7
leaq 0x210e(%rip), %rdi      # 0xd6b3
jmp 0xb60c
movl %eax, %ebx
leaq 0xc(%rsp), %rcx
movl %eax, %edi
movl $0x1, %esi
movl $0xf, %edx
movl $0x4, %r8d
callq 0x45e0
testl %eax, %eax
jne 0xb605
leaq 0x10(%rsp), %rsi
movw $0x2, (%rsi)
movl $0x0, 0x4(%rsi)
leaq 0x6daf(%rip), %rax      # 0x12390
movzwl (%rax), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rsi)
movl %ebx, %edi
movl $0x10, %edx
callq 0x4090
testl %eax, %eax
jns 0xb61b
leaq 0x20c9(%rip), %rdi      # 0xd6cc
jmp 0xb60c
leaq 0x20b5(%rip), %rdi      # 0xd6c1
callq 0x42c0
movl $0x1, %edi
callq 0x4400
movl %ebx, %edi
movl $0x3, %esi
callq 0x4390
testl %eax, %eax
jns 0xb634
leaq 0x20a6(%rip), %rdi      # 0xd6d8
jmp 0xb60c
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %edi
callq 0xb645
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x4(%rsp), %r15
movl $0x10, (%r15)
leaq 0x2085(%rip), %rdi      # 0xd6f9
callq 0x44f0
leaq 0x208e(%rip), %rdi      # 0xd70e
callq 0x44f0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4150
testl %eax, %eax
js 0xb6ec
movl %eax, %ebp
movq %rsp, %r14
leaq 0x206c(%rip), %r15      # 0xd70e
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movl $0x4, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x44a0
cmpl $0x1, (%rsp)
jne 0xb6ca
movl %ebp, %edi
callq 0xb702
jmp 0xb6d1
movl %ebp, %edi
callq 0xb884
movq %r15, %rdi
callq 0x44f0
movl %ebx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4150
movl %eax, %ebp
testl %eax, %eax
jns 0xb6ac
leaq 0x1fec(%rip), %rdi      # 0xd6df
callq 0x42c0
movl $0x1, %edi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebx
callq 0x4100
testl %eax, %eax
je 0xb737
movq 0x68b3(%rip), %rdi      # 0x11fd0
leaq 0x1fc2(%rip), %rsi      # 0xd6e6
movl $0x12, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x43c0
leaq 0x1fe0(%rip), %rdi      # 0xd71e
callq 0x44f0
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
movl %ebx, %edi
callq 0x44a0
leaq 0x50(%rsp), %r14
movl $0x14, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x44a0
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x41a0
leaq (%rsp,%rax), %rdx
addq $0x50, %rdx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x7562
leaq 0x6ca3(%rip), %rdi      # 0x12438
leaq 0x10(%rsp), %rsi
callq 0xbb9a
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x74cc
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xb7d3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4350
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41c0
movl $0x0, 0x8(%rsp)
movslq 0xc(%rsp), %rax
testq %rax, %rax
jle 0xb815
xorl %ecx, %ecx
movq 0x30(%rsp), %rdx
xorl %esi, %esi
cmpb $0x30, (%rdx,%rcx)
je 0xb80d
incl %esi
movl %esi, 0x8(%rsp)
incq %rcx
cmpq %rcx, %rax
jne 0xb801
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41c0
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
movl %ebx, %edi
callq 0x44a0
movl %ebx, %edi
callq 0x4670
xorl %edi, %edi
callq 0x4400
jmp 0xb849
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0xb87c
movq 0x40(%rsp), %rsi
jmp 0xb86f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xb87c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4350
jmp 0xb87c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movl %edi, %ebp
movslq %edi, %rdi
callq 0x4030
movq %rax, %r14
testl %r15d, %r15d
je 0xbb02
testl %ebp, %ebp
jle 0xbb15
movl %ebp, %edx
movq %r14, %rdi
movl $0x31, %esi
jmp 0xbb10
testl %ebp, %ebp
jle 0xbb15
movl %ebp, %edx
movq %r14, %rdi
movl $0x30, %esi
callq 0x4200
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x41a0
movq %r14, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7562
leaq 0x68f8(%rip), %rdi      # 0x12438
movq %rbx, %rsi
callq 0xa6a0
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4410
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xbb6d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4350
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xbb92
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4350
movq %rbx, %rdi
callq 0x45d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x28, %edi
callq 0x20d0
movq %rax, %r14
leaq -0x48(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x28ae
movzwl 0x20(%r15), %r13d
movq %r14, %rax
addq $0x10, %rax
movq %rax, (%r14)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r15b
movq %r14, %rdi
callq 0x28ae
movw %r13w, 0x20(%r14)
leaq -0x30(%rbp), %rdi
movq %r14, -0x8(%rdi)
xorl %r15d, %r15d
movq %r14, %rsi
callq 0x294c
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x234e
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x20e0
movq 0x2c83(%rip), %rdi      # 0x4fd8
leaq 0xca8(%rip), %rsi       # 0x3004
movl $0x11, %edx
callq 0x20f0
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x2377
movl 0x8(%rax), %eax
movslq %eax, %rsi
jmp 0x2379
xorl %esi, %esi
movq 0x2c58(%rip), %rdi      # 0x4fd8
callq 0x20b0
movq %rax, %r14
leaq 0xc87(%rip), %rsi       # 0x3016
movl $0x1, %edx
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2060
movq -0x38(%rbp), %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x28ae
movzwl 0x20(%r14), %eax
movw %ax, 0x20(%rbx)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x23f7
callq 0x2834
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x242b
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x2426
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x20e0
testb %r15b, %r15b
je 0x244b
movl $0x28, %esi
movq %r14, %rdi
callq 0x20e0
jmp 0x244b
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x244b
callq 0x2834
movq %rbx, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq (%rsi,%rdx), %r14
movq 0x60(%rdi), %rbp
andq $0x3f, %rbp
je 0x181c
addq %rbp, %rdx
cmpq $0x40, %rdx
jb 0x181e
leaq 0x20(%rbx), %r12
leaq (%rbx,%rbp), %rdi
addq $0x20, %rdi
movl $0x40, %r13d
subq %rbp, %r13
movq %r15, %rsi
movq %r13, %rdx
callq 0x1060
addq %r13, 0x60(%rbx)
addq %r13, %r15
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq *0x2985c(%rip)          # 0x2b078
xorl %ebp, %ebp
movq %r14, %r12
subq %r15, %r12
cmpq $0x40, %r12
jl 0x1851
movq %r12, %rdx
shrq $0x6, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x2983b(%rip)          # 0x2b078
movabsq $0x7fffffffffffffc0, %rax # imm = 0x7FFFFFFFFFFFFFC0
andq %r12, %rax
addq %rax, %r15
addq %rax, 0x60(%rbx)
subq %r15, %r14
jbe 0x186d
leaq (%rbx,%rbp), %rdi
addq $0x20, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1060
addq %r14, 0x60(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rax
leaq (,%rax,8), %rcx
bswapq %rcx
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
movl $0x37, %edx
subl %eax, %edx
andl $0x3f, %edx
incq %rdx
leaq 0x26856(%rip), %rsi     # 0x28110
callq 0x17bc
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x17bc
movl (%r14), %eax
bswapl %eax
movl %eax, (%rbx)
movl 0x4(%r14), %eax
bswapl %eax
movl %eax, 0x4(%rbx)
movl 0x8(%r14), %eax
bswapl %eax
movl %eax, 0x8(%rbx)
movl 0xc(%r14), %eax
bswapl %eax
movl %eax, 0xc(%rbx)
movl 0x10(%r14), %eax
bswapl %eax
movl %eax, 0x10(%rbx)
movl 0x14(%r14), %eax
bswapl %eax
movl %eax, 0x14(%rbx)
movl 0x18(%r14), %eax
bswapl %eax
movl %eax, 0x18(%rbx)
movl 0x1c(%r14), %eax
bswapl %eax
movl %eax, 0x1c(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x8, %rdx
jb 0x1982
cmpq $0x0, 0x2974b(%rip)     # 0x2b0a8
je 0x1982
movq %r15, %rdi
movq %r14, %rsi
callq 0xa8cc
addq $0x100, %r15            # imm = 0x100
addq $0x200, %r14            # imm = 0x200
addq $-0x8, %rbx
cmpq $0x7, %rbx
ja 0x195f
cmpq $0x4, %rbx
jb 0x19b2
cmpq $0x0, 0x29710(%rip)     # 0x2b0a0
je 0x19b2
movq %r15, %rdi
movq %r14, %rsi
callq 0x1810c
subq $-0x80, %r15
addq $0x100, %r14            # imm = 0x100
addq $-0x4, %rbx
cmpq $0x3, %rbx
ja 0x1992
cmpq $0x2, %rbx
jb 0x19df
cmpq $0x0, 0x296d8(%rip)     # 0x2b098
je 0x19df
movq %r15, %rdi
movq %r14, %rsi
callq 0x16472
addq $0x40, %r15
subq $-0x80, %r14
addq $-0x2, %rbx
cmpq $0x1, %rbx
ja 0x19c2
testq %rbx, %rbx
je 0x19fd
movq %r15, %rdi
movq %r14, %rsi
callq *0x29690(%rip)          # 0x2b080
addq $0x20, %r15
addq $0x40, %r14
decq %rbx
jne 0x19e4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/bsaikiran618[P]mandelbrot-set-viewer/Window.cpp
// Function: Window::drawAxes(Cartesian2DPlane*)
void Window::drawAxes( Cartesian2DPlane *plane )
{
	Cartesian2DPoint leftExtreme	(double(0),	-1000,	plane);
	Cartesian2DPoint rightExtreme	(double(0),	1000,	plane);
	Cartesian2DPoint topExtreme		(double(1000), 0,		plane);
	Cartesian2DPoint bottomExtreme	(double(-1000),0, 	plane);

	SDL_SetRenderDrawColor(screenRenderer, 120,120,120,SDL_ALPHA_OPAQUE);
	//The X axis
	SDL_RenderDrawLine(screenRenderer, leftExtreme.getOnScreenX(), leftExtreme.getOnScreenY(),	
										rightExtreme.getOnScreenX(), rightExtreme.getOnScreenY());
	//The Y axis
	SDL_RenderDrawLine(screenRenderer, topExtreme.getOnScreenX(), topExtreme.getOnScreenY(),
										bottomExtreme.getOnScreenX(), bottomExtreme.getOnScreenY());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x90(%rbp), %r13
movsd 0x9de(%rip), %xmm1      # 0x3098
xorps %xmm0, %xmm0
movq %r13, %rdi
callq 0x2b50
leaq -0x78(%rbp), %rdi
movsd 0x9cf(%rip), %xmm1      # 0x30a0
xorps %xmm0, %xmm0
movq %rdi, %r12
movq %r14, %rsi
callq 0x2b50
leaq -0x60(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0x9b2(%rip), %xmm0      # 0x30a0
movq %r14, %rsi
callq 0x2b50
leaq -0x48(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0x993(%rip), %xmm0      # 0x3098
movq %r14, %rsi
callq 0x2b50
movq %rbx, -0x30(%rbp)
movq 0x10(%rbx), %rdi
movl $0x78, %esi
movl $0x78, %edx
movl $0x78, %ecx
movl $0xff, %r8d
callq 0x21c0
movq 0x10(%rbx), %r14
movq %r13, %rdi
callq 0x2c06
movq %rax, %r15
movq %r13, %rdi
callq 0x2c68
movq %rax, %r13
movq %r12, %rbx
movq %r12, %rdi
callq 0x2c06
movq %rax, %r12
movq %rbx, %rdi
callq 0x2c68
movq %r14, %rdi
movl %r15d, %esi
movl %r13d, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq 0x2080
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rbx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x2c06
movq %rax, %r14
movq %r15, %rdi
callq 0x2c68
movq %rax, %r15
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0x2c06
movq %rax, %r12
movq %r13, %rdi
callq 0x2c68
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq 0x2080
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bsaikiran618[P]mandelbrot-set-viewer/Window.cpp
// Function: Window::Window(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
Window::Window(std::string windowTitle, uint64_t flags)
{	
		if(SDL_Init(SDL_INIT_VIDEO) < 0) throw "Couldn't initialize SDL Video!";

		if((window = SDL_CreateWindow(windowTitle.c_str(), WINDOW_X, WINDOW_Y, SCREEN_W, SCREEN_H, flags)) == NULL)
			throw "Couldn't create SDL window!";

		//windowSurface = SDL_GetWindowSurface(window);

		if((screenRenderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED)) == NULL)
			throw "Couldn't create SDL Renderer!";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x20, %edi
callq 0x2130
testl %eax, %eax
js 0x29f1
movq (%r15), %rdi
movl $0x2fff0000, %esi       # imm = 0x2FFF0000
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x384, %ecx            # imm = 0x384
movl $0x384, %r8d            # imm = 0x384
movl %r14d, %r9d
callq 0x2040
movq %rax, (%rbx)
testq %rax, %rax
je 0x2a04
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x2030
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x2a17
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x20c0
leaq 0x6ec(%rip), %rcx       # 0x30ee
jmp 0x2a28
movl $0x8, %edi
callq 0x20c0
leaq 0x6f8(%rip), %rcx       # 0x310d
jmp 0x2a28
movl $0x8, %edi
callq 0x20c0
leaq 0x701(%rip), %rcx       # 0x3129
movq %rcx, (%rax)
movq 0x258e(%rip), %rsi      # 0x4fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2200