LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp
// Function: ASTOptimizer::iteratorReplacer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, long long)
Callback ASTOptimizer::iteratorReplacer(std::string &variableToReplace, long long value) {
    return [this, variableToReplace, value](Node *node) -> Node * {
        if (auto idVal = dynamic_cast<IdentifierValue *>(node)) {
            try {
                VariableIdentifier &varId = dynamic_cast<VariableIdentifier &>(idVal->identifier);

                if (varId.name == variableToReplace) {
                    return new NumberValue(value);
                }
            } catch (std::bad_cast _) {
                try {
                    VariableAccessIdentifier &varAccId = dynamic_cast<VariableAccessIdentifier &>(idVal->identifier);

                    if (varAccId.accessName == variableToReplace) {
                        return new IdentifierValue(*new AccessIdentifier(varAccId.name, value));
                    }
                } catch (std::bad_cast _) {}
            }
        } else if (auto varArrId = dynamic_cast<VariableAccessIdentifier *>(node)) {
            if (varArrId->accessName == variableToReplace) return new AccessIdentifier(varArrId->name, value);
        }
        return node;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %rdi
movq %rsi, -0x8(%rdi)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x639e
movq %r14, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl $0x30, %edi
callq 0x51f0
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdx
cmpq %r15, %rdx
je 0x19941
movq %rdx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x19948
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %r15, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x30(%rbp)
movq %r14, 0x28(%rax)
movq %rax, (%rbx)
leaq 0x566(%rip), %rax       # 0x19ed4
movq %rax, 0x18(%rbx)
leaq 0x803(%rip), %rax       # 0x1a17c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x199a3
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/peephole/PeepholeOptimizer.cpp
// Function: PeepholeOptimizer::optimize(bool)
void PeepholeOptimizer::optimize(bool verbose) {
    std::cout << "   [i] Removing useless STORE LOADs..." << std::endl;
    while (removeUselessStoreLoads()) {
        if (verbose) std::cout << std::endl << "Removed useless STORE LOAD";
    }
    std::cout << "   [i] Removing useless STORE LOADIs..." << std::endl;
    while (removeUselessStoreLoadis()) {
        if (verbose) std::cout << std::endl << "Removed useless STORE LOADI";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xda81(%rip), %r15      # 0x27fc8
leaq 0x6373(%rip), %rsi      # 0x208c1
movl $0x26, %edx
movq %r15, %rdi
callq 0x5250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movq %r14, %rdi
callq 0x1a67a
testb %al, %al
je 0x1a5dc
leaq 0x6353(%rip), %r12      # 0x208e8
testb %bl, %bl
je 0x1a5d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movl $0x1a, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x5250
movq %r14, %rdi
callq 0x1a67a
testb %al, %al
jne 0x1a595
leaq 0x6320(%rip), %rsi      # 0x20903
movl $0x27, %edx
movq %r15, %rdi
callq 0x5250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movq %r14, %rdi
callq 0x1a8f4
testb %al, %al
je 0x1a671
leaq 0x6301(%rip), %r12      # 0x2092b
testb %bl, %bl
je 0x1a665
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movl $0x1b, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x5250
movq %r14, %rdi
callq 0x1a8f4
testb %al, %al
jne 0x1a62a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ad82
leaq 0x8(%rbx), %r14
movl $0x18, %edi
callq 0x51f0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq $-0x1, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xcf1c(%rip), %rcx      # 0x27c88
addq $0x10, %rcx
movq %rcx, (%rax)
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x1ae6c
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r15, %r14
je 0x1adb3
xorl %ebx, %ebx
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
cmpq %r15, %r14
jne 0x1ad91
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x6a19(%rip), %rbx      # 0x8fc0
movq 0x6a22(%rip), %r12      # 0x8fd0
leaq -0x48(%rbp), %r13
leaq 0x3ab8(%rip), %r14      # 0x6071
movl $0x18, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movl $0x5, %esi
callq 0x26c8
movl $0x24, %edx
movq %rbx, %rdi
leaq 0x3a22(%rip), %rsi      # 0x6004
callq 0x2230
movq %r15, %rdi
callq 0x3682
testb %al, %al
je 0x2605
movq %r15, %rdi
callq 0x2fd8
movq %r15, %rdi
callq 0x368a
jmp 0x25e7
movq %r15, %rdi
callq 0x3606
movq %r15, %rdi
callq 0x2f92
movl $0x18, %esi
movq %r15, %rdi
callq 0x2200
movl $0x22, %edx
movq %rbx, %rdi
leaq 0x39f8(%rip), %rsi      # 0x6029
callq 0x2230
movq %r12, %rdi
movq %r13, %rsi
callq 0x2270
movq %r13, %rdi
movq %r14, %rsi
callq 0x2080
testl %eax, %eax
je 0x2665
movq -0x48(%rbp), %rax
movsbl (%rax), %edi
callq 0x23b0
cmpl $0x59, %eax
je 0x25b9
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x267e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x2200
jmp 0x26a6
jmp 0x26a3
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x26bf
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15d
movq %rdi, %rbx
movl $0x0, 0x4(%rdi)
movb $0x1, (%rdi)
movl %esi, 0x8(%rdi)
movslq %esi, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %r14
cmovnsq %rax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
testl %r12d, %r12d
jle 0x272e
movl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x2030
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x2716
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x273e
// File: /workspace/github_cpp_makefile_star2_O1/Matlock42[P]Jeopardy/jgameClass.cpp
// Function: Game::showScore()
int Game::showScore(void)
{
	clearScreen();
	// display final score;
	cout << "Final Score: " << mScore << "\n";
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %r12d
movq 0x599f(%rip), %r14      # 0x8fc0
leaq 0x2b8e(%rip), %r15      # 0x61b6
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
decl %r12d
je 0x3628
movq 0x597c(%rip), %r14      # 0x8fc0
leaq 0x2ade(%rip), %rsi      # 0x6129
movl $0xd, %edx
movq %r14, %rdi
callq 0x2230
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x2340
leaq 0x2b4c(%rip), %rsi      # 0x61b6
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq 0x8(%rdi), %r12
xorl %r14d, %r14d
testq %r12, %r12
jle 0x36f8
movb $0x1, %r15b
movq %r12, -0x30(%rbp)
decq %r12
cmpl $0x0, 0x8(%rbx)
jle 0x36e7
xorl %r13d, %r13d
testb $0x1, %r15b
je 0x36db
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r12,8), %rdi
callq 0x5ec4
movzbl %r15b, %r15d
testb %al, %al
cmovel %r14d, %r15d
incq %r13
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jl 0x36ba
cmpq $0x2, -0x30(%rbp)
jge 0x36aa
notb %r15b
andb $0x1, %r15b
movl %r15d, %r14d
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_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x270(%rbp), %rdi
movl $0x4, %edx
callq 0x23a0
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x3f3e
andb $-0x11, -0x257(%rbp,%rax)
leaq -0x270(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2290
leaq -0x270(%rbp), %rdi
callq 0x2350
movq %rax, %r14
leaq -0x270(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2260
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x4566
movq (%rbx), %rsi
leaq -0x270(%rbp), %rdi
movq %r14, %rdx
callq 0x2250
movq (%rbx), %rax
movb $0x0, (%rax,%r14)
leaq -0x270(%rbp), %rdi
callq 0x2050
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %r14
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x23d9(%rip), %rsi      # 0x6334
leaq 0x23e3(%rip), %rdx      # 0x6345
leaq -0x68(%rbp), %rdi
callq 0x44cc
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x23c0
leaq -0x38(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3f9a
movups (%rcx), %xmm0
leaq -0x38(%rbp), %rdx
movups %xmm0, (%rdx)
jmp 0x3fa5
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r13b
movq %r14, %rdi
callq 0x2300
xorl %r13d, %r13d
movq 0x501b(%rip), %rsi      # 0x8ff0
movq 0x4fdc(%rip), %rdx      # 0x8fb8
movq %r14, %rdi
callq 0x2330
movq %rax, %r15
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4008
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x4008
movq %rax, %r15
movb $0x1, %r13b
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x4025
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x4025
movq %rax, %r15
movb $0x1, %r13b
testb %r13b, %r13b
je 0x4040
movq %r14, %rdi
callq 0x2170
jmp 0x4040
jmp 0x403d
jmp 0x403d
movq %rax, %r15
jmp 0x404c
movq %rax, %r15
leaq -0x270(%rbp), %rdi
callq 0x2050
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4060
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r15, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4173
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4099
movq $0x0, 0x20(%rax)
movq 0x58(%rax), %rax
jmp 0x4086
movq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x40b8
movq $0x0, 0x20(%rax)
movq 0x30(%rax), %rax
jmp 0x40a5
movq $0x0, 0x40(%rbx)
cmpb $-0x11, (%rsi)
jne 0x40d9
cmpb $-0x45, 0x1(%rsi)
jne 0x40d9
cmpb $-0x41, 0x2(%rsi)
jne 0x40d9
addq $0x3, %rsi
movq %rsi, -0x20(%rbp)
leaq 0x2550(%rip), %r15      # 0x6630
leaq -0x20(%rbp), %r14
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
incq %rax
cmpb $0x0, (%rcx,%r15)
jne 0x40e8
leaq -0x1(%rax), %rcx
movq %rcx, -0x20(%rbp)
movzbl -0x1(%rax), %ecx
cmpl $0x3c, %ecx
jne 0x4127
movq %rax, -0x20(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46bc
testq %rax, %rax
je 0x40e4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4884
jmp 0x40e4
testl %ecx, %ecx
jne 0x4136
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x20d0
movq -0x20(%rbp), %rcx
leaq 0x4c35(%rip), %rdx      # 0x8d80
movq %rdx, (%rax)
leaq 0x226a(%rip), %rdx      # 0x63bf
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x4bf4(%rip), %rsi      # 0x8d58
movq 0x4e6d(%rip), %rdx      # 0x8fd8
movq %rax, %rdi
callq 0x2330
leaq 0x21e6(%rip), %rdi      # 0x6360
leaq 0x21e4(%rip), %rsi      # 0x6365
leaq 0x21f5(%rip), %rcx      # 0x637d
movl $0x567, %edx            # imm = 0x567
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
testq %rsi, %rsi
je 0x4294
testq %rdx, %rdx
jne 0x41c0
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%rsi,%rax)
movq %rdx, %rax
jne 0x41b2
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4298
leaq 0x1(%rsi), %rdi
leaq 0x502b(%rip), %r8       # 0x9203
leaq 0x2b51(%rip), %r9       # 0x6d30
movq (%rax), %r14
testq %r14, %r14
je 0x41f0
movq %r14, %r10
movq 0x10(%rax), %r14
jmp 0x41f3
movq %r8, %r10
cmpq %rdx, %r14
jne 0x427e
leaq (%r10,%r14), %r11
testq %r14, %r14
setg %bl
testb %cl, %cl
je 0x423d
testq %r14, %r14
jle 0x4298
movb (%r10), %r14b
cmpb (%rsi), %r14b
jne 0x427a
incq %r10
movq %rdi, %r14
cmpq %r11, %r10
setb %bl
jae 0x4298
movb (%r10), %r15b
leaq 0x1(%r14), %r12
incq %r10
cmpb (%r14), %r15b
movq %r12, %r14
je 0x4221
jmp 0x427a
testq %r14, %r14
jle 0x4298
movzbl (%r10), %r14d
movb (%r14,%r9), %r14b
movzbl (%rsi), %r15d
cmpb (%r15,%r9), %r14b
jne 0x427a
incq %r10
movq %rdi, %r14
cmpq %r11, %r10
setb %bl
jae 0x4298
movzbl (%r10), %r15d
movb (%r15,%r9), %r15b
movzbl (%r14), %r12d
incq %r14
incq %r10
cmpb (%r12,%r9), %r15b
je 0x425a
testb %bl, %bl
je 0x4298
cmpq $0x0, 0x20(%rax)
je 0x42a1
movq 0x58(%rax), %rax
testq %rax, %rax
jne 0x41df
jmp 0x4298
movq 0x30(%rdi), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22db(%rip), %rdi      # 0x6583
leaq 0x20b6(%rip), %rsi      # 0x6365
leaq 0x22dc(%rip), %rcx      # 0x6592
movl $0x3ee, %edx            # imm = 0x3EE
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43ba
testq %rdx, %rdx
jne 0x42e3
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%rsi,%rax)
movq %rdx, %rax
jne 0x42d5
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x43be
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1(%rsi), %rdi
leaq 0x4efd(%rip), %r8       # 0x9203
leaq 0x2a23(%rip), %r9       # 0x6d30
movq (%rax), %r14
testq %r14, %r14
je 0x431e
movq %r14, %r10
movq 0x10(%rax), %r14
jmp 0x4321
movq %r8, %r10
cmpq %rdx, %r14
jne 0x43a4
leaq (%r10,%r14), %r11
testq %r14, %r14
setg %bl
testb %cl, %cl
je 0x4363
testq %r14, %r14
jle 0x43b1
movb (%r10), %r14b
cmpb (%rsi), %r14b
jne 0x43a0
incq %r10
movq %rdi, %r14
cmpq %r11, %r10
setb %bl
jae 0x43b1
movb (%r10), %r15b
leaq 0x1(%r14), %r12
incq %r10
cmpb (%r14), %r15b
movq %r12, %r14
je 0x4347
jmp 0x43a0
testq %r14, %r14
jle 0x43b1
movzbl (%r10), %r14d
movb (%r14,%r9), %r14b
movzbl (%rsi), %r15d
cmpb (%r15,%r9), %r14b
jne 0x43a0
incq %r10
movq %rdi, %r14
cmpq %r11, %r10
setb %bl
jae 0x43b1
movzbl (%r10), %r15d
movb (%r15,%r9), %r15b
movzbl (%r14), %r12d
incq %r14
incq %r10
cmpb (%r12,%r9), %r15b
je 0x4380
testb %bl, %bl
je 0x43b1
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0x430d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rdi), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r15
cmpq %r14, %r15
je 0x4406
movq %r15, %rdi
movl %edi, %eax
negl %eax
andl $0x7, %eax
movq (%r15,%rax), %r15
movq 0x10020(%rbx), %rax
testq %rax, %rax
je 0x43f7
callq *%rax
jmp 0x4401
testq %rdi, %rdi
je 0x4401
callq 0x2280
movq %r15, (%rbx)
jmp 0x43d4
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_O1/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 0x48cb
cmpq $0x0, 0x20(%rsi)
jne 0x48cb
cmpl $0x0, 0x28(%rsi)
je 0x48cb
cmpq $0x0, 0x30(%rdi)
je 0x48ab
movq 0x38(%rdi), %rax
movq %rax, 0x50(%rsi)
addq $0x58, %rax
jmp 0x48b7
leaq 0x30(%rdi), %rax
movq $0x0, 0x50(%rsi)
movq %rsi, (%rax)
movq %rsi, 0x38(%rdi)
movq %rdi, 0x20(%rsi)
movq $0x0, 0x58(%rsi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1c2e(%rip), %rdi      # 0x6504
leaq 0x1a88(%rip), %rsi      # 0x6365
leaq 0x1c5c(%rip), %rcx      # 0x6540
movl $0x44b, %edx            # imm = 0x44B
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a6c
testl %ecx, %ecx
jne 0x4a75
jmp 0x4a89
cmpb $0x3e, (%rax)
je 0x4a7a
testb %cl, %cl
je 0x4a89
movq %rax, (%rbx)
jmp 0x4a5a
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 0x42e3(%rip), %rdx      # 0x8d80
movq %rdx, (%rax)
leaq 0x1923(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x42a2(%rip), %rsi      # 0x8d58
movq 0x451b(%rip), %rdx      # 0x8fd8
movq %rax, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b5c
testl %ecx, %ecx
jne 0x4b6b
jmp 0x4b80
cmpb $0x2d, (%rax)
jne 0x4b67
cmpb $0x3e, 0x1(%rax)
je 0x4b70
testb %cl, %cl
je 0x4b80
movq %rax, (%rbx)
jmp 0x4b4a
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 0x41ec(%rip), %rdx      # 0x8d80
movq %rdx, (%rax)
leaq 0x182c(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x41ab(%rip), %rsi      # 0x8d58
movq 0x4424(%rip), %rdx      # 0x8fd8
movq %rax, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4bdc
testl %ecx, %ecx
jne 0x4beb
jmp 0x4c39
cmpb $0x5d, (%rax)
jne 0x4be7
cmpb $0x3e, 0x1(%rax)
je 0x4bf3
testb %cl, %cl
je 0x4c39
movq %rax, (%rbx)
incq %rax
jmp 0x4bcd
addq $0x60, %rdi
movl $0x60, %esi
callq 0x5078
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 0x4133(%rip), %rdx      # 0x8d80
movq %rdx, (%rax)
leaq 0x1773(%rip), %rdx      # 0x63ca
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
leaq 0x40f2(%rip), %rsi      # 0x8d58
movq 0x436b(%rip), %rdx      # 0x8fd8
movq %rax, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50f4
leaq 0x16(%rbx), %rax
cmpq $0x10001, %rbx          # imm = 0x10001
movl $0x10016, %r15d         # imm = 0x10016
cmovaeq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5106
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)
movq %rcx, 0x8(%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_O1/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 0x5122
callq *%rax
testq %rax, %rax
je 0x5128
popq %rbp
retq
popq %rbp
jmp 0x2030
leaq 0x12d3(%rip), %rdi      # 0x6402
leaq 0x122f(%rip), %rsi      # 0x6365
leaq 0x12cc(%rip), %rcx      # 0x6409
movl $0x24a, %edx            # imm = 0x24A
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5189
cmpq $0x0, 0x20(%rsi)
jne 0x5189
cmpq $0x0, 0x40(%rdi)
je 0x5169
movq 0x48(%rdi), %rax
movq %rax, 0x28(%rsi)
addq $0x30, %rax
jmp 0x5175
leaq 0x40(%rdi), %rax
movq $0x0, 0x28(%rsi)
movq %rsi, (%rax)
movq %rsi, 0x48(%rdi)
movq %rdi, 0x20(%rsi)
movq $0x0, 0x30(%rsi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x12d5(%rip), %rdi      # 0x6469
leaq 0x11ca(%rip), %rsi      # 0x6365
leaq 0x12e9(%rip), %rcx      # 0x648b
movl $0x4c3, %edx            # imm = 0x4C3
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5d2a
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 0x2f6(%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 0x5d7b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5da9
movq %rax, %r15
movl $0xb8, %r12d
leaq (%rbx,%r12), %rax
movq -0x10(%rbx,%r12), %rdi
cmpq %rdi, %rax
je 0x5dcb
movq (%rax), %rsi
incq %rsi
callq 0x2200
addq $-0x20, %r12
cmpq $0x38, %r12
jne 0x5db2
movq (%r14), %rdi
cmpq -0x30(%rbp), %rdi
je 0x5ded
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x5e05
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq %r15, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5e82
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 0x1d0(%rip), %rsi       # 0x6071
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x5eb1
xorl %eax, %eax
jmp 0x5ebe
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_O1/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
movl $0x1, %r14d
xorl %r12d, %r12d
leaq 0x25b(%rip), %r13       # 0x61b6
movq 0x305e(%rip), %rdi      # 0x8fc0
movl %r14d, %esi
callq 0x2340
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0xeb4(%rip), %rsi       # 0x6e30
callq 0x2230
movq 0x48(%rbx,%r12), %rsi
movq 0x50(%rbx,%r12), %rdx
movq %r15, %rdi
callq 0x2230
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
incl %r14d
addq $0x20, %r12
cmpq $0x80, %r12
jne 0x5f5b
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_O1/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 0x28ca
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 0x28ca
movw %r13w, 0x20(%r14)
leaq -0x30(%rbp), %rdi
movq %r14, -0x8(%rdi)
xorl %r15d, %r15d
movq %r14, %rsi
callq 0x2964
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x235e
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x20e0
movq 0x2c73(%rip), %rdi      # 0x4fd8
leaq 0xc98(%rip), %rsi       # 0x3004
movl $0x11, %edx
callq 0x20f0
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x2387
movl 0x8(%rax), %eax
movslq %eax, %rsi
jmp 0x2389
xorl %esi, %esi
movq 0x2c48(%rip), %rdi      # 0x4fd8
callq 0x20b0
movq %rax, %r14
leaq 0xc77(%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 0x28ca
movzwl 0x20(%r14), %eax
movw %ax, 0x20(%rbx)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2407
callq 0x2850
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r15b
jmp 0x2439
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x2439
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x20e0
testb %r15b, %r15b
je 0x245e
movl $0x28, %esi
movq %r14, %rdi
callq 0x20e0
jmp 0x245e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x245e
callq 0x2850
movq %rbx, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libutreexo/test_utreexo.cpp
// Function: main
int main(int argc, char* argv[])
{
    (void)argc;
    (void)argv;
    std::string sha2_impl = SHA256AutoDetect();
    printf("sha2 implementation: %s\n", sha2_impl.c_str());
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1208
movq (%rbx), %rsi
leaq 0x26e1e(%rip), %rdi     # 0x28004
xorl %eax, %eax
callq 0x1030
movq (%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x11ff
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1854
addq %rbp, %rdx
cmpq $0x40, %rdx
jb 0x1856
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 *0x29824(%rip)          # 0x2b078
xorl %ebp, %ebp
movq %r14, %r12
subq %r15, %r12
cmpq $0x40, %r12
jl 0x1889
movq %r12, %rdx
shrq $0x6, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x29803(%rip)          # 0x2b078
movabsq $0x7fffffffffffffc0, %rax # imm = 0x7FFFFFFFFFFFFFC0
andq %r12, %rax
addq %rax, %r15
addq %rax, 0x60(%rbx)
subq %r15, %r14
jbe 0x18a5
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_O1/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 0x2681e(%rip), %rsi     # 0x28110
callq 0x17f4
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x17f4
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_O1/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 0x19ba
cmpq $0x0, 0x29713(%rip)     # 0x2b0a8
je 0x19ba
movq %r15, %rdi
movq %r14, %rsi
callq 0xa8fc
addq $0x100, %r15            # imm = 0x100
addq $0x200, %r14            # imm = 0x200
addq $-0x8, %rbx
cmpq $0x7, %rbx
ja 0x1997
cmpq $0x4, %rbx
jb 0x19ea
cmpq $0x0, 0x296d8(%rip)     # 0x2b0a0
je 0x19ea
movq %r15, %rdi
movq %r14, %rsi
callq 0x1802c
subq $-0x80, %r15
addq $0x100, %r14            # imm = 0x100
addq $-0x4, %rbx
cmpq $0x3, %rbx
ja 0x19ca
cmpq $0x2, %rbx
jb 0x1a17
cmpq $0x0, 0x296a0(%rip)     # 0x2b098
je 0x1a17
movq %r15, %rdi
movq %r14, %rsi
callq 0x16392
addq $0x40, %r15
subq $-0x80, %r14
addq $-0x2, %rbx
cmpq $0x1, %rbx
ja 0x19fa
testq %rbx, %rbx
je 0x1a35
movq %r15, %rdi
movq %r14, %rsi
callq *0x29658(%rip)          # 0x2b080
addq $0x20, %r15
addq $0x40, %r14
decq %rbx
jne 0x1a1c
popq %rbx
popq %r14
popq %r15
retq