LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Bartor[P]kompilator/back/asm/InstructionList.cpp
// Function: InstructionList::seal(bool)
void InstructionList::seal(bool addHalt) {
    if (addHalt) instructions.push_back(new Halt());

    long long counter = 0;
    for (const auto &ins : instructions) { // instruction address resolution
        ins->setAddress(counter);
        if (!ins->stub) {
            counter++; // stubs use next instruction's address
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x14e62
leaq 0x8(%rbx), %r14
pushq $0x18
popq %rdi
callq 0x51c0
andq $0x0, 0x10(%rax)
orq $-0x1, 0x8(%rax)
leaq 0xae44(%rip), %rcx      # 0x1fc90
addq $0x10, %rcx
movq %rcx, (%rax)
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x14f94
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
xorl %ebx, %ebx
cmpq %r15, %r14
je 0x14e90
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq (%r14), %rax
movzbl 0x10(%rax), %eax
xorq $0x1, %rax
addq %rax, %rbx
addq $0x8, %r14
jmp 0x14e6c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/jgame.cpp
// Function: main
int main()
{
	bool lAgain = true;
	string lInput;
	while ( lAgain )
	{
		// start game
		Game * lJeopardy = new Game(5);

		cout << "Welcome to a new game of Jeopardy.\n\n";

		// while game not done continue playing
		while(lJeopardy->playing())
		{
			//Start by showing the board
			lJeopardy->showBoard();
			// updates the status (checks if the game is done)
			lJeopardy->updateStatus();
		}
		// when game is finished display the score
		lJeopardy->showScore();
		delete lJeopardy;
		// Play another game?
		cout << "Do you want to play again? [y/N] \n";
		cin >> lInput;
		if(lInput != "")
			lAgain = toupper(lInput[0]) == 'Y';
		else
			lAgain = false;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
pushq $0x18
popq %rbx
movq 0x79d9(%rip), %r15      # 0x9fc0
leaq -0x48(%rbp), %r12
leaq 0x3a7f(%rip), %r13      # 0x6071
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rax, %rdi
pushq $0x5
popq %rsi
callq 0x26f0
movq %r15, %rdi
leaq 0x39f2(%rip), %rsi      # 0x6004
callq 0x2210
movq %r14, %rdi
callq 0x322e
testb %al, %al
je 0x2635
movq %r14, %rdi
callq 0x2d28
movq %r14, %rdi
callq 0x3236
jmp 0x2617
movq %r14, %rdi
callq 0x31ea
movq %r14, %rdi
callq 0x2ce6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2230
movq %r15, %rdi
leaq 0x39cf(%rip), %rsi      # 0x6029
callq 0x2210
movq 0x796a(%rip), %rdi      # 0x9fd0
movq %r12, %rsi
callq 0x2290
movq %r12, %rdi
movq %r13, %rsi
callq 0x26d2
testb %al, %al
je 0x2692
movq -0x48(%rbp), %rax
movsbl (%rax), %edi
callq 0x23d0
cmpl $0x59, %eax
je 0x25f2
leaq -0x48(%rbp), %rdi
callq 0x20d0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x2230
jmp 0x26c1
jmp 0x26be
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/jgameClass.cpp
// Function: Game::Game(int)
Game::Game(int aSize)
{
	this->mScore = 0;
	this->mPlaying = true;
	this->mSize = aSize;
	this->mQuestionSet = new Question**[mSize];
	for(int lRow = 0; lRow < aSize; lRow++)
	{
		this->mQuestionSet[lRow] = new Question*[mSize];
	}
	loadQuestions();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
andl $0x0, 0x4(%rdi)
movb $0x1, (%rdi)
movl %esi, 0x8(%rdi)
movl %esi, %eax
shlq $0x3, %rax
xorl %r12d, %r12d
testl %esi, %esi
pushq $-0x1
popq %r15
cmovnsq %rax, %r15
cmovlel %r12d, %r14d
movq %r15, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
cmpq %r12, %r14
je 0x2748
movq %r15, %rdi
callq 0x2030
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x272e
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2758
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/jgameClass.cpp
// Function: Game::updateStatus()
int Game::updateStatus(void)
{
	bool lDone = true; // assume done
	// loop through the questionSet and see if they have all been played
	// for efficency, start with the high dollar/harder questions
	
	// loop through rows (bottom to top)
	for(int i = mSize-1; i >= 0; i--)
	{
		// loop through columns
		for(int j=0; j < mSize; j++)
		{
			// sets done to false if a question hasn't been played
			if( lDone && !mQuestionSet[j][i]->hasBeenPlayed() )
			{
				lDone = false;
			}
		}
	}
	mPlaying = !(lDone);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movb $0x1, %r14b
xorl %r15d, %r15d
movq %rax, %r12
testl %r12d, %r12d
jle 0x328f
decq %r12
xorl %r13d, %r13d
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x3253
testb $0x1, %r14b
je 0x328a
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r12,8), %rdi
callq 0x58d4
movzbl %r14b, %r14d
testb %al, %al
cmovel %r15d, %r14d
movl 0x8(%rbx), %eax
incq %r13
jmp 0x325e
notb %r14b
andb $0x1, %r14b
movb %r14b, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/./RapidXml/rapidxml_utils.hpp
// Function: rapidxml::file<char>::file(char const*)
file(const char *filename)
        {
            using namespace std;

            // Open stream
            basic_ifstream<Ch> stream(filename, ios::binary);
            if (!stream)
                throw runtime_error(string("cannot open file ") + filename);
            stream.unsetf(ios::skipws);
            
            // Determine stream size
            stream.seekg(0, ios::end);
            size_t size = stream.tellg();
            stream.seekg(0);   
            
            // Load data and add terminating 0
            m_data.resize(size + 1);
            stream.read(&m_data.front(), static_cast<streamsize>(size));
            m_data[size] = 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x270(%rbp), %rdi
pushq $0x4
popq %rdx
callq 0x23c0
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x3917
andb $-0x11, -0x257(%rbp,%rax)
leaq -0x270(%rbp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x22c0
leaq -0x270(%rbp), %rdi
callq 0x2380
movq %rax, %r14
leaq -0x270(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x3fc6
movq (%rbx), %rsi
leaq -0x270(%rbp), %rdi
movq %r14, %rdx
callq 0x2270
movq (%rbx), %rax
movb $0x0, (%rax,%r14)
leaq -0x270(%rbp), %rdi
callq 0x2060
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %r14
leaq 0x2a0b(%rip), %rsi      # 0x6334
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x376e
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %r15, %rdx
callq 0x3f9d
movb $0x1, %r12b
leaq -0x68(%rbp), %rsi
movq %r14, %rdi
callq 0x2330
xorl %r12d, %r12d
movq 0x6691(%rip), %rsi      # 0x9ff0
movq 0x6652(%rip), %rdx      # 0x9fb8
movq %r14, %rdi
callq 0x2360
movq %rax, %r15
leaq -0x68(%rbp), %rdi
callq 0x20d0
jmp 0x3982
movq %rax, %r15
movb $0x1, %r12b
leaq -0x48(%rbp), %rdi
callq 0x20d0
testb %r12b, %r12b
jne 0x3995
jmp 0x39ab
movq %rax, %r15
movq %r14, %rdi
callq 0x2180
jmp 0x39ab
jmp 0x39a8
jmp 0x39a8
movq %rax, %r15
jmp 0x39b7
movq %rax, %r15
leaq -0x270(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x3dd6
movq %r15, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, -0x18(%rbp)
testq %rsi, %rsi
je 0x3a7f
movq %rdi, %rbx
callq 0x4152
movq %rbx, %rdi
callq 0x4176
leaq -0x18(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x419a
movq %r14, %rdi
callq 0x41bc
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
cmpl $0x3c, %ecx
jne 0x3a37
incq %rax
movq %rax, -0x18(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41e0
testq %rax, %rax
je 0x39ff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a6
jmp 0x39ff
testl %ecx, %ecx
jne 0x3a44
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq -0x18(%rbp), %rcx
leaq 0x6329(%rip), %rdx      # 0x9d80
movq %rdx, (%rax)
leaq 0x295e(%rip), %rdx      # 0x63bf
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x62e8(%rip), %rsi      # 0x9d58
movq 0x6561(%rip), %rdx      # 0x9fd8
movq %rax, %rdi
callq 0x2360
leaq 0x28da(%rip), %rdi      # 0x6360
leaq 0x28d8(%rip), %rsi      # 0x6365
leaq 0x28e9(%rip), %rcx      # 0x637d
movl $0x567, %edx            # imm = 0x567
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
testq %rsi, %rsi
je 0x3b1c
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %rbx
testq %rdx, %rdx
jne 0x3acd
movq %rbx, %rdi
callq 0x4c33
movq %rax, %r14
movq 0x30(%r15), %r15
movzbl %r12b, %r12d
pushq $0x1
popq %r13
testq %r15, %r15
je 0x3b22
movq (%r15), %rsi
testq %rsi, %rsi
je 0x3aef
movq %rsi, %rdi
movq 0x10(%r15), %rsi
jmp 0x3af6
leaq 0x6735(%rip), %rdi      # 0xa22b
movq %rbx, %rdx
movq %r14, %rcx
movl %r12d, %r8d
callq 0x5522
testb %al, %al
jne 0x3b25
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r13d, %ecx
callq 0x3bf6
movq %rax, %r15
jmp 0x3ad9
movq 0x30(%r15), %r15
jmp 0x3b25
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/./RapidXml/rapidxml_utils.hpp
// Function: unsigned long rapidxml::count_children<char>(rapidxml::xml_node<char>*)
inline std::size_t count_children(xml_node<Ch> *node)
    {
        xml_node<Ch> *child = node->first_node();
        std::size_t count = 0;
        while (child)
        {
            ++count;
            child = child->next_sibling();
        }
        return count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
xorl %ebx, %ebx
pushq $0x1
popq %r14
testq %rax, %rax
je 0x3b61
incq %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x3bf6
jmp 0x3b48
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3bdc
movl %ecx, %r12d
movq %rdx, %r15
movq %rsi, %r14
testq %rdx, %rdx
jne 0x3b99
movq %r14, %rdi
callq 0x4c33
movq %rax, %r15
addq $0x40, %rbx
leaq 0x6687(%rip), %r13      # 0xa22b
movzbl %r12b, %r12d
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x3be2
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x3bc1
movq %rsi, %rdi
movq 0x10(%rbx), %rsi
jmp 0x3bc4
movq %r13, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x5522
testb %al, %al
jne 0x3be4
addq $0x30, %rbx
jmp 0x3ba8
movq 0x40(%rbx), %rbx
jmp 0x3be4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>::next_sibling(char const*, unsigned long, bool) const
xml_node<Ch> *next_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            assert(this->m_parent);     // Cannot query for siblings if node has no parent
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *sibling = m_next_sibling; sibling; sibling = sibling->m_next_sibling)
                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
                        return sibling;
                return 0;
            }
            else
                return m_next_sibling;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0x3c82
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3c68
movl %ecx, %r12d
movq %rdx, %r15
testq %rdx, %rdx
jne 0x3c2c
movq %r14, %rdi
callq 0x4c33
movq %rax, %r15
leaq 0x65f8(%rip), %r13      # 0xa22b
movzbl %r12b, %r12d
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
je 0x3c6e
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x3c51
movq %rsi, %rdi
movq 0x10(%rbx), %rsi
jmp 0x3c54
movq %r13, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x5522
testb %al, %al
je 0x3c37
jmp 0x3c70
movq 0x58(%rbx), %rbx
jmp 0x3c70
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2912(%rip), %rdi      # 0x659b
leaq 0x26d5(%rip), %rsi      # 0x6365
leaq 0x2913(%rip), %rcx      # 0x65aa
movl $0x3ee, %edx            # imm = 0x3EE
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3dab
movl %edi, %eax
negl %eax
andl $0x7, %eax
movq (%rdi,%rax), %r15
movq 0x10020(%rbx), %rax
testq %rax, %rax
je 0x3d9e
callq *%rax
jmp 0x3da3
callq 0x22a0
movq %r15, (%rbx)
movq %r15, %rdi
jmp 0x3d7e
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_O2/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: void rapidxml::xml_document<char>::parse_bom<0>(char*&)
void parse_bom(Ch *&text)
        {
            // UTF-8?
            if (static_cast<unsigned char>(text[0]) == 0xEF && 
                static_cast<unsigned char>(text[1]) == 0xBB && 
                static_cast<unsigned char>(text[2]) == 0xBF)
            {
                text += 3;      // Skup utf-8 bom
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
cmpb $-0x11, (%rax)
jne 0x41b9
cmpb $-0x45, 0x1(%rax)
jne 0x41b9
cmpb $-0x41, 0x2(%rax)
jne 0x41b9
addq $0x3, %rax
movq %rax, (%rsi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: void rapidxml::xml_document<char>::skip<rapidxml::xml_document<char>::whitespace_pred, 0>(char*&)
static void skip(Ch *&text)
        {
            Ch *tmp = text;
            while (StopPred::test(*tmp))
                ++tmp;
            text = tmp;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
decq %rax
leaq 0x2473(%rip), %rcx      # 0x6640
movzbl 0x1(%rax), %edx
incq %rax
cmpb $0x0, (%rdx,%rcx)
jne 0x41cd
movq %rax, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43e8
cmpq $0x0, 0x20(%rsi)
jne 0x43e8
cmpl $0x0, 0x28(%rsi)
je 0x43e8
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)
andq $0x0, 0x58(%rsi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2129(%rip), %rdi      # 0x651c
leaq 0x1f6b(%rip), %rsi      # 0x6365
leaq 0x2157(%rip), %rcx      # 0x6558
movl $0x44b, %edx            # imm = 0x44B
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_element<0>(char*&)
xml_node<Ch> *parse_element(Ch *&text)
        {
            // Create element node
            xml_node<Ch> *element = this->allocate_node(node_element);

            // Extract element name
            Ch *name = text;
            skip<node_name_pred, Flags>(text);
            if (text == name)
                RAPIDXML_PARSE_ERROR("expected element name", text);
            element->name(name, text - name);
            
            // Skip whitespace between element name and attributes or >
            skip<whitespace_pred, Flags>(text);

            // Parse attributes, if any
            parse_node_attributes<Flags>(text, element);

            // Determine ending type
            if (*text == Ch('>'))
            {
                ++text;
                parse_node_contents<Flags>(text, element);
            }
            else if (*text == Ch('/'))
            {
                ++text;
                if (*text != Ch('>'))
                    RAPIDXML_PARSE_ERROR("expected >", text);
                ++text;
            }
            else
                RAPIDXML_PARSE_ERROR("expected >", text);

            // Place zero terminator after name
            if (!(Flags & parse_no_string_terminators))
                element->name()[element->name_size()] = Ch('\0');

            // Return parsed element
            return element;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
addq $0x60, %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x47ba
movq %rax, %r14
movq (%rbx), %r12
movq %rbx, %rdi
callq 0x4850
movq (%rbx), %rax
subq %r12, %rax
je 0x44c8
movq %r12, (%r14)
movq %rax, 0x10(%r14)
movq %rbx, %rdi
callq 0x41bc
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4874
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x2f, %ecx
je 0x448c
cmpl $0x3e, %ecx
jne 0x44e6
incq %rax
movq %rax, (%rbx)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4a30
jmp 0x44a0
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
cmpb $0x3e, 0x1(%rax)
jne 0x44e6
addq $0x2, %rax
movq %rax, (%rbx)
movq (%r14), %rax
testq %rax, %rax
je 0x44b1
movq %rax, %rcx
movq 0x10(%r14), %rax
jmp 0x44b8
leaq 0x5d73(%rip), %rcx      # 0xa22b
movb $0x0, (%rcx,%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq (%rbx), %rcx
leaq 0x58a6(%rip), %rdx      # 0x9d80
movq %rdx, (%rax)
leaq 0x1efd(%rip), %rdx      # 0x63e1
jmp 0x4502
pushq $0x18
popq %rdi
callq 0x20e0
movq (%rbx), %rcx
leaq 0x5888(%rip), %rdx      # 0x9d80
movq %rdx, (%rax)
leaq 0x1ef5(%rip), %rdx      # 0x63f7
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x5847(%rip), %rsi      # 0x9d58
movq 0x5ac0(%rip), %rdx      # 0x9fd8
movq %rax, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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 0x453e
testl %ecx, %ecx
jne 0x4543
jmp 0x4557
cmpb $0x3e, (%rax)
je 0x4548
movq %rax, (%rbx)
jmp 0x452c
incq %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq (%rbx), %rcx
leaq 0x5817(%rip), %rdx      # 0x9d80
movq %rdx, (%rax)
leaq 0x1e57(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x57d6(%rip), %rsi      # 0x9d58
movq 0x5a4f(%rip), %rdx      # 0x9fd8
movq %rax, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4622
testl %ecx, %ecx
jne 0x462d
jmp 0x4642
cmpb $0x2d, (%rax)
jne 0x462d
cmpb $0x3e, 0x1(%rax)
je 0x4632
movq %rax, (%rbx)
jmp 0x4610
addq $0x2, %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq (%rbx), %rcx
leaq 0x572c(%rip), %rdx      # 0x9d80
movq %rdx, (%rax)
leaq 0x1d6c(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x56eb(%rip), %rsi      # 0x9d58
movq 0x5964(%rip), %rdx      # 0x9fd8
movq %rax, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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 0x469c
testl %ecx, %ecx
jne 0x46a7
jmp 0x46e2
cmpb $0x5d, (%rax)
jne 0x46a7
cmpb $0x3e, 0x1(%rax)
je 0x46af
movq %rax, (%rbx)
incq %rax
jmp 0x468d
addq $0x60, %rdi
pushq $0x3
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x47ba
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
pushq $0x18
popq %rdi
callq 0x20e0
movq (%rbx), %rcx
leaq 0x568c(%rip), %rdx      # 0x9d80
movq %rdx, (%rax)
leaq 0x1ccc(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x564b(%rip), %rsi      # 0x9d58
movq 0x58c4(%rip), %rdx      # 0x9fd8
movq %rax, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::allocate_node(rapidxml::node_type, char const*, char const*, unsigned long, unsigned long)
xml_node<Ch> *allocate_node(node_type type, 
                                    const Ch *name = 0, const Ch *value = 0, 
                                    std::size_t name_size = 0, std::size_t value_size = 0)
        {
            void *memory = allocate_aligned(sizeof(xml_node<Ch>));
            xml_node<Ch> *node = new(memory) xml_node<Ch>(type);
            if (name)
            {
                if (name_size > 0)
                    node->name(name, name_size);
                else
                    node->name(name);
            }
            if (value)
            {
                if (value_size > 0)
                    node->value(value, value_size);
                else
                    node->value(value);
            }
            return node;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %r14d
pushq $0x60
popq %rsi
callq 0x4b24
movq %rax, %r15
andq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %r14d, 0x28(%rax)
andq $0x0, 0x30(%rax)
andq $0x0, 0x40(%rax)
testq %r12, %r12
je 0x481a
testq %r13, %r13
je 0x480f
movq %r12, (%r15)
movq %r13, 0x10(%r15)
jmp 0x481a
movq %r15, %rdi
movq %r12, %rsi
callq 0x4bae
testq %rbx, %rbx
je 0x483d
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x4832
movq %rbx, 0x8(%r15)
movq %rax, 0x18(%r15)
jmp 0x483d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4bd0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::allocate_aligned(unsigned long)
void *allocate_aligned(std::size_t size)
        {
            // Calculate aligned pointer
            char *result = align(m_ptr);

            // If not enough memory left in current pool, allocate a new pool
            if (result + size > m_end)
            {
                // Calculate required pool size (may be bigger than RAPIDXML_DYNAMIC_POOL_SIZE)
                std::size_t pool_size = RAPIDXML_DYNAMIC_POOL_SIZE;
                if (pool_size < size)
                    pool_size = size;
                
                // Allocate
                std::size_t alloc_size = sizeof(header) + (2 * RAPIDXML_ALIGNMENT - 2) + pool_size;     // 2 alignments required in worst case: one for header, one for actual allocation
                char *raw_memory = allocate_raw(alloc_size);
                    
                // Setup new pool in allocated memory
                char *pool = align(raw_memory);
                header *new_header = reinterpret_cast<header *>(pool);
                new_header->previous_begin = m_begin;
                m_begin = raw_memory;
                m_ptr = pool + sizeof(header);
                m_end = raw_memory + alloc_size;

                // Calculate aligned pointer again using new pool
                result = align(m_ptr);
            }

            // Update pool and return aligned pointer
            m_ptr = result + size;
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movl %ecx, %eax
negl %eax
andl $0x7, %eax
addq %rcx, %rax
leaq (%rax,%rsi), %rcx
cmpq 0x10(%rdi), %rcx
jbe 0x4b9c
leaq 0x16(%rbx), %rax
cmpq $0x10001, %rbx          # imm = 0x10001
movl $0x10016, %r15d         # imm = 0x10016
cmovaeq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4bf2
movl %eax, %ecx
negl %ecx
andl $0x7, %ecx
leaq (%rax,%rcx), %rdx
movq (%r14), %rsi
addq %rax, %rcx
addq $0x8, %rcx
movq %rsi, -0x8(%rcx)
movq %rax, (%r14)
addq %rax, %r15
movq %r15, 0x10(%r14)
negl %ecx
andl $0x7, %ecx
leaq (%rcx,%rdx), %rax
addq $0x8, %rax
addq %rax, %rbx
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4c0e
callq *%rax
testq %rax, %rax
je 0x4c14
popq %rbp
retq
popq %rbp
jmp 0x2030
leaq 0x17e7(%rip), %rdi      # 0x6402
leaq 0x1743(%rip), %rsi      # 0x6365
leaq 0x17e0(%rip), %rcx      # 0x6409
movl $0x24a, %edx            # imm = 0x24A
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4cae
cmpq $0x0, 0x20(%rsi)
jne 0x4cae
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)
andq $0x0, 0x30(%rsi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x17c8(%rip), %rdi      # 0x6481
leaq 0x16a5(%rip), %rsi      # 0x6365
leaq 0x17dc(%rip), %rcx      # 0x64a3
movl $0x4c3, %edx            # imm = 0x4C3
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq %rcx, %rsi
jne 0x5549
pushq %rbp
movq %rsp, %rbp
addq %rdi, %rsi
testb %r8b, %r8b
je 0x554c
cmpq %rsi, %rdi
setae %al
jae 0x5575
movb (%rdi), %cl
cmpb (%rdx), %cl
jne 0x5575
incq %rdi
incq %rdx
jmp 0x5533
xorl %eax, %eax
retq
leaq 0x17ed(%rip), %rcx      # 0x6d40
cmpq %rsi, %rdi
setae %al
jae 0x5575
movzbl (%rdi), %r8d
movb (%r8,%rcx), %r8b
movzbl (%rdx), %r9d
cmpb (%r9,%rcx), %r8b
jne 0x5575
incq %rdi
incq %rdx
jmp 0x5553
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %r12d
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %r14
movb %al, 0x38(%rdi)
pushq $0x58
popq %rax
leaq (%rbx,%rax), %rcx
movq %rcx, -0x10(%rbx,%rax)
andq $0x0, -0x8(%rbx,%rax)
movb $0x0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0xd8, %rax
jne 0x57a7
movq %rbx, %rdi
callq 0x2100
movl %r12d, 0x20(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
leaq 0x48(%rbx), %r12
movb $0x0, 0xcc(%rbx)
xorl %r13d, %r13d
leaq 0x87f(%rip), %r15       # 0x6071
cmpq $0x80, %r13
je 0x580d
leaq (%r12,%r13), %rdi
movq %r15, %rsi
callq 0x23f0
addq $0x20, %r13
jmp 0x57f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x581e
movq %rax, %r15
movl $0xa8, %r12d
leaq (%rbx,%r12), %rdi
callq 0x20d0
addq $-0x20, %r12
cmpq $0x28, %r12
jne 0x5827
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5892
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 0x7c0(%rip), %rsi       # 0x6071
movq %r14, %rdi
callq 0x26d2
testb %al, %al
je 0x58c1
xorl %eax, %eax
jmp 0x58ce
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x48, %rbx
pushq $-0x4
popq %r13
movq 0x466e(%rip), %r14      # 0x9fc0
leaq 0x14e7(%rip), %r15      # 0x6e40
leaq 0x856(%rip), %r12       # 0x61b6
testq %r13, %r13
je 0x599b
leal 0x5(%r13), %esi
movq %r14, %rdi
callq 0x2370
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
incq %r13
addq $0x20, %rbx
jmp 0x5960
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x58(%rsp), %rbx
leaq 0xb27c(%rip), %r14      # 0x10870
leaq 0x38(%rsp), %r15
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %rbp
xorl %r13d, %r13d
movl %r13d, %eax
movq 0xb268(%rip), %rcx      # 0x10878
movq 0xb259(%rip), %rsi      # 0x10870
subq %rsi, %rcx
sarq $0x5, %rcx
cmpq %rax, %rcx
jbe 0x5700
leaq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
andq $0x0, 0x60(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
andq $0x0, 0x40(%rsp)
xorl %eax, %eax
movb %al, 0x68(%rsp)
movb %al, 0x48(%rsp)
leaq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movb %al, 0x28(%rsp)
movq %rbx, %rdi
callq 0x4200
movq %r14, %rdi
callq 0x633e
movq 0xb1f4(%rip), %rsi      # 0x10870
movq %r15, %rdi
callq 0x4200
movq %r14, %rdi
callq 0x633e
movq 0xb1dd(%rip), %rsi      # 0x10870
movq %r12, %rdi
callq 0x4200
movq %r14, %rdi
callq 0x633e
movq %rbx, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movq %rbp, %rdi
leaq 0x16f2(%rip), %rsi      # 0x6dac
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x6352
movq %rbp, %rdi
callq 0x4580
movq %rbp, %rdi
callq 0x61dc
movq %r12, %rdi
callq 0x4678
movq %r15, %rdi
callq 0x4678
movq %rbx, %rdi
callq 0x4678
addl $0x3, %r13d
jmp 0x5606
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x61dc
jmp 0x5723
jmp 0x5720
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4678
leaq 0x38(%rsp), %rdi
callq 0x4678
leaq 0x58(%rsp), %rdi
callq 0x4678
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: ReadFileByLine(int, int)
void ReadFileByLine(int TrackerFileD,int flag){
    char sendBuffer[BUFFER_SIZE];
    int index = 0;

    mTorrentFileData.clear();
    memset(&sendBuffer, '\0',BUFFER_SIZE);
    while (read(TrackerFileD, &sendBuffer[index], 1) == 1) {
        if (sendBuffer[index] == '\n' || sendBuffer[index] == 0x0) {
            if(!flag){
                mTorrentFileData.push_back((string)sendBuffer);
                return ;
            }
            else{ 
                string sb = (string)sendBuffer;
                unsigned int found = sb.find(':');
                if (found != string::npos){
                    mTorrentFileData.push_back(sb.substr(0,found));
                    mTorrentFileData.push_back(sb.substr(found+1));
                }
                return ;
            }
        }
        index++;
    }
    return ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movl %esi, %ebx
movl %edi, %ebp
leaq 0x9026(%rip), %rdi      # 0x108d8
callq 0x89b2
leaq 0x40(%rsp), %r14
movl $0x7d0, %edx            # imm = 0x7D0
movq %r14, %rdi
xorl %esi, %esi
callq 0x4210
pushq $0x1
popq %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4490
cmpq $0x1, %rax
jne 0x79a4
movzbl (%r14), %eax
cmpl $0xa, %eax
je 0x78f8
testl %eax, %eax
je 0x78f8
incq %r14
jmp 0x78cf
testl %ebx, %ebx
je 0x7977
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
callq 0x6040
leaq 0x20(%rsp), %r14
pushq $0x3a
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4440
movq %rax, %rbx
movl %ebx, %ecx
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4360
leaq 0x8f9f(%rip), %rdi      # 0x108d8
movq %rsp, %rsi
callq 0x680a
movq %rsp, %rdi
callq 0x4678
incl %ebx
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %rbx, %rdx
callq 0x4360
leaq 0x8f73(%rip), %rdi      # 0x108d8
movq %rsp, %rsi
callq 0x680a
movq %rsp, %rdi
callq 0x4678
jmp 0x799a
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
callq 0x6040
leaq 0x8f48(%rip), %rdi      # 0x108d8
leaq 0x20(%rsp), %rsi
callq 0x680a
leaq 0x20(%rsp), %rdi
callq 0x4678
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x79c7
jmp 0x79d6
jmp 0x79ba
jmp 0x79c7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4678
jmp 0x79ca
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4678
jmp 0x79d9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x4100
testl %eax, %eax
js 0x7a51
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
pushq $0x2
popq %rdi
callq 0x4600
testl %eax, %eax
jle 0x7a5a
movq %rsp, %rsi
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x42c0
testl %eax, %eax
jns 0x7a69
leaq 0x3aa5(%rip), %rdi      # 0xb4f4
jmp 0x7a61
leaq 0x3ad9(%rip), %rdi      # 0xb531
jmp 0x7a61
leaq 0x3aa7(%rip), %rdi      # 0xb508
callq 0x44e0
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq