LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1423c
leaq 0xc560(%rip), %rax      # 0x1bab0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x6eea(%rip), %rcx      # 0x1644c
movl $0xd, %r8d
xorl %esi, %esi
callq 0x3290
movl $0x68, %edi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0x140ec
movq %r15, 0x8(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x6ec3(%rip), %rsi      # 0x1645a
leaq 0x6ec5(%rip), %rdx      # 0x16463
leaq -0x38(%rbp), %rdi
callq 0xe724
leaq 0x30(%rbx), %r14
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe7be
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xf5c5
callq 0x31c0
leaq 0xd3a4(%rip), %rsi      # 0x1c970
movq %r14, %rdi
callq 0xd958
leaq -0x38(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x6e82(%rip), %rsi      # 0x16464
leaq 0x6e8a(%rip), %rdx      # 0x16473
callq 0xe724
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe7be
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xf608
callq 0x31c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf617
jmp 0xf634
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0xf62d
jmp 0xf637
jmp 0xf634
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0xf637
movq %rax, %r14
movq %rbx, %rdi
callq 0x1426a
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %eax, %eax
movq 0xc8f4(%rip), %r13      # 0x1bfd8
movq %rdi, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3350
movq 0x8(%rbx), %r14
movb $0x1, %r15b
movb $0x1, %r12b
testq %r14, %r14
je 0xf751
movq (%rbx), %rbx
movb $0x1, %r12b
xorl %r13d, %r13d
movsbl (%rbx,%r13), %edi
callq 0x32c0
testl %eax, %eax
movzbl %r12b, %r12d
cmovel %eax, %r12d
incq %r13
movl %r13d, %eax
cmpq %rax, %r14
ja 0xf727
movq -0x38(%rbp), %rbx
movq 0xc887(%rip), %r13      # 0x1bfd8
testb $0x1, %r12b
jne 0xf7ba
movl $0x26, %edx
movq 0xc865(%rip), %rdi      # 0x1bfc8
leaq 0x6d36(%rip), %rsi      # 0x164a0
callq 0x3210
movq 0xc852(%rip), %rcx      # 0x1bfc8
movq (%rcx), %rax
movq -0x18(%rax), %rdi
addq %rcx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq 0xc834(%rip), %rdi      # 0x1bfc8
callq 0x3030
movq %rax, %rdi
callq 0x3140
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
xorl %esi, %esi
callq 0x3300
movq -0x40(%rbp), %rax
movl %eax, %r15d
movl %r15d, %eax
testb $0x1, %r12b
je 0xf6e8
testb $0x1, %r15b
jne 0xf7db
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xf7db
callq 0x31c0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xf7fe
callq 0x31c0
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0xc7a5(%rip), %rbx      # 0x1bfc8
movq %rbx, %rdi
callq 0x3210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
movq 0xc77c(%rip), %r14      # 0x1bfd8
leaq -0x21(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x3300
movl $0x186a0, %esi          # imm = 0x186A0
movq %r14, %rdi
movl $0xa, %edx
callq 0x3110
leaq 0x6c32(%rip), %r12      # 0x164c7
movsbl -0x21(%rbp), %edi
callq 0x3360
movb %al, -0x21(%rbp)
cmpb $0x4e, %al
je 0xf8ed
movzbl %al, %ecx
cmpl $0x59, %ecx
je 0xf8ed
movl $0x23, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3210
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x3300
movl $0x186a0, %esi          # imm = 0x186A0
movq %r14, %rdi
movl $0xa, %edx
callq 0x3110
jmp 0xf895
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc251(%rip), %rbx      # 0x1bfd8
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x3120
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0xfe25
movq 0xc244(%rip), %r14      # 0x1bff0
leaq 0x6756(%rip), %r15      # 0x16509
leaq -0x28(%rbp), %r12
movl $0x1c, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x3300
movq %rbx, %rdi
callq 0x3220
cmpl $0xa, %eax
jne 0xfdff
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3120
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xfdb7
movq 0xc1ac(%rip), %rdi      # 0x1bfd8
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movl $0xa, %edx
callq 0x3110
movsd -0x28(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%rdi), %rdx
movq 0xc155(%rip), %rdi      # 0x1bfc8
callq 0x3210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
callq 0xf8fa
cmpl %r14d, %eax
setge %cl
cmpl %ebx, %eax
setle %dl
testb %dl, %cl
jne 0xff5b
movq 0xc107(%rip), %r15      # 0x1bfc8
leaq 0x66cb(%rip), %r12      # 0x16593
movl $0x23, %edx
movq %r15, %rdi
leaq 0x664f(%rip), %rsi      # 0x16526
callq 0x3210
movq %r15, %rdi
movl %r14d, %esi
callq 0x3310
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
leaq 0x74bf(%rip), %rsi      # 0x173b8
callq 0x3210
movq %r13, %rdi
movl %ebx, %esi
callq 0x3310
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3210
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
callq 0xf8fa
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %dl
orb %cl, %dl
jne 0xfec8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0xc037(%rip), %rdi      # 0x1bfc8
callq 0x3210
movq %rax, %rbx
leaq 0x6593(%rip), %rsi      # 0x16533
movl $0x16, %edx
movq %rax, %rdi
callq 0x3210
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x32d0
movq %rax, %rbx
leaq 0x73f4(%rip), %rsi      # 0x173b8
movl $0x4, %edx
movq %rax, %rdi
callq 0x3210
movq %rbx, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x32d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
callq 0xfd71
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10023
ucomisd -0x28(%rbp), %xmm0
jbe 0x100b6
movq 0xbf9e(%rip), %rbx      # 0x1bfc8
leaq 0x64f5(%rip), %r14      # 0x16526
leaq 0x7380(%rip), %r15      # 0x173b8
movl $0x23, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3210
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x32d0
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3210
movq %r12, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x32d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
callq 0xfd71
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10038
ucomisd -0x28(%rbp), %xmm0
ja 0x10038
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rbx
leaq -0x1c0(%rbp), %r14
movq %r14, %rdi
callq 0x3260
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq $0x2, -0x1b8(%rbp,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl -0x1a8(%rbp,%rax), %ecx
orl $0x4, %ecx
movl %ecx, -0x1a8(%rbp,%rax)
movq %r14, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x32d0
leaq -0x1b8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x32a0
leaq -0x48(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
movq (%r14), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x104d9
callq 0x31c0
movl 0x8(%rbx), %eax
addl $-0x6, %eax
testl %eax, %eax
jle 0x10510
movl %eax, %r14d
leaq 0x6140(%rip), %r15      # 0x1662d
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x3200
leaq -0x3(%r14), %rax
cmpq $0x3, %r14
movq %rax, %r14
jg 0x104ed
movq 0xbaa9(%rip), %rsi      # 0x1bfc0
leaq -0x1c0(%rbp), %rdi
callq 0x30e0
leaq -0x150(%rbp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10546
jmp 0x10546
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x10556
callq 0x31c0
movq 0xba63(%rip), %rsi      # 0x1bfc0
leaq -0x1c0(%rbp), %rdi
callq 0x30e0
leaq -0x150(%rbp), %rdi
callq 0x3090
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xba1d(%rip), %r14      # 0x1bfc8
leaq 0x5fe3(%rip), %r15      # 0x16595
movq 0xba1f(%rip), %r12      # 0x1bfd8
leaq -0x48(%rbp), %r13
movl $0x30, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
movq %r12, %rdi
movq %r13, %rsi
callq 0x3240
movq %rbx, %rdi
movq %r13, %rsi
movl $0x8, %edx
callq 0x31a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x10658
movl $0xf, %edx
movq %r14, %rdi
leaq 0x5f9a(%rip), %rsi      # 0x165c6
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x105bd
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1067c
callq 0x31c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x106a0
callq 0x31c0
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xb8f2(%rip), %r14      # 0x1bfc8
leaq 0x5ef9(%rip), %r15      # 0x165d6
movq 0xb8f4(%rip), %r12      # 0x1bfd8
leaq -0x48(%rbp), %r13
movl $0x2a, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
movq %r12, %rdi
movq %r13, %rsi
callq 0x3240
movq %rbx, %rdi
movq %r13, %rsi
movl $0x10, %edx
callq 0x30c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x10783
movl $0x2b, %edx
movq %r14, %rdi
leaq 0x5eaa(%rip), %rsi      # 0x16601
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x106e8
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x107a7
callq 0x31c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x107cb
callq 0x31c0
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x1b8(%rbp), %r15
movq %r15, %rdi
callq 0x3260
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r15, %rdi
movl %r14d, %esi
callq 0x3310
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x32a0
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x10848
callq 0x31c0
movl 0x8(%rbx), %r15d
leaq 0x5dda(%rip), %r14      # 0x1662d
addq $-0x3, %r15
testl %r15d, %r15d
jle 0x1087a
movl %r15d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl $0x1, %r8d
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x3200
jmp 0x10853
movq 0xb73f(%rip), %rsi      # 0x1bfc0
leaq -0x1b8(%rbp), %rdi
callq 0x30e0
leaq -0x148(%rbp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x108b0
jmp 0x108b0
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x108c0
callq 0x31c0
movq 0xb6f9(%rip), %rsi      # 0x1bfc0
leaq -0x1b8(%rbp), %rdi
callq 0x30e0
leaq -0x148(%rbp), %rdi
callq 0x3090
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1423c
leaq 0xad0c(%rip), %rax      # 0x1bb10
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x5819(%rip), %rcx      # 0x1662f
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3290
movl $0x68, %edi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0x13e34
movq %r15, 0x8(%rbx)
leaq 0x30(%rbx), %r14
leaq 0xbcb9(%rip), %rsi      # 0x1cb00
movq %r14, %rdi
callq 0xd958
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x57dd(%rip), %rsi      # 0x1663b
leaq 0x57dc(%rip), %rdx      # 0x16641
leaq -0x38(%rbp), %rdi
callq 0xe724
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe7be
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x10e88
callq 0x31c0
leaq -0x38(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x57ac(%rip), %rsi      # 0x16642
leaq 0x57b7(%rip), %rdx      # 0x16654
callq 0xe724
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe7be
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x10ebc
callq 0x31c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10ecb
jmp 0x10ee8
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0x10ee1
jmp 0x10eeb
jmp 0x10ee8
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0x10eeb
movq %rax, %r14
movq %rbx, %rdi
callq 0x1426a
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0xbbb5(%rip), %rsi      # 0x1cb40
movq 0xbbb6(%rip), %rdx      # 0x1cb48
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0xd9b2
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd878
movl %eax, %r15d
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x10fbd
callq 0x31c0
testb %r15b, %r15b
je 0x110aa
movq 0xaffb(%rip), %r15      # 0x1bfc8
leaq 0x50bf(%rip), %rsi      # 0x16093
movl $0x5, %edx
movq %r15, %rdi
callq 0x3210
leaq 0x566d(%rip), %rsi      # 0x16655
movl $0x8e, %edx
movq %r15, %rdi
callq 0x3210
leaq 0x50b2(%rip), %rsi      # 0x160ae
movl $0x4, %edx
movq %r15, %rdi
callq 0x3210
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
leaq 0x56ad(%rip), %r12      # 0x166e4
leaq 0x56ba(%rip), %r13      # 0x166f8
movl $0x13, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3210
movl $0x17, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x3210
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
callq 0xf8fa
leal -0x3(%rax), %ecx
cmpl $-0x2, %ecx
jb 0x1103e
cmpl $0x1, %eax
jne 0x110aa
cmpl $0x1, 0x20(%rbx)
movl $0x2, %eax
sbbl $0x0, %eax
movl %eax, 0x30(%rbx)
xorl %eax, %eax
jmp 0x110b5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x142e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x110d5
callq 0x31c0
movq %rbx, %rdi
callq 0x3320
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x113e7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x113f9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x1140b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x1141d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x1142f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x11441
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x11453
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x1146b
callq 0x31c0
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x11483
callq 0x31c0
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x11495
callq 0x31c0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x114a7
callq 0x31c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd90a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x4ff2(%rip), %rsi      # 0x1699d
leaq -0x250(%rbp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x3340
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq 0xa5ed(%rip), %rdi      # 0x1bfc8
leaq 0x4a4a(%rip), %rsi      # 0x1642c
movl $0x5, %edx
callq 0x3210
leaq -0x48(%rbp), %r14
movq 0xa5d1(%rip), %r15      # 0x1bfc8
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3350
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11a67
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x3210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
jmp 0x119f7
movq 0xa55a(%rip), %rdi      # 0x1bfc8
leaq 0x4ece(%rip), %rsi      # 0x16943
movl $0x2, %edx
callq 0x3210
movq 0xa542(%rip), %rdi      # 0x1bfc8
leaq 0x4621(%rip), %rsi      # 0x160ae
movl $0x4, %edx
callq 0x3210
leaq -0x250(%rbp), %rdi
callq 0x3040
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x11ab1
callq 0x31c0
leaq -0x250(%rbp), %rdi
callq 0x3050
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11ad1
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x11ae2
callq 0x31c0
leaq -0x250(%rbp), %rdi
callq 0x3050
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ca0(%rip), %rbx      # 0x1bfc8
leaq 0x3615(%rip), %rsi      # 0x16944
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3210
leaq 0x3547(%rip), %r14      # 0x1688a
leaq 0x3561(%rip), %r15      # 0x168ab
leaq 0x357e(%rip), %r12      # 0x168cf
movl $0x20, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3210
movl $0x23, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3210
movl $0x7, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3140
callq 0xf8fa
leal -0x4(%rax), %ecx
cmpl $-0x3, %ecx
jb 0x13351
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x142d6
movq %rax, %rdi
callq 0xecbc
testb %al, %al
jne 0x13403
movq 0xc8(%rbx), %rdi
callq 0x142d6
movq %rax, %rdi
callq 0xeca8
testb %al, %al
je 0x13403
movq 0xc8(%rbx), %rdi
jmp 0x134ac
movq 0xd8(%rbx), %rdi
callq 0x142d6
movq %rax, %rdi
callq 0xecbc
testb %al, %al
jne 0x1343c
movq 0xd8(%rbx), %rdi
callq 0x142d6
movq %rax, %rdi
callq 0xeca8
testb %al, %al
je 0x1343c
movq 0xd8(%rbx), %rdi
jmp 0x134ac
movq 0xe8(%rbx), %rdi
callq 0x142d6
movq %rax, %rdi
callq 0xecbc
testb %al, %al
jne 0x13475
movq 0xe8(%rbx), %rdi
callq 0x142d6
movq %rax, %rdi
callq 0xeca8
testb %al, %al
je 0x13475
movq 0xe8(%rbx), %rdi
jmp 0x134ac
movq 0xf0(%rbx), %rdi
callq 0x142d6
movq %rax, %rdi
callq 0xecbc
testb %al, %al
jne 0x134c5
movq 0xf0(%rbx), %rdi
callq 0x142d6
movq %rax, %rdi
callq 0xeca8
testb %al, %al
je 0x134c5
movq 0xf0(%rbx), %rdi
callq 0x142d6
movq %rax, %rdi
movl $0x1, %esi
callq 0xecb2
incl 0x24(%rbx)
movb $0x1, %al
jmp 0x134ec
movl 0x20(%rbx), %eax
cmpl $0x1, %eax
je 0x134da
testl %eax, %eax
jne 0x134e3
movl $0xe, 0x30(%rbx)
jmp 0x134ea
movl $0x10, 0x30(%rbx)
jmp 0x134ea
movl $0xf, 0x30(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ac3(%rip), %r14      # 0x1bfc8
leaq 0x363d(%rip), %rsi      # 0x16b49
movl $0x5, %edx
movq %r14, %rdi
callq 0x3210
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
movq %r14, %rdi
callq 0x3210
movq %rax, %r14
leaq 0x3be3(%rip), %rsi      # 0x17116
movl $0x2, %edx
movq %rax, %rdi
callq 0x3210
leaq 0x347c(%rip), %rsi      # 0x169c3
movl $0x5, %edx
movq %r14, %rdi
callq 0x3210
movl 0x38(%rbx), %eax
leal (%rax,%rax), %ecx
leal (%rcx,%rcx,4), %ebx
cmpl $0x6, %eax
jl 0x1357f
movl %ebx, %eax
movl $0x88888889, %esi       # imm = 0x88888889
imulq %rax, %rsi
shrq $0x25, %rsi
movq 0x8a50(%rip), %rdi      # 0x1bfc8
callq 0x3310
jmp 0x13597
movq 0x8a42(%rip), %rdi      # 0x1bfc8
leaq 0x35c2(%rip), %rsi      # 0x16b4f
movl $0x1, %edx
callq 0x3210
movq 0x8a2a(%rip), %rdi      # 0x1bfc8
leaq 0x3eaf(%rip), %rsi      # 0x17454
movl $0x1, %edx
callq 0x3210
movslq %ebx, %rax
imulq $-0x77777777, %rax, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %ebx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x5, %eax
addl %ecx, %eax
imull $0x3c, %eax, %eax
subl %eax, %ebx
jne 0x135e8
movq 0x89f1(%rip), %rdi      # 0x1bfc8
leaq 0x3571(%rip), %rsi      # 0x16b4f
movl $0x1, %edx
callq 0x3210
movq 0x89d9(%rip), %rdi      # 0x1bfc8
movl %ebx, %esi
callq 0x3310
movq %rax, %rbx
leaq 0x2aae(%rip), %rsi      # 0x160ae
movl $0x4, %edx
movq %rax, %rdi
callq 0x3210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x1423c
leaq 0x8464(%rip), %rax      # 0x1bbe0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x3a8d(%rip), %rcx      # 0x1721b
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3290
movq $0x0, 0x8(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x3a75(%rip), %rsi      # 0x17227
leaq 0x3a7e(%rip), %rdx      # 0x17237
leaq -0x38(%rbp), %rdi
callq 0xe724
leaq 0x30(%rbx), %r14
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe7be
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x137e0
callq 0x31c0
leaq -0x38(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x3a4a(%rip), %rsi      # 0x17238
leaq 0x3a55(%rip), %rdx      # 0x1724a
callq 0xe724
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe7be
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x13814
callq 0x31c0
leaq 0x9825(%rip), %rsi      # 0x1d040
movq %r14, %rdi
callq 0xd958
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13832
jmp 0x13847
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1384a
callq 0x31c0
jmp 0x1384a
jmp 0x13847
movq %rax, %r14
movq %rbx, %rdi
callq 0x1426a
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x5, 0x1c(%rsi)
jne 0x138ec
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x39a0(%rip), %rsi      # 0x1724b
leaq 0x39c0(%rip), %rdx      # 0x17272
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xe724
movq %r15, %rdi
callq 0xf806
movl %eax, %r15d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x138d7
callq 0x31c0
cmpb $0x59, %r15b
jne 0x138ec
movq %rbx, %rsi
callq 0x1391e
movl $0x0, 0x1c(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x142e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13915
callq 0x31c0
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1423c
leaq 0x7d94(%rip), %rax      # 0x1bc78
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x3420(%rip), %rcx      # 0x17316
movl $0x6, %r8d
xorl %esi, %esi
callq 0x3290
movl $0x68, %edi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0x14180
movq %r15, 0x8(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x33f2(%rip), %rsi      # 0x1731d
leaq 0x33f7(%rip), %rdx      # 0x17329
leaq -0x38(%rbp), %rdi
callq 0xe724
leaq 0x30(%rbx), %r14
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe7be
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x13f59
callq 0x31c0
leaq -0x38(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x33c3(%rip), %rsi      # 0x1732a
leaq 0x33c9(%rip), %rdx      # 0x17337
callq 0xe724
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe7be
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x13f8d
callq 0x31c0
leaq 0x93ac(%rip), %rsi      # 0x1d340
movq %r14, %rdi
callq 0xd958
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13fab
jmp 0x13fc8
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0x13fc1
jmp 0x13fcb
jmp 0x13fc8
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0x13fcb
movq %rax, %r14
movq %rbx, %rdi
callq 0x1426a
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/dnegovan[P]Intruder-On-Donnar-V/main.cpp
// Function: main
int main()
{
    int start = 1;
    bool firstGame = true;

    while (start == 1 || start == 2)
    {
        //create game
        Game donnarV;
        if (firstGame)
        {
            start = donnarV.startMenu();
            if (start == 3)
            {
                return 0;
            }
        }

        //play the game
        donnarV.play(start);

        //play again?
        firstGame = false;
        start = donnarV.startMenu();
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movl $0x1, %r14d
movb $0x1, %r15b
leaq -0x120(%rbp), %rbx
leal -0x1(%r14), %eax
cmpl $0x1, %eax
ja 0x140c1
movq %rbx, %rdi
callq 0x110e0
testb $0x1, %r15b
je 0x14098
movq %rbx, %rdi
callq 0x13316
movl %eax, %r14d
cmpl $0x3, %eax
jne 0x14098
movl $0x3, %r14d
xorl %r12d, %r12d
jmp 0x140b4
movq %rbx, %rdi
movl %r14d, %esi
callq 0x114b6
movq %rbx, %rdi
callq 0x13316
movl %eax, %r14d
movb $0x1, %r12b
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x113cc
testb %r12b, %r12b
jne 0x14066
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0x113cc
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/dnegovan[P]Intruder-On-Donnar-V/Player.cpp
// Function: Player::Player()
Player::Player()
{
    state = UNFINISHED;
    incubated = false;
    crewInfected = 1;
    crewDead = 0;
    innocentsShot = 0;
    injectedWrong = false;
    ingredientsFound = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x28(%rdi)
movl $0x1, 0x24(%rdi)
movq %rax, 0x2c(%rdi)
movb %al, 0x18(%rdi)
movq %rax, 0x1c(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dnegovan[P]Intruder-On-Donnar-V/Space.cpp
// Function: Space::checkForIngredient(Player&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Space::checkForIngredient(Player& markNelson, std::string item)
{
    //update counter if we've found an ingredient
    if (std::find(ingredientList.begin(),
        ingredientList.end(), item)
        != ingredientList.end())
    {
        markNelson.ingredientsFound++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8d3e(%rip), %rdi      # 0x1db80
movq 0x8d3f(%rip), %rsi      # 0x1db88
callq 0xdb89
cmpq 0x8d33(%rip), %rax      # 0x1db88
je 0x14e5a
incl 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lemire[P]runningmaxmin/runningmaxmin.cpp
// Function: getwhite(unsigned int)
std::vector<floattype> getwhite(uint size) {
    std::vector<floattype> data(size);
    for (uint k = 0; k < size; ++k)
        data[k] = (1.0 * rand() / (RAND_MAX)) - 0.5;
    return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x3fce
testl %ebp, %ebp
je 0x23e9
xorl %r15d, %r15d
callq 0x2050
vcvtsi2sd %eax, %xmm1, %xmm0
vdivsd 0x6c38(%rip), %xmm0, %xmm0 # 0x9008
vaddsd 0x6c38(%rip), %xmm0, %xmm0 # 0x9010
movq (%rbx), %rax
vmovsd %xmm0, (%rax,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x23bf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lemire[P]runningmaxmin/runningmaxmin.cpp
// Function: getrandomwalk(unsigned int)
std::vector<floattype> getrandomwalk(uint size) {
    std::vector<floattype> data(size);
    data[0] = 0.0;
    for (uint k = 1; k < size; ++k)
        data[k] = (1.0 * rand() / (RAND_MAX)) - 0.5 + data[k - 1];
    return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x3fce
movq (%rbx), %rax
movq $0x0, (%rax)
cmpl $0x2, %ebp
jb 0x2459
movl $0x1, %r15d
callq 0x2050
vcvtsi2sd %eax, %xmm1, %xmm0
vdivsd 0x6bcf(%rip), %xmm0, %xmm0 # 0x9008
vaddsd 0x6bcf(%rip), %xmm0, %xmm0 # 0x9010
movq (%rbx), %rax
vaddsd -0x8(%rax,%r15,8), %xmm0, %xmm0
vmovsd %xmm0, (%rax,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x2428
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lemire[P]runningmaxmin/runningmaxmin.cpp
// Function: getcin()
std::vector<floattype> getcin() {
    float val;
    std::cin >> val;
    std::vector<floattype> v;
    while (std::cin) {
        v.push_back(val);
        std::cin >> val;
    }
    std::cout << "# Read " << v.size() << " data points. " << std::endl;
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0xab5c(%rip), %r14      # 0xcfd8
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x10(%rsp), %r12
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x24ec
vcvtss2sd 0xc(%rsp), %xmm1, %xmm0
vmovsd %xmm0, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x24d4
vmovsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x24df
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8204
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
jmp 0x24a1
movq 0xaad5(%rip), %rdi      # 0xcfc8
leaq 0x6b86(%rip), %rsi      # 0x9080
movl $0x7, %edx
callq 0x2150
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x3, %rsi
movq 0xaab2(%rip), %rdi      # 0xcfc8
callq 0x20e0
movq %rax, %r14
leaq 0x6b63(%rip), %rsi      # 0x9088
movl $0xe, %edx
movq %rax, %rdi
callq 0x2150
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x256c
jmp 0x256c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x257c
callq 0x2120
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/umatin[P]LogarithmicErrorRegression/./src/fast_random.h
// Function: xorshf96()
unsigned long xorshf96(void) {//period 2^96-1
    unsigned long t;
    x ^= x << 16;
    x ^= x >> 5;
    x ^= x << 1;

    t = x;
    x = y;
    y = z;
    z = t ^ x ^ y;

    return z;
}

// Assembly:
movq 0xbc7d(%rip), %rax      # 0xe1e0
movq %rax, %rcx
shlq $0x10, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x5, %rax
xorq %rcx, %rax
leaq (%rax,%rax), %rcx
xorq %rax, %rcx
movq 0xbc63(%rip), %rdx      # 0xe1e8
movq %rdx, 0xbc54(%rip)      # 0xe1e0
movq 0xbc5d(%rip), %rax      # 0xe1f0
movq %rax, 0xbc4e(%rip)      # 0xe1e8
xorq %rdx, %rax
xorq %rcx, %rax
movq %rax, 0xbc49(%rip)      # 0xe1f0
retq
// File: /workspace/github_cpp_makefile_star2_O1/umatin[P]LogarithmicErrorRegression/./src/interpolation.h
// Function: fit_line(long, long, double, double)
linear_regression fit_line(long fr, long to, double dfr, double dto){
    double a = (to - fr) / (dto - dfr);
    double b = to - (dto * a);
    if (a == -std::numeric_limits<double>::infinity()){
        a = std::numeric_limits<double>::infinity();
    }
    return linear_regression(a,b);
}

// Assembly:
vcvtsi2sd %rsi, %xmm2, %xmm2
subq %rdi, %rsi
vcvtsi2sd %rsi, %xmm3, %xmm3
vsubsd %xmm0, %xmm1, %xmm0
vdivsd %xmm0, %xmm3, %xmm0
vcmplesd 0x79b2(%rip), %xmm0, %k1 # 0xa008
vfnmadd213sd %xmm2, %xmm0, %xmm1 # xmm1 = -(xmm0 * xmm1) + xmm2
vmovsd 0x79ab(%rip), %xmm0 {%k1} # 0xa010
retq
// File: /workspace/github_cpp_makefile_star2_O1/umatin[P]LogarithmicErrorRegression/./src/competitor_regression.h
// Function: simple_linear_regression(std::vector<double, std::allocator<double>>&)
linear_regression simple_linear_regression(std::vector<double>& data){
    long double count = data.size();
    long double x_sum = 0;
    long double y_sum = 0;
    long double xx_sum = 0;
    long double xy_sum = 0;

    for(int i = 0; i < data.size(); i++){
        x_sum += data[i];
        y_sum += (long double)i;
        xx_sum += data[i] * data[i];
        xy_sum += (long double)i * data[i];
    }

    double a = ((count * xy_sum) - (x_sum * y_sum)) / ((count * xx_sum) - (x_sum * x_sum));
    double b = (y_sum - (a * x_sum)) / count;
    assert(a >= 0);
    return linear_regression(a,b);
}

// Assembly:
subq $0x38, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq %rdx, %rcx
subq %rax, %rcx
xorl %esi, %esi
sarq $0x3, %rcx
sets %sil
movq %rcx, 0x30(%rsp)
fildll 0x30(%rsp)
leaq 0x7987(%rip), %rdi      # 0xa018
fadds (%rdi,%rsi,4)
fldz
fld %st(0)
fld %st(1)
fld %st(2)
cmpq %rax, %rdx
je 0x26fc
fstp %st(0)
fstp %st(0)
fstp %st(1)
fstp %st(0)
cmpq $0x1, %rcx
adcq $0x0, %rcx
fldz
xorl %edx, %edx
fld %st(0)
fld %st(1)
fld %st(2)
fxch %st(3)
fxch %st(1)
fxch %st(2)
fxch %st(1)
vmovsd (%rax,%rdx,8), %xmm0
vmovsd %xmm0, 0x28(%rsp)
fldl 0x28(%rsp)
fadd %st, %st(1)
movl %edx, 0x4(%rsp)
fildl 0x4(%rsp)
fadd %st, %st(3)
vmulsd %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
fxch %st(5)
faddl 0x20(%rsp)
fxch %st(5)
fmulp %st, %st(1)
faddp %st, %st(3)
incq %rdx
cmpq %rdx, %rcx
jne 0x26c3
fld %st(1)
fmul %st(1), %st
fxch %st(3)
fmul %st(5), %st
fsubp %st, %st(3)
fld %st(0)
fmul %st(1), %st
fxch %st(4)
fmul %st(5), %st
fsubp %st, %st(4)
fxch %st(2)
fdivp %st, %st(3)
fxch %st(2)
fstpl 0x18(%rsp)
vmovsd 0x18(%rsp), %xmm0
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jb 0x2747
vmovsd %xmm0, 0x10(%rsp)
fmull 0x10(%rsp)
fsubrp %st, %st(1)
fdivp %st, %st(1)
fstpl 0x8(%rsp)
vmovsd 0x8(%rsp), %xmm1
addq $0x38, %rsp
retq
fstp %st(2)
fstp %st(1)
fstp %st(0)
leaq 0x7a2c(%rip), %rdi      # 0xa180
leaq 0x7a2c(%rip), %rsi      # 0xa187
leaq 0x7a43(%rip), %rcx      # 0xa1a5
movl $0x19, %edx
callq 0x2130