LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Backpack.cpp
// Function: Backpack::displayFormula()
void Backpack::displayFormula()
{
    std::cout << PROLOGUE_COLOR
              << "\nNEUTRALIZATION FORMULA"
              << "\n-quadriprohyl alcohol"
              << "\n-ecitobeniphal"
              << "\n-black iron oxide"
              << "\n-tricarbonated liquid"
              << "\n-injection device\n" << RESET << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xca3b(%rip), %rdi      # 0x15fc8
leaq 0x6b3b(%rip), %rsi      # 0x100cf
callq 0x31d0
leaq 0x6bd3(%rip), %rsi      # 0x10173
movq %rax, %rdi
callq 0x31d0
leaq 0x6bdc(%rip), %rsi      # 0x1018b
movq %rax, %rdi
callq 0x31d0
leaq 0x6be4(%rip), %rsi      # 0x101a2
movq %rax, %rdi
callq 0x31d0
leaq 0x6be5(%rip), %rsi      # 0x101b2
movq %rax, %rdi
callq 0x31d0
leaq 0x6be9(%rip), %rsi      # 0x101c5
movq %rax, %rdi
callq 0x31d0
leaq 0x6bf1(%rip), %rsi      # 0x101dc
movq %rax, %rdi
callq 0x31d0
leaq 0x6ab9(%rip), %rsi      # 0x100b3
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Backpack.cpp
// Function: Backpack::menu()
void Backpack::menu()
{
    if (contents.empty())
    {
        printContents();
        //no need for options if pack is empty
        return;
    }

    int input = 0;

    while (true)
    {
        printContents();
        std::cout << "1. Discard Items...\n"
                  << "2. Show neutralization formula\n"
                  << "3. Return" << std::endl;

        input = getInteger();

        if (input == 3)
        {
            return;
        }

        if (input == 2)
        {
            displayFormula();
            wait(SHORT);
        }

        if (input == 1)
        {
            discardMenu();
            return;
        }

        input = 0;
    }





}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x969d
movq 0xc99b(%rip), %r14      # 0x15fc8
leaq 0x6b00(%rip), %r15      # 0x10134
leaq 0x6b0e(%rip), %r12      # 0x10149
leaq 0x6b27(%rip), %r13      # 0x10169
movq %rbx, %rdi
callq 0x92ac
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %rdi
movq %r13, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
callq 0xaed4
cmpl $0x2, %eax
je 0x9689
cmpl $0x1, %eax
je 0x96c2
cmpl $0x3, %eax
jne 0x9642
jmp 0x96b3
callq 0x9582
movsd 0x6972(%rip), %xmm0     # 0x10008
callq 0xbaf9
jmp 0x9642
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x92ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9378
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Bridge.cpp
// Function: Bridge::Bridge()
Bridge::Bridge()
{
    //set up room
    this->roomName = "Bridge";
    occupant = new Harper;

    roomItems.push_back("handgun");
    roomItems.push_back("escape pod codes");
    roomItems.push_back("photos of you and Holly");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xe2ec
leaq 0xbb84(%rip), %rax      # 0x15970
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x6441(%rip), %rsi      # 0x1023b
callq 0x3340
pushq $0x68
popq %rdi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0xd9c8
movq %r15, 0x8(%rbx)
leaq 0x6236(%rip), %rsi      # 0x10053
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq 0x30(%rbx), %r14
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
leaq 0x6211(%rip), %rsi      # 0x1005b
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
leaq 0x63cf(%rip), %rsi      # 0x10242
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9ea8
jmp 0x9ec5
jmp 0x9ea8
jmp 0x9ec5
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3368
jmp 0x9ec8
jmp 0x9ec5
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0x9ec8
movq %rax, %r14
movq %rbx, %rdi
callq 0xe31a
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/CaptainsQuarters.cpp
// Function: CaptainsQuarters::CaptainsQuarters()
CaptainsQuarters::CaptainsQuarters()
{
    //set up room
    this->roomName = "Captain's Quarters";
    occupant = new Holly;

    roomItems.push_back(keyCard);
    roomItems.push_back(captainsQIngredient);
    roomItems.push_back("sour candy ration");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xe2ec
leaq 0xb648(%rip), %rax      # 0x159d0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x6003(%rip), %rsi      # 0x10399
callq 0x3340
pushq $0x68
popq %rdi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0xda44
movq %r15, 0x8(%rbx)
leaq 0x30(%rbx), %r14
leaq 0xc1d3(%rip), %rsi      # 0x16590
movq %r14, %rdi
callq 0x97ca
leaq 0xc124(%rip), %rsi      # 0x164f0
movq %r14, %rdi
callq 0x97ca
leaq 0x5fd1(%rip), %rsi      # 0x103ac
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3368
jmp 0xa428
jmp 0xa425
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0xa428
movq %rax, %r14
movq %rbx, %rdi
callq 0xe31a
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/CrewQuarters.cpp
// Function: CrewQuarters::CrewQuarters()
CrewQuarters::CrewQuarters()
{
    //set up room
    this->roomName = "Crew Quarters";
    occupant = new Nate;

    roomItems.push_back("dumbbells");
    roomItems.push_back(crewQIngredient);
    roomItems.push_back("reading glasses");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xe2ec
leaq 0xae6c(%rip), %rax      # 0x15ac0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x57ca(%rip), %rsi      # 0x1042c
callq 0x3340
pushq $0x68
popq %rdi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0xe1c8
movq %r15, 0x8(%rbx)
leaq 0x57b5(%rip), %rsi      # 0x1043a
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq 0x30(%rbx), %r14
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
leaq 0xbcae(%rip), %rsi      # 0x16960
movq %r14, %rdi
callq 0x97ca
leaq 0x5783(%rip), %rsi      # 0x10444
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xacf2
jmp 0xad0f
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3368
jmp 0xad12
jmp 0xad0f
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0xad12
movq %rax, %r14
movq %rbx, %rdi
callq 0xe31a
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: getLetters[abi:cxx11]()
std::string getLetters()
{
    std::string input;

	while(true)
    {
        bool check = true;
		std::getline(std::cin, input); //get string input

        //make sure they only entered letters
        for (unsigned int i = 0; i < input.size(); i++)
        {
            if (!isalpha(input[i]))
            {
                check = false;
            }
        }
        if (!check)
        {
            std::cout << "Please enter letters only.  Try again:" << std::endl;
        }
        else
        {
            //std::cin.ignore(std::numeric_limits<std::streamsize>::max());
            return input;
        }

		std::cin.clear();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0xb240(%rip), %rbx      # 0x15fd8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3030
movq (%r15), %r13
movq %r15, %rbx
movq 0x8(%r15), %r15
xorl %eax, %eax
movb $0x1, %r12b
movl %eax, %r14d
cmpq %r14, %r15
jbe 0xadd3
movsbl (%r13,%r14), %edi
callq 0x32a0
testl %eax, %eax
setne %al
andb %al, %r12b
leal 0x1(%r14), %eax
jmp 0xadb2
testb $0x1, %r12b
jne 0xae11
movq 0xb1e8(%rip), %rdi      # 0x15fc8
leaq 0x5699(%rip), %rsi      # 0x10480
movq %rbx, %r15
callq 0x31d0
movq 0xb1e2(%rip), %rbx      # 0x15fd8
movq %rax, %rdi
callq 0x30f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x32e0
jmp 0xad98
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x3368
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: getYesNo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char getYesNo(std::string prompt)
{
    std::cout << prompt << std::endl;
    char yesOrNo;
	std::cin >> yesOrNo;
    std::cin.clear();
    std::cin.ignore(LARGE_NUMBER, '\n');

	yesOrNo = toupper(yesOrNo);

	while (yesOrNo != 'Y' && yesOrNo != 'N')
	{
		std::cout << "Invalid input, please enter [y/n]: ";
		std::cin >> yesOrNo;
        std::cin.clear();
        std::cin.ignore(LARGE_NUMBER, '\n');
		yesOrNo = toupper(yesOrNo);
	}

    return yesOrNo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rsi
movq 0xb17a(%rip), %rbx      # 0x15fc8
movq %rbx, %rdi
callq 0x31b0
movq %rax, %rdi
callq 0x30f0
movq 0xb173(%rip), %r14      # 0x15fd8
leaq -0x29(%rbp), %r15
pushq $0xa
popq %r12
leaq 0x5633(%rip), %r13      # 0x104a7
movq %r14, %rdi
movq %r15, %rsi
callq 0x3230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x32e0
movl $0x186a0, %esi          # imm = 0x186A0
movq %r14, %rdi
movl %r12d, %edx
callq 0x3130
movsbl -0x29(%rbp), %edi
callq 0x3320
movb %al, -0x29(%rbp)
cmpb $0x4e, %al
je 0xaec5
movzbl %al, %ecx
cmpl $0x59, %ecx
je 0xaec5
movq %rbx, %rdi
movq %r13, %rsi
callq 0x31d0
jmp 0xae74
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: getInteger()
int getInteger()
{
    int input;
	std::string stringNumber;

    while(true)
	{
        std::getline(std::cin, stringNumber); //get string input
		std::stringstream convert(stringNumber); //turns the string into stream

		if(convert >> input) //Try to convert to a number
		{
			std::string leftovers;
			std::getline(convert,leftovers); //Reads the rest from the input

			if(leftovers == "") //If leftovers is empty, we have a correct number
			{
                //std::cin.ignore(std::numeric_limits<std::streamsize>::max());
				return input;
			}
            else
            {
				std::cout << "Please enter a valid integer." << std::endl;
			}
		}
        else
        {
			std::cout << "Please enter a valid integer." << std::endl;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x70(%rbp), %r14
leaq -0x1f8(%rbp), %r15
leaq -0x30(%rbp), %r13
leaq -0x50(%rbp), %rbx
movq 0xb0c6(%rip), %rdi      # 0x15fd8
movq %r14, %rsi
callq 0x3030
movq %r15, %rdi
movq %r14, %rsi
pushq $0x18
popq %rdx
callq 0x3290
movq %r15, %rdi
movq %r13, %rsi
callq 0x3120
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0xaf61
movq 0xb080(%rip), %rdi      # 0x15fc8
leaq 0x557c(%rip), %rsi      # 0x104cb
callq 0x31d0
movb $0x1, %r12b
movq %rax, %rdi
callq 0x30f0
jmp 0xafc2
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3030
movq %rbx, %rdi
leaq 0x599e(%rip), %rsi      # 0x10925
callq 0xbcb4
movl %eax, %r12d
testb %al, %al
je 0xaf9b
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xafb6
movq 0xb026(%rip), %rdi      # 0x15fc8
leaq 0x5522(%rip), %rsi      # 0x104cb
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3368
xorb $0x1, %r12b
movq %r15, %rdi
callq 0x3170
testb %r12b, %r12b
jne 0xaf0b
leaq -0x70(%rbp), %rdi
callq 0x3368
movl -0x2c(%rbp), %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3368
jmp 0xb009
jmp 0xb001
movq %rax, %rbx
jmp 0xb015
movq %rax, %rbx
leaq -0x1f8(%rbp), %rdi
callq 0x3170
leaq -0x70(%rbp), %rdi
callq 0x3368
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: getDouble()
double getDouble()
{
    double input;

	while(true)
    {
        if (std::cin >> input)
        {
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            return input;
        }
        else
        {
            std::cerr << "Please enter a valid number."  << std::endl;
            std::cin.clear(); //in case an error occurs with cin
            while (std::cin.get() != '\n');  //empty loop
        }

	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0xae31(%rip), %rbx      # 0x15fd8
leaq -0x28(%rbp), %r14
movq 0xae3e(%rip), %r15      # 0x15ff0
leaq 0x5330(%rip), %r12      # 0x104e9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3140
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0xb205
movq %r15, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x32e0
movq %rbx, %rdi
callq 0x31f0
cmpl $0xa, %eax
jne 0xb1f6
jmp 0xb1b9
movq 0xadcc(%rip), %rdi      # 0x15fd8
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
pushq $0xa
popq %rdx
callq 0x3130
movsd -0x28(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: getIntWithinRange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
int getIntWithinRange(std::string prompt, int min, int max)
{

    std::cout << prompt
              //<< " Choose a number from " << min << " to " << max << "."
              << std::endl;
    int input = getInteger();

    //validate range
    while(input < min || input > max)
    {
        std::cout << "Out of range. Choose a number from " << min << " to "
                  << max << "." << std::endl;

        input = getInteger();
    }
    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %rsi
movq 0xad7b(%rip), %rdi      # 0x15fc8
callq 0x31b0
leaq 0x52ad(%rip), %r12      # 0x10506
leaq 0x6133(%rip), %r13      # 0x11393
leaq 0x530c(%rip), %r15      # 0x10573
movq %rax, %rdi
callq 0x30f0
callq 0xaed4
cmpl %r14d, %eax
setge %cl
cmpl %ebx, %eax
setle %dl
testb %dl, %cl
jne 0xb2bf
movq 0xad3e(%rip), %rdi      # 0x15fc8
movq %r12, %rsi
callq 0x31d0
movq %rax, %rdi
movl %r14d, %esi
callq 0x32f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x31d0
movq %rax, %rdi
movl %ebx, %esi
callq 0x32f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
jmp 0xb267
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: getDoubleWithinRange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double)
double getDoubleWithinRange(std::string prompt, double min, double max)
{

    std::cout << prompt << " Choose a number from " << min << " to "
              << max << std::endl;
    double input= getDouble();

    //validate range
    while(input < min || input > max)
    {
        std::cout << "Out of range. Choose a number from " << min << " to "
                  << max << std::endl;

        input = getDouble();
    }
    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rsi
movq 0xacd9(%rip), %rbx      # 0x15fc8
movq %rbx, %rdi
callq 0x31b0
leaq 0x5215(%rip), %rsi      # 0x10513
movq %rax, %rdi
callq 0x31d0
leaq 0x6086(%rip), %r14      # 0x11393
leaq 0x51f2(%rip), %r15      # 0x10506
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x32b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x32b0
movq %rax, %rdi
callq 0x30f0
callq 0xb191
movsd -0x28(%rbp), %xmm1
ucomisd %xmm0, %xmm1
ja 0xb358
ucomisd -0x20(%rbp), %xmm0
jbe 0xb365
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d0
jmp 0xb314
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: makeTwoDecimals[abi:cxx11](double)
std::string makeTwoDecimals(double value)
{
    std::ostringstream stream;
    std::string money;

    stream << std::setprecision(2) << std::fixed << value;
    money = stream.str();

    int insertPosition = money.length() - 6;
    while (insertPosition > 0)
    {
        money.insert(insertPosition, ",");
        insertPosition-=3;
    }

    return money;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
leaq -0x1b8(%rbp), %r14
movq %r14, %rdi
callq 0x3240
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq $0x2, -0x1b0(%rbp,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl -0x1a0(%rbp,%rax), %ecx
orl $0x4, %ecx
movl %ecx, -0x1a0(%rbp,%rax)
movq %r14, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x32b0
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3280
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3200
movq %r14, %rdi
callq 0x3368
movl 0x8(%rbx), %r15d
addl $-0x6, %r15d
leaq 0x4fe1(%rip), %r14      # 0x1060d
testl %r15d, %r15d
jle 0xb645
movl %r15d, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3060
addl $-0x3, %r15d
jmp 0xb62c
leaq -0x1b8(%rbp), %rdi
callq 0x3050
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb666
jmp 0xb666
movq %rax, %r14
movq %rbx, %rdi
callq 0x3368
leaq -0x1b8(%rbp), %rdi
callq 0x3050
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: promptOpenRead(std::basic_ifstream<char, std::char_traits<char>>&)
void promptOpenRead(std::ifstream& inputFile)
{
    std::string inFileName;
    do
    {
        std::cout << "What is the name of the file you'd like to read?"
                  << std::endl;
        std::cin >> inFileName;

        inputFile.open(inFileName);

        if(inputFile.fail())
        {
            std::cout << "File not found." << std::endl;
        }
    }
    while(inputFile.fail());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
movq 0xa918(%rip), %r14      # 0x15fc8
movq 0xa921(%rip), %r12      # 0x15fd8
leaq -0x48(%rbp), %r13
pushq $0x8
popq %r15
movq %r14, %rdi
leaq 0x4eac(%rip), %rsi      # 0x10575
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x3210
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x3190
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x20(%rbx,%rax), %eax
testb $0x5, %al
je 0xb720
movq %r14, %rdi
leaq 0x4e9e(%rip), %rsi      # 0x105a6
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x20(%rbx,%rax), %eax
testb $0x5, %al
jne 0xb6bf
leaq -0x48(%rbp), %rdi
callq 0x3368
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3368
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: promptOpenWrite(std::basic_ofstream<char, std::char_traits<char>>&)
void promptOpenWrite(std::ofstream& outputFile)
{
    std::string outFileName;
    do {
        std::cout << "What will be the name of your output file?" << std::endl;
        std::cin >> outFileName;

        outputFile.open(outFileName);

        if(outputFile.fail())
        {
            std::cout << "There was an error opening the output file."
                      << std::endl;
        }
    } while(outputFile.fail());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
movq 0xa84d(%rip), %r14      # 0x15fc8
movq 0xa856(%rip), %r12      # 0x15fd8
leaq -0x48(%rbp), %r13
pushq $0x10
popq %r15
movq %r14, %rdi
leaq 0x4e22(%rip), %rsi      # 0x105b6
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x3210
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x30e0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x20(%rbx,%rax), %eax
testb $0x5, %al
je 0xb7eb
movq %r14, %rdi
leaq 0x4e0e(%rip), %rsi      # 0x105e1
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x20(%rbx,%rax), %eax
testb $0x5, %al
jne 0xb78a
leaq -0x48(%rbp), %rdi
callq 0x3368
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3368
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: addCommas[abi:cxx11](int)
std::string addCommas (int value)
{
    std::ostringstream stream;
    std::string number;

    stream << value;
    number = stream.str();

    int insertPosition = number.length() - 3;
    while (insertPosition > 0)
    {
        number.insert(insertPosition, ",");
        insertPosition-=3;
    }

    return number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x3240
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r15, %rdi
movl %r14d, %esi
callq 0x32f0
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3280
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3200
movq %r14, %rdi
callq 0x3368
movl 0x8(%rbx), %r15d
leaq 0x4d80(%rip), %r14      # 0x1060d
addq $-0x3, %r15
testl %r15d, %r15d
jle 0xb8ac
movl %r15d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3060
jmp 0xb88d
leaq -0x1b0(%rbp), %rdi
callq 0x3050
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb8cd
jmp 0xb8cd
movq %rax, %r14
movq %rbx, %rdi
callq 0x3368
leaq -0x1b0(%rbp), %rdi
callq 0x3050
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: printString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
void printString(std::string str, std::string color, double seconds)
{
    std::stringstream ss;
    std::string temp;
    int counter = 0;

    ss << str;

    std::cout << color;

    //read full string
    while (!ss.eof())
    {
        //keep a character count, newline if we hit the end
        ss >> temp;  //goes until it hits a space
        counter += temp.size();
        if (counter < LINE_WIDTH)
        {
            //print the word
            std::cout << temp;
        }
        if (counter >= LINE_WIDTH)
        {
            //wait to print next line, for drama purposes
            wait(seconds);
            //newline, then the word
            std::cout << "\n" << temp;
            //reset counter for next line
            counter = 0;
            counter += temp.size();
        }
        //put the space back in
        std::cout << " ";
    }

    ss.clear();
    //newline at end of this function needs to wait, too, for consistency
    wait(seconds);
    std::cout << "\n" << RESET << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movsd %xmm0, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x1d8(%rbp), %rdi
callq 0x3160
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x1c8(%rbp), %rdi
movq %r14, %rsi
callq 0x31b0
movq 0xa436(%rip), %rdi      # 0x15fc8
movq %rbx, %rsi
callq 0x31b0
xorl %r13d, %r13d
leaq -0x1d8(%rbp), %rbx
leaq -0x50(%rbp), %r14
movq 0xa419(%rip), %r15      # 0x15fc8
leaq 0x5481(%rip), %r12      # 0x11037
movq -0x1d8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1b8(%rbp,%rax)
jne 0xbc25
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3210
movslq %r13d, %r13
addq -0x48(%rbp), %r13
cmpl $0x39, %r13d
jg 0xbbf0
movq %r15, %rdi
movq %r14, %rsi
callq 0x31b0
jmp 0xbc18
movsd -0x30(%rbp), %xmm0
callq 0xbaf9
movq %r15, %rdi
leaq 0x4d20(%rip), %rsi      # 0x10924
callq 0x31d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31b0
movq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x31d0
jmp 0xbbb6
leaq (%rax,%rbp), %rdi
addq $-0x1d8, %rdi           # imm = 0xFE28
xorl %esi, %esi
callq 0x32e0
movsd -0x30(%rbp), %xmm0
callq 0xbaf9
movq 0xa380(%rip), %rdi      # 0x15fc8
leaq 0x4cd5(%rip), %rsi      # 0x10924
callq 0x31d0
leaq 0x4458(%rip), %rsi      # 0x100b3
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
leaq -0x50(%rbp), %rdi
callq 0x3368
leaq -0x1d8(%rbp), %rdi
callq 0x3170
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbc94
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3368
leaq -0x1d8(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Engineering.cpp
// Function: Engineering::Engineering()
Engineering::Engineering()
{
    //set up room
    this->roomName = "Engineering";
    occupant = new Lester;

    roomItems.push_back(engineeringIngredient);
    roomItems.push_back("wrench");
    roomItems.push_back("tikurian generator");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xe2ec
leaq 0x9e40(%rip), %rax      # 0x15b20
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x4921(%rip), %rsi      # 0x1060f
callq 0x3340
pushq $0x68
popq %rdi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0xdf68
movq %r15, 0x8(%rbx)
leaq 0x30(%rbx), %r14
leaq 0xaddb(%rip), %rsi      # 0x16af0
movq %r14, %rdi
callq 0x97ca
leaq 0x48f7(%rip), %rsi      # 0x1061b
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
leaq 0x48d5(%rip), %rsi      # 0x10622
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbd7e
jmp 0xbd9b
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3368
jmp 0xbd9e
jmp 0xbd9b
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0xbd9e
movq %rax, %r14
movq %rbx, %rdi
callq 0xe31a
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Engineering.cpp
// Function: Engineering::actionMenu(Player&)
bool Engineering::actionMenu(Player& markNelson)
{
    if (markNelson.pack.checkFor(codes))
    {
        std::cout << NARRATOR_COLOR
                  << "As you enter Engineering, you notice the escape pod. "
                     " You have the \ncodes, and it is out of Lester's field of"
                     " view.  It only fits one \nperson."
                  << RESET << std:: endl;

        int choice = 0;
        while (choice < 1 || choice > 2)
        {
            std::cout << "1. Take escape pod\n"
                      << "2. Stay aboard the ship" << std::endl;

            choice = getInteger();
        }

        //game Over if you take pod
        if (choice == 1)
        {
            if (markNelson.crewDead == 0)
            {
                markNelson.state = TOOK_POD_NONE_DEAD;
                return false;
            }
            else
            {
                markNelson.state = TOOK_POD_SOME_DEAD;
                return false;
            }
        }
    }

    return Space::actionMenu(markNelson);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xad18(%rip), %rsi      # 0x16b30
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r15, %rsi
callq 0x970a
movl %eax, %r15d
leaq -0x48(%rbp), %rdi
callq 0x3368
testb %r15b, %r15b
je 0xbed1
movq 0xa17d(%rip), %r15      # 0x15fc8
leaq 0x4246(%rip), %rsi      # 0x10098
movq %r15, %rdi
callq 0x31d0
leaq 0x47d4(%rip), %rsi      # 0x10635
movq %rax, %rdi
callq 0x31d0
leaq 0x4243(%rip), %rsi      # 0x100b3
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
xorl %eax, %eax
leaq 0x483b(%rip), %r12      # 0x106c4
leaq 0x4848(%rip), %r13      # 0x106d8
leal -0x3(%rax), %ecx
cmpl $-0x3, %ecx
ja 0xbebd
movq %r15, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %rdi
movq %r13, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
callq 0xaed4
jmp 0xbe90
cmpl $0x1, %eax
jne 0xbed1
cmpl $0x0, 0x20(%rbx)
je 0xbede
movl $0x2, 0x30(%rbx)
jmp 0xbee5
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe374
jmp 0xbee7
movl $0x1, 0x30(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3368
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Game.cpp
// Function: Game::~Game()
Game::~Game()
{
    //free memory
    delete bridge;
    delete corridor;
    delete captainsQ;
    delete lounge;
    delete lab;
    delete crewQ;
    delete engineering;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc8(%rdi), %rdi
testq %rdi, %rdi
je 0xc1a7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0xc1b9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0xc1cb
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0xc1dd
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0xc1ef
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0xc201
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0xc213
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xa0(%rbx), %rdi
callq 0x3368
leaq 0x80(%rbx), %rdi
callq 0x3368
leaq 0x60(%rbx), %rdi
callq 0x3368
leaq 0x40(%rbx), %rdi
callq 0x3368
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9794
nop
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Game.cpp
// Function: Game::printPrologue()
void Game::printPrologue()
{

    std::cout << NARRATOR_COLOR << std::endl
              << "As you approach the terminal, you notice an alert, "
                 "blinking furiously.\n\n";
    wait(MED);

    std::cout << DIALOGUE_COLOR << "That wasn’t there when we left...\n\n";
    wait(MED);

    std::cout << NARRATOR_COLOR
              <<"Alone in the corridor, you enter your login credentials.\n\n";
    wait(MED);

    printFile("prologueA.txt", PROLOGUE_COLOR, MED);
    std::cout << std::endl;
    printFile("prologueB.txt", NARRATOR_COLOR, MED);
    wait(MED);

    std::cout << RESET;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq 0x9bb9(%rip), %rbx      # 0x15fc8
leaq 0x3c82(%rip), %r14      # 0x10098
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
leaq 0x4487(%rip), %rsi      # 0x108b7
movq %rax, %rdi
callq 0x31d0
movsd 0x3fb0(%rip), %xmm0     # 0x103f0
callq 0xbaf9
leaq 0x3fc0(%rip), %rsi      # 0x1040c
movq %rbx, %rdi
callq 0x31d0
leaq 0x44a5(%rip), %rsi      # 0x10900
movq %rax, %rdi
callq 0x31d0
movsd 0x3f85(%rip), %xmm0     # 0x103f0
callq 0xbaf9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
leaq 0x44a4(%rip), %rsi      # 0x10926
movq %rax, %rdi
callq 0x31d0
movsd 0x3f5e(%rip), %xmm0     # 0x103f0
callq 0xbaf9
leaq 0x44c3(%rip), %rsi      # 0x10961
leaq -0x98(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0x30b0
leaq 0x3c1a(%rip), %rsi      # 0x100cf
leaq -0x78(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30b0
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movsd 0x3f1b(%rip), %xmm0     # 0x103f0
callq 0xb8ec
leaq -0x78(%rbp), %rdi
callq 0x3368
leaq -0x98(%rbp), %rdi
callq 0x3368
movq 0x9ad2(%rip), %rdi      # 0x15fc8
callq 0x30f0
leaq 0x446d(%rip), %rsi      # 0x1096f
leaq -0x58(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0x30b0
leaq 0x3b82(%rip), %rsi      # 0x10098
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30b0
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movsd 0x3ebd(%rip), %xmm0     # 0x103f0
callq 0xb8ec
leaq -0x38(%rbp), %rdi
callq 0x3368
leaq -0x58(%rbp), %rdi
callq 0x3368
movsd 0x3e9e(%rip), %xmm0     # 0x103f0
callq 0xbaf9
movq 0x9a6a(%rip), %rdi      # 0x15fc8
leaq 0x3b4e(%rip), %rsi      # 0x100b3
callq 0x31d0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3368
jmp 0xc587
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0xc5a7
jmp 0xc5ae
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3368
jmp 0xc5a0
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x3368
jmp 0xc5b1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Game.cpp
// Function: Game::printTitle()
void Game::printTitle()
{
    std::ifstream stream("titleCard.txt", std::ios::in);
    std::string contents;

    std::cout << CYAN;
    while (getline(stream, contents))
    {
        std::cout << contents << std::endl;
    }
    std::cout << "\n\n" << RESET;
    stream.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x43ac(%rip), %rsi      # 0x1097d
leaq -0x240(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x3310
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x99d1(%rip), %rdi      # 0x15fc8
leaq 0x3e0e(%rip), %rsi      # 0x1040c
callq 0x31d0
leaq -0x240(%rbp), %rbx
leaq -0x38(%rbp), %r14
movq 0x99b3(%rip), %r15      # 0x15fc8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xc643
movq %r15, %rdi
movq %r14, %rsi
callq 0x31b0
movq %rax, %rdi
callq 0x30f0
jmp 0xc615
movq 0x997e(%rip), %rdi      # 0x15fc8
leaq 0x42d2(%rip), %rsi      # 0x10923
callq 0x31d0
leaq 0x3a56(%rip), %rsi      # 0x100b3
movq %rax, %rdi
callq 0x31d0
leaq -0x240(%rbp), %rdi
callq 0x3040
leaq -0x38(%rbp), %rdi
callq 0x3368
leaq -0x240(%rbp), %rdi
callq 0x3070
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc696
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3368
leaq -0x240(%rbp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Game.cpp
// Function: Game::startMenu()
int Game::startMenu()
{
    int input = 0;
    std::cout << "\n";

    while (input < 1 || input > 3)
    {
        std::cout << "1. Begin New Game With Prologue\n"
                  << "2. Begin New Game Without Prologue\n"
                  << "3. Quit" << std::endl;

        input = getInteger();
    }

    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x887a(%rip), %rbx      # 0x15fc8
leaq 0x31cf(%rip), %rsi      # 0x10924
movq %rbx, %rdi
callq 0x31d0
xorl %eax, %eax
leaq 0x3104(%rip), %r14      # 0x1086a
leaq 0x311e(%rip), %r15      # 0x1088b
leaq 0x313b(%rip), %r12      # 0x108af
leal -0x4(%rax), %ecx
cmpl $-0x4, %ecx
ja 0xd7ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
callq 0xaed4
jmp 0xd774
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Game.cpp
// Function: Game::parasiteSpreads()
bool Game::parasiteSpreads()
{
    //spread to next person in the chain if they're alive
    if (!bridge->getOccupant()->getInfected()
        && bridge->getOccupant()->getAlive())
    {
        bridge->getOccupant()->setInfected(true);
        markNelson.crewInfected++;
        return true;
    }
    else if (!lounge->getOccupant()->getInfected()
             && lounge->getOccupant()->getAlive())
    {
        lounge->getOccupant()->setInfected(true);
        markNelson.crewInfected++;
        return true;
    }
    else if (!crewQ->getOccupant()->getInfected()
             && crewQ->getOccupant()->getAlive())
    {
        crewQ->getOccupant()->setInfected(true);
        markNelson.crewInfected++;
        return true;
    }
    else if (!engineering->getOccupant()->getInfected()
              && engineering->getOccupant()->getAlive())
    {
        engineering->getOccupant()->setInfected(true);
        markNelson.crewInfected++;
        return true;
    }
    //you are the last one, so game over - trigger appropriate ending
    else if (markNelson.crewDead == 0)
    {
        markNelson.state = PLAYER_AND_CREW_INFECTED;
        return false;
    }
    else if (markNelson.crewDead == 1)
    {
        markNelson.state = KILLED_PERSON_INFECTED_ANYWAY;
        return false;
    }
    else
    {
        markNelson.state = KILLED_PEOPLE_INFECTED_ANYWAY;
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc8(%rdi), %rdi
callq 0xe36a
movq %rax, %rdi
callq 0xa5ee
testb %al, %al
jne 0xd7fb
movq 0xc8(%rbx), %rdi
callq 0xe36a
movq %rax, %rdi
callq 0xa5da
testb %al, %al
je 0xd7fb
movq 0xc8(%rbx), %rdi
jmp 0xd8a4
movq 0xd8(%rbx), %rdi
callq 0xe36a
movq %rax, %rdi
callq 0xa5ee
testb %al, %al
jne 0xd834
movq 0xd8(%rbx), %rdi
callq 0xe36a
movq %rax, %rdi
callq 0xa5da
testb %al, %al
je 0xd834
movq 0xd8(%rbx), %rdi
jmp 0xd8a4
movq 0xe8(%rbx), %rdi
callq 0xe36a
movq %rax, %rdi
callq 0xa5ee
testb %al, %al
jne 0xd86d
movq 0xe8(%rbx), %rdi
callq 0xe36a
movq %rax, %rdi
callq 0xa5da
testb %al, %al
je 0xd86d
movq 0xe8(%rbx), %rdi
jmp 0xd8a4
movq 0xf0(%rbx), %rdi
callq 0xe36a
movq %rax, %rdi
callq 0xa5ee
testb %al, %al
jne 0xd8bb
movq 0xf0(%rbx), %rdi
callq 0xe36a
movq %rax, %rdi
callq 0xa5da
testb %al, %al
je 0xd8bb
movq 0xf0(%rbx), %rdi
callq 0xe36a
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xa5e4
incl 0x24(%rbx)
movb $0x1, %al
jmp 0xd8e2
movl 0x20(%rbx), %eax
cmpl $0x1, %eax
je 0xd8d0
testl %eax, %eax
jne 0xd8d9
movl $0xe, 0x30(%rbx)
jmp 0xd8e0
movl $0x10, 0x30(%rbx)
jmp 0xd8e0
movl $0xf, 0x30(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Game.cpp
// Function: Game::printTime()
void Game::printTime()
{
    std::cout << MAP_COLOR << deadline << ": " << TIME_COLOR;
    int niceTime = timeLeft * TIME_FACTOR;
    if (niceTime > 59)
    {
        std::cout << niceTime/60;
    }
    else
    {
        std::cout << "0";
    }

    std::cout << ":";
    if (niceTime % 60 == 0)
    {
        std::cout << "0";
    }
    std::cout << niceTime % 60 << RESET << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x86cd(%rip), %rdi      # 0x15fc8
leaq 0x3227(%rip), %rsi      # 0x10b29
callq 0x31d0
leaq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x31b0
leaq 0x37dc(%rip), %rsi      # 0x110f6
movq %rax, %rdi
callq 0x31d0
leaq 0x307a(%rip), %rsi      # 0x109a3
movq %rax, %rdi
callq 0x31d0
movl 0x38(%rbx), %eax
imull $0xa, %eax, %ebx
pushq $0x3c
popq %r14
cmpl $0x6, %eax
jl 0xd957
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
movq 0x867a(%rip), %rdi      # 0x15fc8
movl %eax, %esi
callq 0x32f0
jmp 0xd96a
movq 0x866a(%rip), %rdi      # 0x15fc8
leaq 0x31ca(%rip), %rsi      # 0x10b2f
callq 0x31d0
movq 0x8657(%rip), %rdi      # 0x15fc8
leaq 0x3ab7(%rip), %rsi      # 0x1142f
callq 0x31d0
movl %ebx, %eax
cltd
idivl %r14d
movl %edx, %ebx
testl %edx, %edx
jne 0xd99c
movq 0x8638(%rip), %rdi      # 0x15fc8
leaq 0x3198(%rip), %rsi      # 0x10b2f
callq 0x31d0
movq 0x8625(%rip), %rdi      # 0x15fc8
movl %ebx, %esi
callq 0x32f0
leaq 0x2702(%rip), %rsi      # 0x100b3
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Lab.cpp
// Function: Lab::Lab()
Lab::Lab()
{
    //set up room
    this->roomName = "Medical Lab";
    occupant = nullptr;

    roomItems.push_back("erlenmeyer flask");
    roomItems.push_back("jar of gray matter");
    roomItems.push_back(labIngredient);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xe2ec
leaq 0x8116(%rip), %rax      # 0x15bf0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x3713(%rip), %rsi      # 0x111fb
callq 0x3340
andq $0x0, 0x8(%rbx)
leaq 0x370e(%rip), %rsi      # 0x11207
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30b0
leaq 0x30(%rbx), %r14
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x38(%rbp), %rdi
callq 0x3368
leaq 0x36f2(%rip), %rsi      # 0x11218
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30b0
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x38(%rbp), %rdi
callq 0x3368
leaq 0x94e1(%rip), %rsi      # 0x17030
movq %r14, %rdi
callq 0x97ca
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xdb64
jmp 0xdb74
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x3368
jmp 0xdb77
jmp 0xdb74
movq %rax, %r14
movq %rbx, %rdi
callq 0xe31a
movq %r14, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Lab.cpp
// Function: Lab::actionMenu(Player&)
bool Lab::actionMenu(Player& markNelson)
{

    //if player has all ingredients, give option to make compound
    if (markNelson.ingredientsFound == TOTAL_INGREDIENTS)
    {
        char answer = getYesNo("Create Neutralization Compound? [y/n]: ");
        if (answer == 'Y')
        {
            makeCompound(markNelson);
            //reset this so this option isn't triggered next time you enter
            //the room
            markNelson.ingredientsFound = 0;
        }
    }
    //then call regular menu
    return Space::actionMenu(markNelson);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x5, 0x1c(%rsi)
jne 0xdc04
leaq 0x365d(%rip), %rsi      # 0x1122b
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x30b0
movq %r15, %rdi
callq 0xae36
movl %eax, %r15d
leaq -0x40(%rbp), %rdi
callq 0x3368
cmpb $0x59, %r15b
jne 0xdc04
movq %rbx, %rsi
callq 0xdc2e
andl $0x0, 0x1c(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe374
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3368
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Lab.cpp
// Function: Lab::makeCompound(Player&)
void Lab::makeCompound(Player& markNelson)
{
    markNelson.pack.removeItem(labIngredient);
    markNelson.pack.removeItem(loungeIngredient);
    markNelson.pack.removeItem(captainsQIngredient);
    markNelson.pack.removeItem(crewQIngredient);
    markNelson.pack.removeItem(engineeringIngredient);

    std::cout << NARRATOR_COLOR
              << "\ncompound ingredients removed from pack.\n"
              << compound << " added to pack.\n" << std::endl;

    markNelson.pack.addItem(compound);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
leaq 0x93e8(%rip), %rsi      # 0x17030
leaq -0xd8(%rbp), %r14
movq %r14, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9730
leaq -0xd8(%rbp), %rdi
callq 0x3368
leaq 0x93db(%rip), %rsi      # 0x17050
leaq -0xb8(%rbp), %r14
movq %r14, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9730
leaq -0xb8(%rbp), %rdi
callq 0x3368
leaq 0x93ce(%rip), %rsi      # 0x17070
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9730
leaq -0x98(%rbp), %rdi
callq 0x3368
leaq 0x93c1(%rip), %rsi      # 0x17090
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9730
leaq -0x78(%rbp), %rdi
callq 0x3368
leaq 0x93ba(%rip), %rsi      # 0x170b0
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9730
leaq -0x58(%rbp), %rdi
callq 0x3368
movq 0x82ab(%rip), %rdi      # 0x15fc8
leaq 0x2374(%rip), %rsi      # 0x10098
callq 0x31d0
leaq 0x3565(%rip), %rsi      # 0x11295
movq %rax, %rdi
callq 0x31d0
leaq 0x93f1(%rip), %r15      # 0x17130
movq %rax, %rdi
movq %r15, %rsi
callq 0x31b0
leaq 0x356e(%rip), %rsi      # 0x112bf
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9700
leaq -0x38(%rbp), %rdi
callq 0x3368
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdd9c
jmp 0xdd9c
jmp 0xdd9c
jmp 0xdd9c
jmp 0xdd9c
movq %rax, %rbx
movq %r14, %rdi
callq 0x3368
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Lounge.cpp
// Function: Lounge::Lounge()
Lounge::Lounge()
{
    //set up room
    this->roomName = "Lounge";
    occupant = new Penny;

    roomItems.push_back("water bottle");
    roomItems.push_back("nutrition bar");
    roomItems.push_back(loungeIngredient);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xe2ec
leaq 0x7c88(%rip), %rax      # 0x15c88
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x32e8(%rip), %rsi      # 0x112f6
callq 0x3340
pushq $0x68
popq %rdi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0xe244
movq %r15, 0x8(%rbx)
leaq 0x32cc(%rip), %rsi      # 0x112fd
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq 0x30(%rbx), %r14
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
leaq 0x32ac(%rip), %rsi      # 0x1130a
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30b0
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0xa27a
leaq -0x40(%rbp), %rdi
callq 0x3368
leaq 0x92a9(%rip), %rsi      # 0x17330
movq %r14, %rdi
callq 0x97ca
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe09e
jmp 0xe0bb
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3368
jmp 0xe0be
jmp 0xe0bb
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0xe0be
movq %rax, %r14
movq %rbx, %rdi
callq 0xe31a
movq %r14, %rdi
callq 0x3300