LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp
// Function: ASTOptimizer::optimize(bool)
void ASTOptimizer::optimize(bool verbose) {
    while (traverse(originalProgram->commands, [this](Node *node) -> Node * { return constantConditionRemover(node); })) {
        std::cout << "   [i] flattening always true expressions" << std::endl;
    }

    while (traverse(originalProgram->commands, [this](Node *node) -> Node * { return constantLoopUnroller(node); })) {
        std::cout << "   [i] unrolling constant loops" << std::endl;
    }
    while (traverse(originalProgram->commands, [this](Node *node) -> Node * { return constantExpressionOptimizer(node); })) {
        std::cout << "   [i] Replacing constant expressions" << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0xb8(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x27730
movq -0xa0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
callq 0x25f40
movb %al, -0xa1(%rbp)
jmp 0x27561
leaq -0x30(%rbp), %rdi
callq 0x11640
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x27576
jmp 0x275b7
movq 0x19a4b(%rip), %rdi     # 0x40fc8
leaq 0xb39d(%rip), %rsi      # 0x32921
callq 0x6250
movq %rax, %rdi
movq 0x199fd(%rip), %rsi     # 0x40f90
callq 0x6280
jmp 0x27512
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11640
jmp 0x2771a
jmp 0x275b9
movq -0xa0(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0xd0(%rbp)
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x277c0
movq -0xa0(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x25f40
movb %al, -0xb9(%rbp)
jmp 0x27608
leaq -0x68(%rbp), %rdi
callq 0x11640
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x2761d
jmp 0x2765e
movq 0x199a4(%rip), %rdi     # 0x40fc8
leaq 0xb320(%rip), %rsi      # 0x3294b
callq 0x6250
movq %rax, %rdi
movq 0x19956(%rip), %rsi     # 0x40f90
callq 0x6280
jmp 0x275b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x11640
jmp 0x2771a
jmp 0x27660
movq -0xa0(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0xe8(%rbp)
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
leaq -0x98(%rbp), %rsi
callq 0x27850
movq -0xa0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
callq 0x25f40
movb %al, -0xd1(%rbp)
jmp 0x276b8
leaq -0x90(%rbp), %rdi
callq 0x11640
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x276d0
jmp 0x27711
movq 0x198f1(%rip), %rdi     # 0x40fc8
leaq 0xb28d(%rip), %rsi      # 0x3296b
callq 0x6250
movq %rax, %rdi
movq 0x198a3(%rip), %rsi     # 0x40f90
callq 0x6280
jmp 0x27660
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x11640
jmp 0x2771a
addq $0xf0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x64d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x16d25(%rip), %rdi     # 0x40fc8
leaq 0x86ff(%rip), %rsi      # 0x329a9
callq 0x6250
movq %rax, %rdi
movq 0x16cd7(%rip), %rsi     # 0x40f90
callq 0x6280
movq -0x18(%rbp), %rdi
callq 0x2a360
testb $0x1, %al
jne 0x2a2cd
jmp 0x2a2f7
testb $0x1, -0x9(%rbp)
je 0x2a2f5
movq 0x16cee(%rip), %rdi     # 0x40fc8
movq 0x16caf(%rip), %rsi     # 0x40f90
callq 0x6280
movq %rax, %rdi
leaq 0x86e0(%rip), %rsi      # 0x329d0
callq 0x6250
jmp 0x2a2be
movq 0x16cca(%rip), %rdi     # 0x40fc8
leaq 0x86e6(%rip), %rsi      # 0x329eb
callq 0x6250
movq %rax, %rdi
movq 0x16c7c(%rip), %rsi     # 0x40f90
callq 0x6280
movq -0x18(%rbp), %rdi
callq 0x2a710
testb $0x1, %al
jne 0x2a328
jmp 0x2a352
testb $0x1, -0x9(%rbp)
je 0x2a350
movq 0x16c93(%rip), %rdi     # 0x40fc8
movq 0x16c54(%rip), %rsi     # 0x40f90
callq 0x6280
movq %rax, %rdi
leaq 0x86c8(%rip), %rsi      # 0x32a13
callq 0x6250
jmp 0x2a319
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2b309
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movl $0x18, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x6160
movq -0x58(%rbp), %rdi
callq 0x2b630
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x2b480
movq -0x48(%rbp), %rax
movq $0x0, -0x20(%rbp)
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1fda0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1fdd0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1fe00
testb $0x1, %al
jne 0x2b34a
jmp 0x2b38d
leaq -0x30(%rbp), %rdi
callq 0x1fe40
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x10(%rax)
jne 0x2b380
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2b382
leaq -0x30(%rbp), %rdi
callq 0x1fe60
jmp 0x2b337
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movb $0x1, -0x5(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3390
testb $0x1, -0x5(%rbp)
je 0x388e
movl $0x18, %edi
callq 0x3290
movq %rax, -0x48(%rbp)
jmp 0x3756
movq -0x48(%rbp), %rdi
movl $0x5, %esi
callq 0x3920
jmp 0x3766
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0xe853(%rip), %rdi      # 0x11fc8
leaq 0x8888(%rip), %rsi      # 0xc004
callq 0x3280
jmp 0x3783
jmp 0x3785
movq -0x30(%rbp), %rdi
callq 0x4bb0
movb %al, -0x49(%rbp)
jmp 0x3793
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x379c
jmp 0x37e4
movq -0x30(%rbp), %rdi
callq 0x4420
jmp 0x37a7
movq -0x30(%rbp), %rdi
callq 0x4bd0
jmp 0x37b2
jmp 0x3785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x38a7
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x18, %esi
callq 0x32a0
jmp 0x38a7
movq -0x30(%rbp), %rdi
callq 0x4b50
jmp 0x37ef
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x3814
movq -0x58(%rbp), %rdi
callq 0x43d0
movq -0x58(%rbp), %rdi
movl $0x18, %esi
callq 0x32a0
movq 0xe7ad(%rip), %rdi      # 0x11fc8
leaq 0x8807(%rip), %rsi      # 0xc029
callq 0x3280
jmp 0x3829
movq 0xe7a8(%rip), %rdi      # 0x11fd8
leaq -0x28(%rbp), %rsi
callq 0x3350
jmp 0x383b
leaq 0x880b(%rip), %rsi      # 0xc04d
leaq -0x28(%rbp), %rdi
callq 0x38c0
movb %al, -0x59(%rbp)
jmp 0x3850
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x3859
jmp 0x3885
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x3550
movq %rax, -0x68(%rbp)
jmp 0x386c
movq -0x68(%rbp), %rax
movsbl (%rax), %edi
callq 0x3500
cmpl $0x59, %eax
sete %al
andb $0x1, %al
movb %al, -0x5(%rbp)
jmp 0x3889
movb $0x0, -0x5(%rbp)
jmp 0x373c
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3180
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
callq 0x34a0
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x4(%rax)
movb $0x1, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x39cd
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x397e
movq -0x18(%rbp), %rdi
callq 0x39e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x9(%rbp)
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x4c4f
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4c42
testb $0x1, -0x9(%rbp)
je 0x4c35
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb1f0
testb $0x1, %al
jne 0x4c35
movb $0x0, -0x9(%rbp)
jmp 0x4c37
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4bfe
jmp 0x4c44
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4bf1
movq -0x20(%rbp), %rax
movb -0x9(%rbp), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Matlock42[P]Jeopardy/./tinydir/tinydir.h
// Function: tinydir_open(tinydir_dir*, char const*)
_TINYDIR_FUNC
int tinydir_open(tinydir_dir *dir, const char *path)
{
	if (dir == NULL || path == NULL || strlen(path) == 0)
	{
		errno = EINVAL;
		return -1;
	}
	if (strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX)
	{
		errno = ENAMETOOLONG;
		return -1;
	}

	/* initialise dir */
	dir->_files = NULL;
#ifdef _MSC_VER
	dir->_h = INVALID_HANDLE_VALUE;
#else
	dir->_d = NULL;
#endif
	tinydir_close(dir);

	strcpy(dir->path, path);
#ifdef _MSC_VER
	strcat(dir->path, "\\*");
	dir->_h = FindFirstFile(dir->path, &dir->_f);
	dir->path[strlen(dir->path) - 2] = '\0';
	if (dir->_h == INVALID_HANDLE_VALUE)
#else
	dir->_d = opendir(path);
	if (dir->_d == NULL)
#endif
	{
		errno = ENOENT;
		goto bail;
	}

	/* read first file */
	dir->has_next = 1;
#ifndef _MSC_VER
	dir->_e = readdir(dir->_d);
	if (dir->_e == NULL)
	{
		dir->has_next = 0;
	}
#endif

	return 0;

bail:
	tinydir_close(dir);
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x514d
cmpq $0x0, -0x18(%rbp)
je 0x514d
movq -0x18(%rbp), %rdi
callq 0x3100
cmpq $0x0, %rax
jne 0x5164
callq 0x3050
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5257
movq -0x18(%rbp), %rdi
callq 0x3100
addq $0x0, %rax
cmpq $0x1000, %rax           # imm = 0x1000
jb 0x5190
callq 0x3050
movl $0x24, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5257
movq -0x10(%rbp), %rax
movq $0x0, 0x1008(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x1010(%rax)
movq -0x10(%rbp), %rdi
callq 0x54b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3260
movq -0x18(%rbp), %rdi
callq 0x33d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1010(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1010(%rax)
jne 0x51f6
callq 0x3050
movl $0x2, (%rax)
jmp 0x5247
movq -0x10(%rbp), %rax
movl $0x1, 0x1000(%rax)
movq -0x10(%rbp), %rax
movq 0x1010(%rax), %rdi
callq 0x33f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1018(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1018(%rax)
jne 0x523e
movq -0x10(%rbp), %rax
movl $0x0, 0x1000(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5257
movq -0x10(%rbp), %rdi
callq 0x54b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Matlock42[P]Jeopardy/./tinydir/tinydir.h
// Function: tinydir_next(tinydir_dir*)
_TINYDIR_FUNC
int tinydir_next(tinydir_dir *dir)
{
	if (dir == NULL)
	{
		errno = EINVAL;
		return -1;
	}
	if (!dir->has_next)
	{
		errno = ENOENT;
		return -1;
	}

#ifdef _MSC_VER
	if (FindNextFile(dir->_h, &dir->_f) == 0)
#else
	dir->_e = readdir(dir->_d);
	if (dir->_e == NULL)
#endif
	{
		dir->has_next = 0;
#ifdef _MSC_VER
		if (GetLastError() != ERROR_SUCCESS &&
			GetLastError() != ERROR_NO_MORE_FILES)
		{
			tinydir_close(dir);
			errno = EIO;
			return -1;
		}
#endif
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5437
callq 0x3050
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5499
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1000(%rax)
jne 0x5458
callq 0x3050
movl $0x2, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5499
movq -0x10(%rbp), %rax
movq 0x1010(%rax), %rdi
callq 0x33f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1018(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1018(%rax)
jne 0x5492
movq -0x10(%rbp), %rax
movl $0x0, 0x1000(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Matlock42[P]Jeopardy/./tinydir/tinydir.h
// Function: tinydir_close(tinydir_dir*)
_TINYDIR_FUNC
void tinydir_close(tinydir_dir *dir)
{
	if (dir == NULL)
	{
		return;
	}

	memset(dir->path, 0, sizeof(dir->path));
	dir->has_next = 0;
	dir->n_files = -1;
	if (dir->_files != NULL)
	{
		free(dir->_files);
	}
	dir->_files = NULL;
#ifdef _MSC_VER
	if (dir->_h != INVALID_HANDLE_VALUE)
	{
		FindClose(dir->_h);
	}
	dir->_h = INVALID_HANDLE_VALUE;
#else
	if (dir->_d)
	{
		closedir(dir->_d);
	}
	dir->_d = NULL;
	dir->_e = NULL;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x54c8
jmp 0x555d
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x3140
movq -0x8(%rbp), %rax
movl $0x0, 0x1000(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1004(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1008(%rax)
je 0x5512
movq -0x8(%rbp), %rax
movq 0x1008(%rax), %rdi
callq 0x3300
movq -0x8(%rbp), %rax
movq $0x0, 0x1008(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1010(%rax)
je 0x553f
movq -0x8(%rbp), %rax
movq 0x1010(%rax), %rdi
callq 0x3410
movq -0x8(%rbp), %rax
movq $0x0, 0x1010(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1018(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5bc1
jmp 0x5be0
leaq 0x6774(%rip), %rdi      # 0xc33c
leaq 0x6772(%rip), %rsi      # 0xc341
movl $0x567, %edx            # imm = 0x567
leaq 0x677e(%rip), %rcx      # 0xc359
callq 0x31a0
movq -0x30(%rbp), %rdi
callq 0x7bf0
movq -0x30(%rbp), %rdi
callq 0x7c50
movq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x7cb0
leaq -0x10(%rbp), %rdi
callq 0x7d10
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5c19
jmp 0x5cb1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x5c58
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x7d60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5c56
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x80c0
jmp 0x5cac
movl $0x18, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x6724(%rip), %rsi      # 0xc39b
callq 0x81b0
jmp 0x5c7e
movq -0x38(%rbp), %rdi
leaq 0xc0cf(%rip), %rsi      # 0x11d58
leaq 0x2570(%rip), %rdx      # 0x8200
callq 0x3470
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31e0
jmp 0x5cb7
jmp 0x5bff
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34a0
// File: 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
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5d9f
cmpq $0x0, -0x20(%rbp)
jne 0x5d22
movq -0x18(%rbp), %rdi
callq 0x9370
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5d95
movq -0x30(%rbp), %rdi
callq 0x90a0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x90e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xa6f0
testb $0x1, %al
jne 0x5d6e
jmp 0x5d78
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5dab
jmp 0x5d7a
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x5f40
movq %rax, -0x30(%rbp)
jmp 0x5d2e
movq $0x0, -0x8(%rbp)
jmp 0x5dab
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x5ce0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5e1b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x5f40
movq %rax, -0x10(%rbp)
jmp 0x5ded
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5ee2
cmpq $0x0, -0x20(%rbp)
jne 0x5e72
movq -0x18(%rbp), %rdi
callq 0x9370
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5ed8
movq -0x30(%rbp), %rdi
callq 0x90a0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x90e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xa6f0
testb $0x1, %al
jne 0x5ebe
jmp 0x5ec8
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5eee
jmp 0x5eca
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5e7e
movq $0x0, -0x8(%rbp)
jmp 0x5eee
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x5f6c
jmp 0x5f8b
leaq 0x6604(%rip), %rdi      # 0xc577
leaq 0x63c7(%rip), %rsi      # 0xc341
movl $0x3ee, %edx            # imm = 0x3EE
leaq 0x6600(%rip), %rcx      # 0xc586
callq 0x31a0
cmpq $0x0, -0x18(%rbp)
je 0x601a
cmpq $0x0, -0x20(%rbp)
jne 0x5faa
movq -0x18(%rbp), %rdi
callq 0x9370
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6010
movq -0x30(%rbp), %rdi
callq 0x90a0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x90e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xa6f0
testb $0x1, %al
jne 0x5ff6
jmp 0x6000
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6026
jmp 0x6002
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5fb6
movq $0x0, -0x8(%rbp)
jmp 0x6026
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x6313
movq -0x18(%rbp), %rdi
movq (%rdi), %rsi
callq 0x6340
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0x10020(%rax)
je 0x62ea
movq -0x18(%rbp), %rcx
movq 0x10020(%rcx), %rax
movq (%rcx), %rdi
callq *%rax
jmp 0x6306
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6304
movq -0x20(%rbp), %rdi
callq 0x3360
jmp 0x6306
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x62a4
movq -0x18(%rbp), %rdi
callq 0x6370
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xef, %eax
jne 0x7cff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xbb, %eax
jne 0x7cff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xbf, %eax
jne 0x7cff
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x8220
cmpb $0x0, %al
je 0x7d45
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7d27
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x810d
movq -0x10(%rbp), %rdi
callq 0x9db0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x11(%rbp)
jne 0x810d
movq -0x10(%rbp), %rdi
callq 0xa660
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x8116
jmp 0x8118
jmp 0x8137
leaq 0x43d9(%rip), %rdi      # 0xc4f8
leaq 0x421b(%rip), %rsi      # 0xc341
movl $0x44b, %edx            # imm = 0x44B
leaq 0x4402(%rip), %rcx      # 0xc534
callq 0x31a0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x5ce0
cmpq $0x0, %rax
je 0x8170
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x50(%rcx)
movq -0x10(%rbp), %rcx
movq 0x38(%rax), %rax
movq %rcx, 0x58(%rax)
jmp 0x8188
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, 0x50(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, 0x38(%rcx)
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, -0x29(%rbp)
jne 0x84c8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x84d1
jmp 0x8547
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x8534
movl $0x18, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x3ea7(%rip), %rsi      # 0xc3a6
callq 0x81b0
jmp 0x8506
movq -0x38(%rbp), %rdi
leaq 0x9847(%rip), %rsi      # 0x11d58
leaq -0x318(%rip), %rdx      # 0x8200
callq 0x3470
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31e0
jmp 0x855d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x84a0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x31(%rbp)
jne 0x869d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x31(%rbp)
jne 0x869d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x86a6
jmp 0x871c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x8709
movl $0x18, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x3cd2(%rip), %rsi      # 0xc3a6
callq 0x81b0
jmp 0x86db
movq -0x40(%rbp), %rdi
leaq 0x9672(%rip), %rsi      # 0x11d58
leaq -0x4ed(%rip), %rdx      # 0x8200
callq 0x3470
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31e0
jmp 0x8732
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x8660
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34a0
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5d, %ecx
movb %al, -0x39(%rbp)
jne 0x87a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x5d, %ecx
movb %al, -0x39(%rbp)
jne 0x87a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x87a9
jmp 0x881f
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x880c
movl $0x18, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x3bcf(%rip), %rsi      # 0xc3a6
callq 0x81b0
jmp 0x87de
movq -0x48(%rbp), %rdi
leaq 0x956f(%rip), %rsi      # 0x11d58
leaq -0x5f0(%rip), %rdx      # 0x8200
callq 0x3470
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31e0
jmp 0x8880
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x8763
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x8a40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x9280
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34a0
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x60, %esi
callq 0x9120
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi
callq 0x9200
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8ab9
cmpq $0x0, -0x28(%rbp)
jbe 0x8aaa
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x8b50
jmp 0x8ab7
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9240
jmp 0x8ab9
cmpq $0x0, -0x20(%rbp)
je 0x8ae9
cmpq $0x0, -0x30(%rbp)
jbe 0x8ada
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9280
jmp 0x8ae7
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92b0
jmp 0x8ae9
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq 0x8(%rdi), %rsi
callq 0x6340
movq -0x48(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jbe 0x91e5
movq $0x10000, -0x20(%rbp)   # imm = 0x10000
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x9175
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
addq $0x16, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x92f0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x6340
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rdi), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rdi)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rdi), %rsi
callq 0x6340
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10018(%rax)
je 0x9351
movq -0x20(%rbp), %rax
movq 0x10018(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9330
jmp 0x934f
leaq 0x30a7(%rip), %rdi      # 0xc3de
leaq 0x3003(%rip), %rsi      # 0xc341
movl $0x24a, %edx            # imm = 0x24A
leaq 0x309b(%rip), %rcx      # 0xc3e5
callq 0x31a0
jmp 0x935e
movq -0x10(%rbp), %rdi
callq 0x3030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: unsigned long rapidxml::internal::measure<char>(char const*)
inline std::size_t measure(const Ch *p)
        {
            const Ch *tmp = p;
            while (*tmp) 
                ++tmp;
            return tmp - p;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9397
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9380
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::allocate_attribute(char const*, char const*, unsigned long, unsigned long)
xml_attribute<Ch> *allocate_attribute(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_attribute<Ch>));
            xml_attribute<Ch> *attribute = new(memory) xml_attribute<Ch>;
            if (name)
            {
                if (name_size > 0)
                    attribute->name(name, name_size);
                else
                    attribute->name(name);
            }
            if (value)
            {
                if (value_size > 0)
                    attribute->value(value, value_size);
                else
                    attribute->value(value);
            }
            return attribute;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x38, %esi
callq 0x9120
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x9d90
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x94b3
cmpq $0x0, -0x20(%rbp)
jbe 0x94a4
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8b50
jmp 0x94b1
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9240
jmp 0x94b3
cmpq $0x0, -0x18(%rbp)
je 0x94e3
cmpq $0x0, -0x28(%rbp)
jbe 0x94d4
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9280
jmp 0x94e1
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x92b0
jmp 0x94e3
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)