LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: stoianmihail[P]XY-sorting/./util.hpp
// Function: util::is_sorted(std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
static bool is_sorted(std::vector<cdf_coord>& arr)
   // Test for order
   {
       // Note: the case where arr.size() = 1 is covered
       for (unsigned index = 1; index < arr.size(); ++index)
            if (!(arr[index - 1].first < arr[index].first))
                return false;
        return true;
   }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6870
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x55ff
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x68c0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x68c0
movq %rax, %rcx
movq (%rsp), %rax
cmpq (%rcx), %rax
jb 0x55f0
movb $0x0, 0x27(%rsp)
jmp 0x5604
jmp 0x55f2
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5591
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: mortennobel[P]glMatrix-vs-GLM-Benchmark/Timer.cpp
// Function: Timer::Timer()
Timer::Timer()
{
#ifdef WIN32
    QueryPerformanceFrequency(&frequency);
    startCount.QuadPart = 0;
    endCount.QuadPart = 0;
#else
    startCount.tv_sec = startCount.tv_usec = 0;
    endCount.tv_sec = endCount.tv_usec = 0;
#endif

    stopped = 0;
    startTimeInMicroSec = 0;
    endTimeInMicroSec = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x28(%rax)
movl $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mortennobel[P]glMatrix-vs-GLM-Benchmark/Timer.cpp
// Function: Timer::getElapsedTimeInMicroSec()
double Timer::getElapsedTimeInMicroSec()
{
#ifdef WIN32
    if(!stopped)
        QueryPerformanceCounter(&endCount);

    startTimeInMicroSec = startCount.QuadPart * (1000000.0 / frequency.QuadPart);
    endTimeInMicroSec = endCount.QuadPart * (1000000.0 / frequency.QuadPart);
#else
    if(!stopped)
        gettimeofday(&endCount, NULL);

    startTimeInMicroSec = (startCount.tv_sec * 1000000.0) + startCount.tv_usec;
    endTimeInMicroSec = (endCount.tv_sec * 1000000.0) + endCount.tv_usec;
#endif

    return endTimeInMicroSec - startTimeInMicroSec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x10(%rax)
jne 0x13ab
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1100
movq -0x10(%rbp), %rax
cvtsi2sdq 0x18(%rax), %xmm0
cvtsi2sdq 0x20(%rax), %xmm1
movsd 0x25c45(%rip), %xmm2    # 0x27008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
cvtsi2sdq 0x28(%rax), %xmm0
cvtsi2sdq 0x30(%rax), %xmm1
movsd 0x25c25(%rip), %xmm2    # 0x27008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x8(%rax), %xmm0
subsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: runTestCase(double (*)(long), char*)
void runTestCase(double(*f)(long), char* name){
    double totalTime = 0;
    double minTime = 0;
    double maxTime = 0;
    
    for(int i = 0; i < runCount; ++i) {
        double time = f(internalRunCount);
        if(i == 0) {
            minTime = time;
            maxTime = time;
        } else {
            if(minTime > time) { minTime = time; }
            if(maxTime < time) { maxTime = time; }
        }
        totalTime += time;
    }
    
    double avg = totalTime / runCount;
    
    std::cout<<name<<" - Avg: "<<avg<<"ms, Min: "<<minTime<<"ms, Max: "<<maxTime<<"ms"<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0x103d0(%rip), %eax     # 0x2a0b8
jge 0x19d67
movq -0x8(%rbp), %rax
movq 0x103cb(%rip), %rdi     # 0x2a0c0
callq *%rax
movsd %xmm0, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x19d18
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x19d4a
movsd -0x20(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
jbe 0x19d2e
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x19d48
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x19d4a
movsd -0x38(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x19cdf
movsd -0x18(%rbp), %xmm0
cvtsi2sdl 0x10344(%rip), %xmm1 # 0x2a0b8
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq 0x10250(%rip), %rdi     # 0x29fd8
callq 0x10c0
movq %rax, %rdi
leaq 0xd2d1(%rip), %rsi      # 0x27068
callq 0x10c0
movq %rax, %rdi
movsd -0x40(%rbp), %xmm0
callq 0x1140
movq %rax, %rdi
leaq 0xd2be(%rip), %rsi      # 0x27071
callq 0x10c0
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x1140
movq %rax, %rdi
leaq 0xd2ac(%rip), %rsi      # 0x2707b
callq 0x10c0
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x1140
movq %rax, %rdi
leaq 0xd29a(%rip), %rsi      # 0x27085
callq 0x10c0
movq %rax, %rdi
movq 0x101ce(%rip), %rsi     # 0x29fc8
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: main
int main (int argc, const char * argv[])
{
	if (argc>=2){
		internalRunCount = atoi(argv[1]);
		std::cout<<"InternalRunCount: "<<internalRunCount<<std::endl;
	}
	if (argc>=3){
		runCount = atoi(argv[2]);
		std::cout<<"Run count: "<<runCount<<std::endl;
	}

    /* initialize random seed: */
    srand ( time(NULL) );
        
    int matrixBytes = sizeof(createRandomMatrix());
    
    std::cout<<"Using double precision "<<((matrixBytes>64)?"true":"false")<<std::endl;
    runTestCase(&testMultiplication,"testMultiplication");
    runTestCase(&testTranslation,"testTranslation");
    runTestCase(&testScale,"testScale");
    runTestCase(&testRotationArbitraryAxis,"testRotationArbitraryAxis");
    runTestCase(&testTranspose,"testTranspose");
    runTestCase(&testInverse,"testInverse");    
    runTestCase(&testInverseMat3,"testInverseMat3");    
    runTestCase(&testVectorTransformation,"testVectorTransformation");        

    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jl 0x19e73
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10f0
cltq
movq %rax, 0x1027e(%rip)     # 0x2a0c0
movq 0x1018f(%rip), %rdi     # 0x29fd8
leaq 0xd238(%rip), %rsi      # 0x27088
callq 0x10c0
movq %rax, %rdi
movq 0x10261(%rip), %rsi     # 0x2a0c0
callq 0x1130
movq %rax, %rdi
movq 0x1015a(%rip), %rsi     # 0x29fc8
callq 0x10d0
cmpl $0x3, -0x8(%rbp)
jl 0x19ebc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10f0
movl %eax, 0x1022c(%rip)     # 0x2a0b8
movq 0x10145(%rip), %rdi     # 0x29fd8
leaq 0xd201(%rip), %rsi      # 0x2709b
callq 0x10c0
movq %rax, %rdi
movl 0x10210(%rip), %esi     # 0x2a0b8
callq 0x1110
movq %rax, %rdi
movq 0x10111(%rip), %rsi     # 0x29fc8
callq 0x10d0
xorl %eax, %eax
movl %eax, %edi
callq 0x10a0
movl %eax, %edi
callq 0x10b0
movl $0x40, -0x14(%rbp)
movq 0x100fe(%rip), %rdi     # 0x29fd8
leaq 0xd1c6(%rip), %rsi      # 0x270a7
callq 0x10c0
movq %rax, %rdi
movl -0x14(%rbp), %ecx
leaq 0xd1d1(%rip), %rsi      # 0x270c4
leaq 0xd1c5(%rip), %rax      # 0x270bf
cmpl $0x40, %ecx
cmovgq %rax, %rsi
callq 0x10c0
movq %rax, %rdi
movq 0x100b8(%rip), %rsi     # 0x29fc8
callq 0x10d0
leaq -0xe8dc(%rip), %rdi     # 0xb640
leaq 0xd1a7(%rip), %rsi      # 0x270ca
callq 0x19cb0
leaq -0xb0af(%rip), %rdi     # 0xee80
leaq 0xd1a7(%rip), %rsi      # 0x270dd
callq 0x19cb0
leaq -0x9d72(%rip), %rdi     # 0x101d0
leaq 0xd1a4(%rip), %rsi      # 0x270ed
callq 0x19cb0
leaq -0x8e95(%rip), %rdi     # 0x110c0
leaq 0xd19b(%rip), %rsi      # 0x270f7
callq 0x19cb0
leaq -0x49f8(%rip), %rdi     # 0x15570
leaq 0xd1a2(%rip), %rsi      # 0x27111
callq 0x19cb0
leaq -0x245b(%rip), %rdi     # 0x17b20
leaq 0xd19d(%rip), %rsi      # 0x2711f
callq 0x19cb0
leaq -0x1f7e(%rip), %rdi     # 0x18010
leaq 0xd196(%rip), %rsi      # 0x2712b
callq 0x19cb0
leaq -0x12b1(%rip), %rdi     # 0x18cf0
leaq 0xd193(%rip), %rsi      # 0x2713b
callq 0x19cb0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: angelapwen[P]text-based-game/main.cpp
// Function: main
int main() {
	// Set a random generator seed
	// Referenced from Program 3-32 of C++ Early Objects, 9th Edition
	unsigned seed;

	seed = static_cast<unsigned>(time(nullptr));
	srand(seed);

	// Construct and begin game
	Game game;
	game.startGame();

	// Give player the option to play again
	int repeatChoice = 0;

	do {
		game.repeatMenu();
		repeatChoice = game.intValidation(1,2);

		switch(repeatChoice) {
			case 1: {
				Game repeatGame;
				repeatGame.startGame();
				break;
			}
			case 2:
				break;
			default:
				break;
		}
	} while (repeatChoice != 2);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x31e0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x31f0
leaq -0x98(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x45c0
movq -0x140(%rbp), %rdi
callq 0x5a10
jmp 0x37c7
movl $0x0, -0xa8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x8c80
jmp 0x37df
leaq -0x98(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x86e0
movl %eax, -0x144(%rbp)
jmp 0x37fd
movl -0x144(%rbp), %eax
movl %eax, -0xa8(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x148(%rbp)
subl $0x1, %eax
je 0x383d
jmp 0x381c
movl -0x148(%rbp), %eax
subl $0x2, %eax
je 0x3887
jmp 0x3889
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x38b9
leaq -0x138(%rbp), %rdi
callq 0x45c0
jmp 0x384b
leaq -0x138(%rbp), %rdi
callq 0x5a10
jmp 0x3859
leaq -0x138(%rbp), %rdi
callq 0x8d40
jmp 0x388b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x8d40
jmp 0x38b9
jmp 0x388b
jmp 0x388b
jmp 0x388d
cmpl $0x2, -0xa8(%rbp)
jne 0x37d1
movl $0x0, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x8d40
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
leaq -0x98(%rbp), %rdi
callq 0x8d40
movq -0xa0(%rbp), %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: angelapwen[P]text-based-game/basicSatchel.cpp
// Function: BasicSatchel::printWeapons() const
void BasicSatchel::printWeapons() const {
	if (candlestick) {
		cout << "- candlestick" << endl;
	}
	if (knife) {
		cout << "- knife" << endl;
	}
	if (revolver) {
		cout << "- revolver" << endl;
	}
	if (rope) {
		cout << "- rope" << endl;
	}
	if (wrench) {
		cout << "- wrench" << endl;
	}

	if (pipe) {
		cout << "- pipe" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x14(%rax)
je 0x3e9c
movq 0x1714f(%rip), %rdi     # 0x1afd0
leaq 0xe6ac(%rip), %rsi      # 0x12534
callq 0x3200
movq %rax, %rdi
movq 0x17129(%rip), %rsi     # 0x1afc0
callq 0x3230
movq -0x10(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x3ec8
movq 0x17123(%rip), %rdi     # 0x1afd0
leaq 0xe68e(%rip), %rsi      # 0x12542
callq 0x3200
movq %rax, %rdi
movq 0x170fd(%rip), %rsi     # 0x1afc0
callq 0x3230
movq -0x10(%rbp), %rax
testb $0x1, 0x12(%rax)
je 0x3ef4
movq 0x170f7(%rip), %rdi     # 0x1afd0
leaq 0xe66a(%rip), %rsi      # 0x1254a
callq 0x3200
movq %rax, %rdi
movq 0x170d1(%rip), %rsi     # 0x1afc0
callq 0x3230
movq -0x10(%rbp), %rax
testb $0x1, 0x11(%rax)
je 0x3f20
movq 0x170cb(%rip), %rdi     # 0x1afd0
leaq 0xe649(%rip), %rsi      # 0x12555
callq 0x3200
movq %rax, %rdi
movq 0x170a5(%rip), %rsi     # 0x1afc0
callq 0x3230
movq -0x10(%rbp), %rax
testb $0x1, 0x13(%rax)
je 0x3f4c
movq 0x1709f(%rip), %rdi     # 0x1afd0
leaq 0xe624(%rip), %rsi      # 0x1255c
callq 0x3200
movq %rax, %rdi
movq 0x17079(%rip), %rsi     # 0x1afc0
callq 0x3230
movq -0x10(%rbp), %rax
testb $0x1, 0x15(%rax)
je 0x3f78
movq 0x17073(%rip), %rdi     # 0x1afd0
leaq 0xe601(%rip), %rsi      # 0x12565
callq 0x3200
movq %rax, %rdi
movq 0x1704d(%rip), %rsi     # 0x1afc0
callq 0x3230
addq $0x10, %rsp
popq %rbp
retq
nop
// File: angelapwen[P]text-based-game/eat.cpp
// Function: Eat::action[abi:cxx11]()
std::string Eat::action() {
	cout << "You have come across " << foodItem << "." << endl;
	cout << "What would you like to do?" << endl;
	cout << "1. Do nothing. Food only slows you down." << endl;
	cout << "2. Eat it. This may be your last meal." << endl;

	return Space::action();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x16e26(%rip), %rdi     # 0x1afd0
leaq 0xe3d2(%rip), %rsi      # 0x12583
callq 0x3200
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x80, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0xee79(%rip), %rsi      # 0x1304c
callq 0x3200
movq %rax, %rdi
movq 0x16dde(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x16de2(%rip), %rdi     # 0x1afd0
leaq 0xe3a4(%rip), %rsi      # 0x12599
callq 0x3200
movq %rax, %rdi
movq 0x16dbc(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x16dc0(%rip), %rdi     # 0x1afd0
leaq 0xe39d(%rip), %rsi      # 0x125b4
callq 0x3200
movq %rax, %rdi
movq 0x16d9a(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x16d9e(%rip), %rdi     # 0x1afd0
leaq 0xe3a4(%rip), %rsi      # 0x125dd
callq 0x3200
movq %rax, %rdi
movq 0x16d78(%rip), %rsi     # 0x1afc0
callq 0x3230
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe280
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: angelapwen[P]text-based-game/entertain.cpp
// Function: Entertain::action[abi:cxx11]()
std::string Entertain::action() {
	cout << "You have come across " << gameItem << "." << endl;
	cout << "What would you like to do?" << endl;
	cout << "1. Do nothing. It's too dangerous." << endl;
	cout << "2. You're under a lot of pressure. Entertain yourself for a bit. "
			<< endl;

	return Space::action();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x16b46(%rip), %rdi     # 0x1afd0
leaq 0xe0f2(%rip), %rsi      # 0x12583
callq 0x3200
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x80, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0xeb99(%rip), %rsi      # 0x1304c
callq 0x3200
movq %rax, %rdi
movq 0x16afe(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x16b02(%rip), %rdi     # 0x1afd0
leaq 0xe0c4(%rip), %rsi      # 0x12599
callq 0x3200
movq %rax, %rdi
movq 0x16adc(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x16ae0(%rip), %rdi     # 0x1afd0
leaq 0xe112(%rip), %rsi      # 0x12609
callq 0x3200
movq %rax, %rdi
movq 0x16aba(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x16abe(%rip), %rdi     # 0x1afd0
leaq 0xe113(%rip), %rsi      # 0x1262c
callq 0x3200
movq %rax, %rdi
movq 0x16a98(%rip), %rsi     # 0x1afc0
callq 0x3230
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe280
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: angelapwen[P]text-based-game/game.cpp
// Function: Game::intValidation(int, int) const
int Game::intValidation(int min, int max) const {
	int input;
	cin >> input;

	// Try again if input is out of range or fails
	while (input < min || input > max || cin.fail()) {
		cout << "Input must be an integer between " << min << " and "
		     << max << "." << endl;
		cout << "Please try again: ";
		cin.clear();
		cin.ignore(256, '\n');
		cin >> input;
	}

	// Flush buffer after successful input
	cin.clear();
	cin.ignore(256, '\n');

	return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0x128e7(%rip), %rdi     # 0x1afe0
leaq -0x14(%rbp), %rsi
callq 0x3120
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0x15(%rbp)
jl 0x8739
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0x10(%rbp), %ecx
movb %al, -0x15(%rbp)
jg 0x8739
movq 0x128bd(%rip), %rax     # 0x1afe0
movq (%rax), %rax
movq 0x128b3(%rip), %rdi     # 0x1afe0
addq -0x18(%rax), %rdi
callq 0x3030
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x8745
jmp 0x87f5
movq 0x12884(%rip), %rdi     # 0x1afd0
leaq 0xbf30(%rip), %rsi      # 0x14683
callq 0x3200
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3360
movq %rax, %rdi
leaq 0xbf38(%rip), %rsi      # 0x146a5
callq 0x3200
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x3360
movq %rax, %rdi
leaq 0xa8c5(%rip), %rsi      # 0x1304c
callq 0x3200
movq %rax, %rdi
movq 0x1282a(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x1282e(%rip), %rdi     # 0x1afd0
leaq 0xbf02(%rip), %rsi      # 0x146ab
callq 0x3200
movq 0x1282b(%rip), %rax     # 0x1afe0
movq (%rax), %rax
movq 0x12821(%rip), %rdi     # 0x1afe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x3350
movq 0x1280f(%rip), %rdi     # 0x1afe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x3140
movq 0x127f9(%rip), %rdi     # 0x1afe0
leaq -0x14(%rbp), %rsi
callq 0x3120
jmp 0x8702
movq 0x127e4(%rip), %rax     # 0x1afe0
movq (%rax), %rax
movq 0x127da(%rip), %rdi     # 0x1afe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x3350
movq 0x127c8(%rip), %rdi     # 0x1afe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x3140
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: angelapwen[P]text-based-game/game.cpp
// Function: Game::repeatMenu() const
void Game::repeatMenu() const {
	cout << "\n\t PLAY AGAIN?" << endl;
	cout << "1. Try your hand at joining Hydra again." << endl;
	cout << "** Remember: the room with the secret escape changes for each "
			"trial." << endl;
	cout << "2. Exit the program." << endl;
	cout << "Make your choice: " << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1233d(%rip), %rdi     # 0x1afd0
leaq 0xbe06(%rip), %rsi      # 0x14aa0
callq 0x3200
movq %rax, %rdi
movq 0x12317(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x1231b(%rip), %rdi     # 0x1afd0
leaq 0xbdf3(%rip), %rsi      # 0x14aaf
callq 0x3200
movq %rax, %rdi
movq 0x122f5(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x122f9(%rip), %rdi     # 0x1afd0
leaq 0xbdfa(%rip), %rsi      # 0x14ad8
callq 0x3200
movq %rax, %rdi
movq 0x122d3(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x122d7(%rip), %rdi     # 0x1afd0
leaq 0xbe1d(%rip), %rsi      # 0x14b1d
callq 0x3200
movq %rax, %rdi
movq 0x122b1(%rip), %rsi     # 0x1afc0
callq 0x3230
movq 0x122b5(%rip), %rdi     # 0x1afd0
leaq 0xbc38(%rip), %rsi      # 0x1495a
callq 0x3200
movq %rax, %rdi
movq 0x1228f(%rip), %rsi     # 0x1afc0
callq 0x3230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: angelapwen[P]text-based-game/game.cpp
// Function: Game::~Game()
Game::~Game() {
	delete satchel;
	delete map;

	// Free memory for all rooms
	delete study;
	delete library;
	delete billiards;
	delete conservatory;
	delete ballroom;
	delete kitchen;
	delete dining;
	delete lounge;
	delete hall;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8d6c
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8d8b
movq -0x20(%rbp), %rdi
movl $0x591, %esi            # imm = 0x591
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8da7
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8dc3
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x8ddf
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x8dfb
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x8e17
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x8e33
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x8e4f
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x8e6b
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x8e87
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x3130
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: angelapwen[P]text-based-game/map.cpp
// Function: Map::clearPlayer()
void Map::clearPlayer() {
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 57; j++) {
			if (board[i][j] == '*') {
				board[i][j] = ' ';
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0xa477
movl $0x0, -0x10(%rbp)
cmpl $0x39, -0x10(%rbp)
jge 0xa46a
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x39, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0xa45d
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x39, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb $0x20, (%rax,%rcx)
jmp 0xa45f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa424
jmp 0xa46c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa417
popq %rbp
retq
nopl (%rax)
// File: angelapwen[P]text-based-game/map.cpp
// Function: Map::printBoard() const
void Map::printBoard() const {
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 57; j++) {
			std::cout << board[i][j];
		}
		std::cout << std::endl;
	}
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0xa6aa
movl $0x0, -0x10(%rbp)
cmpl $0x39, -0x10(%rbp)
jge 0xa68c
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x39, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq 0x10958(%rip), %rdi     # 0x1afd0
movsbl (%rax,%rcx), %esi
callq 0x3280
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa658
movq 0x1093d(%rip), %rdi     # 0x1afd0
movq 0x10926(%rip), %rsi     # 0x1afc0
callq 0x3230
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa64b
movq 0x1091f(%rip), %rdi     # 0x1afd0
movq 0x10908(%rip), %rsi     # 0x1afc0
callq 0x3230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: angelapwen[P]text-based-game/quiet.cpp
// Function: Quiet::action[abi:cxx11]()
std::string Quiet::action() {
	cout << "You notice " << quietItem << " nearby." << endl;
	cout << "Would you like to use it for some peace and quiet?" << endl;
	cout << "1. Yes, it's a good time for me to relax." << endl;
	cout << "2. No, that sounds like a bad idea." << endl;

	return Space::action();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xddd6(%rip), %rdi      # 0x1afd0
leaq 0x8087(%rip), %rsi      # 0x15288
callq 0x3200
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x80, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0x8071(%rip), %rsi      # 0x15294
callq 0x3200
movq %rax, %rdi
movq 0xdd8e(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xdd92(%rip), %rdi      # 0x1afd0
leaq 0x8058(%rip), %rsi      # 0x1529d
callq 0x3200
movq %rax, %rdi
movq 0xdd6c(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xdd70(%rip), %rdi      # 0x1afd0
leaq 0x8069(%rip), %rsi      # 0x152d0
callq 0x3200
movq %rax, %rdi
movq 0xdd4a(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xdd4e(%rip), %rdi      # 0x1afd0
leaq 0x8071(%rip), %rsi      # 0x152fa
callq 0x3200
movq %rax, %rdi
movq 0xdd28(%rip), %rsi      # 0x1afc0
callq 0x3230
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe280
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: angelapwen[P]text-based-game/satchel.cpp
// Function: Satchel::clearContents()
void Satchel::clearContents() {
	candlestick = rope = revolver = pipe = knife = wrench = false;
	numUniqueWeapons = 0;
	cout << "Uh oh! You dropped your satchel, butterfingers!" << endl;
	cout << "Someone might be coming." << endl;
	cout << "Pick up your satchel and forget the weapons." << endl;
	cout << "Hydra will take care of them." << endl;
	cout << "\nPress enter to pick up your satchel and hide." << endl;
	getchar();
	cout << "The footsteps you heard fade away. Phew!" << endl;
	cout << "Unfortunately, however, your satchel is now empty.\n" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x13(%rax)
movb $0x0, 0x10(%rax)
movb $0x0, 0x15(%rax)
movb $0x0, 0x12(%rax)
movb $0x0, 0x11(%rax)
movb $0x0, 0x14(%rax)
movl $0x0, 0xc(%rax)
movq 0xda9a(%rip), %rdi      # 0x1afd0
leaq 0x7e13(%rip), %rsi      # 0x15350
callq 0x3200
movq %rax, %rdi
movq 0xda74(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xda78(%rip), %rdi      # 0x1afd0
leaq 0x7e21(%rip), %rsi      # 0x15380
callq 0x3200
movq %rax, %rdi
movq 0xda52(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xda56(%rip), %rdi      # 0x1afd0
leaq 0x7e18(%rip), %rsi      # 0x15399
callq 0x3200
movq %rax, %rdi
movq 0xda30(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xda34(%rip), %rdi      # 0x1afd0
leaq 0x7e23(%rip), %rsi      # 0x153c6
callq 0x3200
movq %rax, %rdi
movq 0xda0e(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xda12(%rip), %rdi      # 0x1afd0
leaq 0x7e1f(%rip), %rsi      # 0x153e4
callq 0x3200
movq %rax, %rdi
movq 0xd9ec(%rip), %rsi      # 0x1afc0
callq 0x3230
callq 0x3300
movq 0xd9eb(%rip), %rdi      # 0x1afd0
leaq 0x7e27(%rip), %rsi      # 0x15413
callq 0x3200
movq %rax, %rdi
movq 0xd9c5(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xd9c9(%rip), %rdi      # 0x1afd0
leaq 0x7e2e(%rip), %rsi      # 0x1543c
callq 0x3200
movq %rax, %rdi
movq 0xd9a3(%rip), %rsi      # 0x1afc0
callq 0x3230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: angelapwen[P]text-based-game/satchel.cpp
// Function: Satchel::getNumUniqueWeapons()
int Satchel::getNumUniqueWeapons() {
	// Reset unique weapon count
	numUniqueWeapons = 0;

	if (knife) {
		numUniqueWeapons++;
	}
	if (wrench) {
		numUniqueWeapons++;
	}
	if (rope) {
		numUniqueWeapons++;
	}
	if (pipe) {
		numUniqueWeapons++;
	}
	if (revolver) {
		numUniqueWeapons++;
	}
	if (candlestick) {
		numUniqueWeapons++;
	}
	return numUniqueWeapons;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, 0xc(%rax)
testb $0x1, 0x10(%rax)
je 0xd65a
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x13(%rax)
je 0xd671
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x11(%rax)
je 0xd688
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x15(%rax)
je 0xd69f
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x12(%rax)
je 0xd6b6
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0xd6cd
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: angelapwen[P]text-based-game/space.cpp
// Function: Space::Space()
Space::Space() {
	name = "default";
	weapon = "default";
	top = right = left = bottom = corner = nullptr;
	newMove = nullptr;
	cornerAccess = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0xd60d(%rip), %rax      # 0x1ad28
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x20(%rbp)
callq 0x32f0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x32f0
movq -0x20(%rbp), %rdi
leaq 0x4e34(%rip), %rsi      # 0x1257b
callq 0x32e0
jmp 0xd74e
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
leaq 0x4e1e(%rip), %rsi      # 0x1257b
callq 0x32e0
jmp 0xd764
movq -0x30(%rbp), %rax
movq $0x0, 0x68(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x70(%rax)
movb $0x0, 0x78(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3130
movq -0x20(%rbp), %rdi
callq 0x3130
movq -0x10(%rbp), %rdi
callq 0x3370
nopl (%rax)
// File: angelapwen[P]text-based-game/space.cpp
// Function: Space::Space(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Space::Space(string nameIn, string weaponIn) {
	name = nameIn;
	weapon = weaponIn;
	top = right = left = bottom = corner = nullptr;
	newMove = nullptr;
	cornerAccess = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq 0xd52d(%rip), %rax      # 0x1ad28
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x32f0
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x32f0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3050
jmp 0xd82b
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x3050
jmp 0xd83e
movq -0x48(%rbp), %rax
movq $0x0, 0x68(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x70(%rax)
movb $0x0, 0x78(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3130
movq -0x38(%rbp), %rdi
callq 0x3130
movq -0x20(%rbp), %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
// File: angelapwen[P]text-based-game/space.cpp
// Function: Space::setCornerAccess(char)
void Space::setCornerAccess (char access) {
	if (access == 'y') {
		cornerAccess = true;
	}
	else {
		cornerAccess = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x79, %eax
jne 0xda09
movq -0x18(%rbp), %rax
movb $0x1, 0x78(%rax)
jmp 0xda11
movq -0x18(%rbp), %rax
movb $0x0, 0x78(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: angelapwen[P]text-based-game/space.cpp
// Function: Space::action[abi:cxx11]()
std::string Space::action() {
	string received;

	int actionChoice = intValidation(1, 2);

	switch (actionChoice) {
		case 1:
			// User made the "wrong" choice and does not receive a weapon
			received = "none";
			break;
		case 2:
			// Return the string of the weapon that the current Space includes
			received = weapon;
			break;
		default:
			break;
	}

	return received;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x32f0
movq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0xe350
movl %eax, -0x28(%rbp)
jmp 0xe2c4
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x1, %eax
je 0xe2f8
jmp 0xe2d7
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0xe30c
jmp 0xe321
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3130
jmp 0xe340
movq -0x40(%rbp), %rdi
leaq 0x471a(%rip), %rsi      # 0x12a1d
callq 0x32e0
jmp 0xe30a
jmp 0xe323
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x28, %rsi
callq 0x3050
jmp 0xe31f
jmp 0xe323
jmp 0xe323
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xe336
movq -0x40(%rbp), %rdi
callq 0x3130
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3370
nopl (%rax)
// File: angelapwen[P]text-based-game/space.cpp
// Function: Space::intValidation(int, int)
int Space::intValidation(int min, int max) {
	cout << "Make your choice: ";

	int input;
	cin >> input;

	// Try again if input is out of range or fails
	while (input < min || input > max || cin.fail()) {
		cout << "Input must be an integer between " << min << " and "
		     << max << "." << endl;
		cout << "Please try again: ";
		cin.clear();
		cin.ignore(256, '\n');
		cin >> input;
	}

	// Flush buffer after successful input
	cin.clear();
	cin.ignore(256, '\n');

	return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0xcc67(%rip), %rdi      # 0x1afd0
leaq 0x65ea(%rip), %rsi      # 0x1495a
callq 0x3200
movq 0xcc64(%rip), %rdi      # 0x1afe0
leaq -0x14(%rbp), %rsi
callq 0x3120
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0x15(%rbp)
jl 0xe3bc
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0x10(%rbp), %ecx
movb %al, -0x15(%rbp)
jg 0xe3bc
movq 0xcc3a(%rip), %rax      # 0x1afe0
movq (%rax), %rax
movq 0xcc30(%rip), %rdi      # 0x1afe0
addq -0x18(%rax), %rdi
callq 0x3030
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xe3c8
jmp 0xe478
movq 0xcc01(%rip), %rdi      # 0x1afd0
leaq 0x62ad(%rip), %rsi      # 0x14683
callq 0x3200
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3360
movq %rax, %rdi
leaq 0x62b5(%rip), %rsi      # 0x146a5
callq 0x3200
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x3360
movq %rax, %rdi
leaq 0x4c42(%rip), %rsi      # 0x1304c
callq 0x3200
movq %rax, %rdi
movq 0xcba7(%rip), %rsi      # 0x1afc0
callq 0x3230
movq 0xcbab(%rip), %rdi      # 0x1afd0
leaq 0x627f(%rip), %rsi      # 0x146ab
callq 0x3200
movq 0xcba8(%rip), %rax      # 0x1afe0
movq (%rax), %rax
movq 0xcb9e(%rip), %rdi      # 0x1afe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x3350
movq 0xcb8c(%rip), %rdi      # 0x1afe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x3140
movq 0xcb76(%rip), %rdi      # 0x1afe0
leaq -0x14(%rbp), %rsi
callq 0x3120
jmp 0xe385
movq 0xcb61(%rip), %rax      # 0x1afe0
movq (%rax), %rax
movq 0xcb57(%rip), %rdi      # 0x1afe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x3350
movq 0xcb45(%rip), %rdi      # 0x1afe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x3140
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: angelapwen[P]text-based-game/vectorSatchel.cpp
// Function: VectorSatchel::randomDrop()
void VectorSatchel::randomDrop() {
	// Randomly shuffle the contents of vector
	std::random_shuffle(satchel.begin(),satchel.end());

	cout << "A " << satchel.back() << " has been selected at random for you "
												 "to drop." << endl;

	// Delete last element
	satchel.pop_back();

	// Update weapon status after one was deleted
	updateWeapons();

	// Print current weapons
	cout << "Your current weapon list is:" << endl;
	printWeapons();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x18, %rdi
callq 0xed50
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x18, %rdi
callq 0xed80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xec80
movq 0xc74a(%rip), %rdi      # 0x1afd0
leaq 0x6f0b(%rip), %rsi      # 0x15798
callq 0x3200
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0xedb0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0x6ee2(%rip), %rsi      # 0x1579b
callq 0x3200
movq %rax, %rdi
movq 0xc6f8(%rip), %rsi      # 0x1afc0
callq 0x3230
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0xedf0
movq -0x20(%rbp), %rdi
callq 0xe920
movq 0xc6e6(%rip), %rdi      # 0x1afd0
leaq 0x68d0(%rip), %rsi      # 0x151c1
callq 0x3200
movq %rax, %rdi
movq 0xc6c0(%rip), %rsi      # 0x1afc0
callq 0x3230
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: angelapwen[P]text-based-game/vectorSatchel.cpp
// Function: VectorSatchel::updateWeapons()
void VectorSatchel::updateWeapons() {
	// Sort bag for binary search
	std::sort(satchel.begin(),satchel.end());

	// Search for each weapon type in bag and set bool flag to false if not found
	if (!std::binary_search(satchel.begin(),satchel.end(),"knife")) {
		knife = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"wrench")) {
		wrench = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"rope")) {
		rope = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"pipe")) {
		pipe = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"revolver")) {
		revolver = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"candlestick")) {
		candlestick = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x18, %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x18, %rdi
callq 0xed80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xee20
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0xed80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x3bb1(%rip), %rdx      # 0x12544
callq 0xee60
testb $0x1, %al
jne 0xe9a4
movq -0x80(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0xed80
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x3b89(%rip), %rdx      # 0x1255e
callq 0xeef0
testb $0x1, %al
jne 0xe9e6
movq -0x80(%rbp), %rax
movb $0x0, 0x13(%rax)
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0xed80
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq 0x3b40(%rip), %rdx      # 0x12557
callq 0xef80
testb $0x1, %al
jne 0xea28
movq -0x80(%rbp), %rax
movb $0x0, 0x11(%rax)
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0xed80
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq 0x3b0e(%rip), %rdx      # 0x12567
callq 0xef80
testb $0x1, %al
jne 0xea6a
movq -0x80(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x18, %rdi
callq 0xed80
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
leaq 0x3ab1(%rip), %rdx      # 0x1254c
callq 0xf010
testb $0x1, %al
jne 0xeaac
movq -0x80(%rbp), %rax
movb $0x0, 0x12(%rax)
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x18, %rdi
callq 0xed80
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq 0x3a59(%rip), %rdx      # 0x12536
callq 0xf0a0
testb $0x1, %al
jne 0xeaee
movq -0x80(%rbp), %rax
movb $0x0, 0x14(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/robin_hood/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	robin_hood::unordered_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
#ifndef UDB2_TEST_DEL
		z += ++h[get_key(n, x)];
#else
		auto p = h.try_emplace(get_key(n, x), i);
		if (p.second == false) h.erase(p.first);
#endif
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0xd8, %rsp
movl %edi, 0xd4(%rsp)
movl %esi, 0xd0(%rsp)
movl $0x0, 0xc4(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x17d0
movl $0x0, 0xcc(%rsp)
movl 0xd0(%rsp), %eax
movl %eax, 0xc8(%rsp)
movl 0xcc(%rsp), %eax
cmpl 0xd4(%rsp), %eax
jae 0x1742
movl 0xc8(%rsp), %edi
callq 0x12a0
movl %eax, 0x2c(%rsp)
jmp 0x166c
movl 0x2c(%rsp), %eax
movl %eax, 0xc8(%rsp)
movl 0xd4(%rsp), %edi
movl 0xc8(%rsp), %esi
callq 0x1310
movl %eax, 0x28(%rsp)
jmp 0x1690
movl 0x28(%rsp), %eax
movl %eax, 0x5c(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x5c(%rsp), %rdx
leaq 0xcc(%rsp), %rcx
callq 0x1840
jmp 0x16b9
movb 0x70(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x172a
movups 0x60(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0x1880
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x16f4
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
jmp 0x172a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1930
jmp 0x17a5
jmp 0x172c
movl 0xcc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xcc(%rsp)
jmp 0x1646
movq 0x4897(%rip), %rax      # 0x5fe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1920
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0xc4(%rsp), %ecx
leaq 0x2911(%rip), %rsi      # 0x4085
movb $0x0, %al
callq 0x10f0
leaq 0x88(%rsp), %rdi
callq 0x1920
movl %eax, 0x14(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1930
movl 0x14(%rsp), %eax
addq $0xd8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::erase(robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::Iter<false>)
iterator erase(iterator pos) {
        ROBIN_HOOD_TRACE(this)
        // we assume that pos always points to a valid entry, and not end().
        auto const idx = static_cast<size_t>(pos.mKeyVals - mKeyVals);

        shiftDown(idx);
        --mNumElements;

        if (*pos.mInfo) {
            // we've backward shifted, return this again
            return pos;
        }

        // no backward shift, return next element
        return ++pos;
    }

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rdi), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x2f50
movq (%rsp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
je 0x18eb
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1906
leaq 0x18(%rsp), %rdi
callq 0x3000
movq (%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::destroy()
void destroy() {
        if (0 == mMask) {
            // don't deallocate!
            return;
        }

        Destroyer<Self, IsFlat && std::is_trivially_destructible<Node>::value>{}
            .nodesDoNotDeallocate(*this);

        // This protection against not deleting mMask shouldn't be needed as it's sufficiently
        // protected with the 0==mMask check, but I have this anyways because g++ 7 otherwise
        // reports a compile error: attempt to free a non-heap object 'fm'
        // [-Werror=free-nonheap-object]
        if (mKeyVals != reinterpret_cast_no_cast_align_warning<Node*>(&mMask)) {
            ROBIN_HOOD_LOG("std::free")
            std::free(mKeyVals);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
jne 0x197d
jmp 0x19be
movq 0x10(%rsp), %rsi
leaq 0x1f(%rsp), %rdi
callq 0x19e0
movq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
callq 0x1950
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x19be
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x10c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::throwOverflowError() const
void throwOverflowError() const {
#if ROBIN_HOOD(HAS_EXCEPTIONS)
        throw std::overflow_error("robin_hood::map overflow");
#else
        abort();
#endif
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x10, %edi
callq 0x1080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x20b2(%rip), %rsi      # 0x40a7
callq 0x1040
jmp 0x1ffc
movq 0x8(%rsp), %rdi
movq 0x3fa8(%rip), %rsi      # 0x5fb0
movq 0x3f91(%rip), %rdx      # 0x5fa0
callq 0x1110
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x10b0
movq 0x18(%rsp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: void robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::keyToIdx<unsigned int&>(unsigned int&, unsigned long*, unsigned int*) const
void keyToIdx(HashKey&& key, size_t* idx, InfoType* info) const {
        // In addition to whatever hash is used, add another mul & shift so we get better hashing.
        // This serves as a bad hash prevention, if the given data is
        // badly mixed.
        auto h = static_cast<uint64_t>(WHash::operator()(key));

        h *= mHashMultiplier;
        h ^= h >> 33U;

        // the lower InitialInfoNumBits are reserved for info.
        *info = mInfoInc + static_cast<InfoType>((h & InfoMask) >> mInfoHashShift);
        *idx = (static_cast<size_t>(h) >> InitialInfoNumBits) & mMask;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %esi
callq 0x2490
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
imulq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rcx
shrq $0x21, %rcx
xorq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x30(%rax), %edx
movq 0x10(%rsp), %rsi
andq $0x1f, %rsi
movl 0x34(%rax), %ecx
shrq %cl, %rsi
movq %rsi, %rcx
addl %ecx, %edx
movq 0x18(%rsp), %rcx
movl %edx, (%rcx)
movq 0x10(%rsp), %rcx
shrq $0x5, %rcx
andq 0x20(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop