LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc360(%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 0xf6ef
cmpl %r14d, %eax
setge %cl
cmpl %ebx, %eax
setle %dl
testb %dl, %cl
jne 0xfd50
movq 0xc312(%rip), %r15      # 0x1bfc8
leaq 0x68d6(%rip), %r12      # 0x16593
movl $0x23, %edx
movq %r15, %rdi
leaq 0x685a(%rip), %rsi      # 0x16526
callq 0x3210
movq %r15, %rdi
movl %r14d, %esi
callq 0x3310
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
leaq 0x76ca(%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 0xf6ef
cmpl %r14d, %eax
setl %cl
cmpl %ebx, %eax
setg %dl
orb %cl, %dl
jne 0xfcbd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc242(%rip), %rdi      # 0x1bfc8
callq 0x3210
movq %rax, %rbx
leaq 0x679e(%rip), %rsi      # 0x16533
movl $0x16, %edx
movq %rax, %rdi
callq 0x3210
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x32d0
movq %rax, %rbx
leaq 0x75ff(%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 0xfb66
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
ja 0xfe18
ucomisd -0x28(%rbp), %xmm0
jbe 0xfeab
movq 0xc1a9(%rip), %rbx      # 0x1bfc8
leaq 0x6700(%rip), %r14      # 0x16526
leaq 0x758b(%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 0xfb66
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
ja 0xfe2d
ucomisd -0x28(%rbp), %xmm0
ja 0xfe2d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x102a6
callq 0x31c0
movl 0x8(%rbx), %eax
addl $-0x6, %eax
testl %eax, %eax
jle 0x102dd
movl %eax, %r14d
leaq 0x6373(%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 0x102ba
movq 0xbcdc(%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 0x10313
jmp 0x10313
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x10323
callq 0x31c0
movq 0xbc96(%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_O3/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 0xbc50(%rip), %r14      # 0x1bfc8
leaq 0x6216(%rip), %r15      # 0x16595
movq 0xbc52(%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
movl 0x20(%rbx,%rax), %eax
testb $0x5, %al
je 0x10431
movl $0xf, %edx
movq %r14, %rdi
leaq 0x61cc(%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
movl 0x20(%rbx,%rax), %eax
testb $0x5, %al
jne 0x1038a
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1044b
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 0x1046f
callq 0x31c0
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbb23(%rip), %r14      # 0x1bfc8
leaq 0x612a(%rip), %r15      # 0x165d6
movq 0xbb25(%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
movl 0x20(%rbx,%rax), %eax
testb $0x5, %al
je 0x1055e
movl $0x2b, %edx
movq %r14, %rdi
leaq 0x60da(%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
movl 0x20(%rbx,%rax), %eax
testb $0x5, %al
jne 0x104b7
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10578
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 0x1059c
callq 0x31c0
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10619
callq 0x31c0
movl 0x8(%rbx), %r15d
leaq 0x6009(%rip), %r14      # 0x1662d
addq $-0x3, %r15
testl %r15d, %r15d
jle 0x1064b
movl %r15d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl $0x1, %r8d
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x3200
jmp 0x10624
movq 0xb96e(%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 0x10681
jmp 0x10681
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x10691
callq 0x31c0
movq 0xb928(%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_O3/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 0x13ff4
leaq 0xaf44(%rip), %rax      # 0x1bb10
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x5a51(%rip), %rcx      # 0x1662f
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3290
movl $0x68, %edi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0x13bf4
movq %r15, 0x8(%rbx)
leaq 0x30(%rbx), %r14
leaq 0xbef1(%rip), %rsi      # 0x1cb00
movq %r14, %rdi
callq 0xd770
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5a15(%rip), %rsi      # 0x1663b
leaq 0x5a14(%rip), %rdx      # 0x16641
leaq -0x38(%rbp), %rdi
callq 0xe56e
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe60c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x10c50
callq 0x31c0
leaq -0x38(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x59e4(%rip), %rsi      # 0x16642
leaq 0x59ef(%rip), %rdx      # 0x16654
callq 0xe56e
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe60c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x10c84
callq 0x31c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10c93
jmp 0x10cb0
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0x10ca9
jmp 0x10cb3
jmp 0x10cb0
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0x10cb3
movq %rax, %r14
movq %rbx, %rdi
callq 0x14022
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbded(%rip), %rsi      # 0x1cb40
movq 0xbdee(%rip), %rdx      # 0x1cb48
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0xd7ca
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd686
movl %eax, %r15d
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x10d85
callq 0x31c0
testb %r15b, %r15b
je 0x10e6e
movq 0xb233(%rip), %r15      # 0x1bfc8
leaq 0x52f7(%rip), %rsi      # 0x16093
movl $0x5, %edx
movq %r15, %rdi
callq 0x3210
leaq 0x58a5(%rip), %rsi      # 0x16655
movl $0x8e, %edx
movq %r15, %rdi
callq 0x3210
leaq 0x52ea(%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 0x58e5(%rip), %r12      # 0x166e4
leaq 0x58f2(%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 0xf6ef
leal -0x3(%rax), %ecx
cmpl $-0x2, %ecx
jb 0x10e06
cmpl $0x1, %eax
jne 0x10e6e
cmpl $0x0, 0x20(%rbx)
je 0x10e7b
movl $0x2, 0x30(%rbx)
jmp 0x10e82
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14098
jmp 0x10e84
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
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x10ea4
callq 0x31c0
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x111b3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x111c5
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x111d7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x111e9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x111fb
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x1120d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x1121f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x11237
callq 0x31c0
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x1124f
callq 0x31c0
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x11261
callq 0x31c0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x11273
callq 0x31c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd718
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5226(%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 0xa821(%rip), %rdi      # 0x1bfc8
leaq 0x4c7e(%rip), %rsi      # 0x1642c
movl $0x5, %edx
callq 0x3210
leaq -0x48(%rbp), %r14
movq 0xa805(%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 0x11833
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 0x117c3
movq 0xa78e(%rip), %rdi      # 0x1bfc8
leaq 0x5102(%rip), %rsi      # 0x16943
movl $0x2, %edx
callq 0x3210
movq 0xa776(%rip), %rdi      # 0x1bfc8
leaq 0x4855(%rip), %rsi      # 0x160ae
movl $0x4, %edx
callq 0x3210
leaq -0x250(%rbp), %rdi
callq 0x3040
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1187d
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 0x1189d
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x118ae
callq 0x31c0
leaq -0x250(%rbp), %rdi
callq 0x3050
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8ee0(%rip), %rbx      # 0x1bfc8
leaq 0x3855(%rip), %rsi      # 0x16944
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3210
leaq 0x3787(%rip), %r14      # 0x1688a
leaq 0x37a1(%rip), %r15      # 0x168ab
leaq 0x37be(%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 0xf6ef
leal -0x4(%rax), %ecx
cmpl $-0x3, %ecx
jb 0x13111
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1408e
movq %rax, %rdi
callq 0xeb0c
testb %al, %al
jne 0x131c3
movq 0xc8(%rbx), %rdi
callq 0x1408e
movq %rax, %rdi
callq 0xeaf8
testb %al, %al
je 0x131c3
movq 0xc8(%rbx), %rdi
jmp 0x1326c
movq 0xd8(%rbx), %rdi
callq 0x1408e
movq %rax, %rdi
callq 0xeb0c
testb %al, %al
jne 0x131fc
movq 0xd8(%rbx), %rdi
callq 0x1408e
movq %rax, %rdi
callq 0xeaf8
testb %al, %al
je 0x131fc
movq 0xd8(%rbx), %rdi
jmp 0x1326c
movq 0xe8(%rbx), %rdi
callq 0x1408e
movq %rax, %rdi
callq 0xeb0c
testb %al, %al
jne 0x13235
movq 0xe8(%rbx), %rdi
callq 0x1408e
movq %rax, %rdi
callq 0xeaf8
testb %al, %al
je 0x13235
movq 0xe8(%rbx), %rdi
jmp 0x1326c
movq 0xf0(%rbx), %rdi
callq 0x1408e
movq %rax, %rdi
callq 0xeb0c
testb %al, %al
jne 0x13285
movq 0xf0(%rbx), %rdi
callq 0x1408e
movq %rax, %rdi
callq 0xeaf8
testb %al, %al
je 0x13285
movq 0xf0(%rbx), %rdi
callq 0x1408e
movq %rax, %rdi
movl $0x1, %esi
callq 0xeb02
incl 0x24(%rbx)
movb $0x1, %al
jmp 0x132ac
movl 0x20(%rbx), %eax
cmpl $0x1, %eax
je 0x1329a
testl %eax, %eax
jne 0x132a3
movl $0xe, 0x30(%rbx)
jmp 0x132aa
movl $0x10, 0x30(%rbx)
jmp 0x132aa
movl $0xf, 0x30(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d03(%rip), %r14      # 0x1bfc8
leaq 0x387d(%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 0x3e23(%rip), %rsi      # 0x17116
movl $0x2, %edx
movq %rax, %rdi
callq 0x3210
leaq 0x36bc(%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 0x1333f
movl %ebx, %eax
movl $0x88888889, %esi       # imm = 0x88888889
imulq %rax, %rsi
shrq $0x25, %rsi
movq 0x8c90(%rip), %rdi      # 0x1bfc8
callq 0x3310
jmp 0x13357
movq 0x8c82(%rip), %rdi      # 0x1bfc8
leaq 0x3802(%rip), %rsi      # 0x16b4f
movl $0x1, %edx
callq 0x3210
movq 0x8c6a(%rip), %rdi      # 0x1bfc8
leaq 0x40ef(%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 0x133a8
movq 0x8c31(%rip), %rdi      # 0x1bfc8
leaq 0x37b1(%rip), %rsi      # 0x16b4f
movl $0x1, %edx
callq 0x3210
movq 0x8c19(%rip), %rdi      # 0x1bfc8
movl %ebx, %esi
callq 0x3310
movq %rax, %rbx
leaq 0x2cee(%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_O3/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 0x13ff4
leaq 0x86a4(%rip), %rax      # 0x1bbe0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x3ccd(%rip), %rcx      # 0x1721b
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3290
movq $0x0, 0x8(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x3cb5(%rip), %rsi      # 0x17227
leaq 0x3cbe(%rip), %rdx      # 0x17237
leaq -0x38(%rbp), %rdi
callq 0xe56e
leaq 0x30(%rbx), %r14
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe60c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x135a0
callq 0x31c0
leaq -0x38(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x3c8a(%rip), %rsi      # 0x17238
leaq 0x3c95(%rip), %rdx      # 0x1724a
callq 0xe56e
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe60c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x135d4
callq 0x31c0
leaq 0x9a65(%rip), %rsi      # 0x1d040
movq %r14, %rdi
callq 0xd770
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x135f2
jmp 0x13607
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1360a
callq 0x31c0
jmp 0x1360a
jmp 0x13607
movq %rax, %r14
movq %rbx, %rdi
callq 0x14022
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x136ac
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3be0(%rip), %rsi      # 0x1724b
leaq 0x3c00(%rip), %rdx      # 0x17272
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xe56e
movq %r15, %rdi
callq 0xf629
movl %eax, %r15d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13697
callq 0x31c0
cmpb $0x59, %r15b
jne 0x136ac
movq %rbx, %rsi
callq 0x136de
movl $0x0, 0x1c(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14098
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 0x136d5
callq 0x31c0
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13ff4
leaq 0x7fd4(%rip), %rax      # 0x1bc78
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x3660(%rip), %rcx      # 0x17316
movl $0x6, %r8d
xorl %esi, %esi
callq 0x3290
movl $0x68, %edi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
callq 0x13f38
movq %r15, 0x8(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x3632(%rip), %rsi      # 0x1731d
leaq 0x3637(%rip), %rdx      # 0x17329
leaq -0x38(%rbp), %rdi
callq 0xe56e
leaq 0x30(%rbx), %r14
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe60c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x13d19
callq 0x31c0
leaq -0x38(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x3603(%rip), %rsi      # 0x1732a
leaq 0x3609(%rip), %rdx      # 0x17337
callq 0xe56e
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0xe60c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x13d4d
callq 0x31c0
leaq 0x95ec(%rip), %rsi      # 0x1d340
movq %r14, %rdi
callq 0xd770
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13d6b
jmp 0x13d88
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0x13d81
jmp 0x13d8b
jmp 0x13d88
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0x13d8b
movq %rax, %r14
movq %rbx, %rdi
callq 0x14022
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x108, %rsp            # imm = 0x108
movb $0x1, %r15b
movl $0x1, %r14d
leaq -0x118(%rbp), %rbx
movq %rbx, %rdi
callq 0x10eac
testb $0x1, %r15b
je 0x13e42
movq %rbx, %rdi
callq 0x130d6
movl %eax, %r14d
cmpl $0x3, %eax
je 0x13e6f
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11282
movq %rbx, %rdi
callq 0x130d6
movl %eax, %r14d
movq %rbx, %rdi
callq 0x11198
movl %r14d, %eax
decl %eax
xorl %r15d, %r15d
cmpl $0x2, %eax
jb 0x13e24
jmp 0x13e7b
leaq -0x118(%rbp), %rdi
callq 0x11198
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x11198
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8f86(%rip), %rdi      # 0x1db80
movq 0x8f87(%rip), %rsi      # 0x1db88
callq 0xd9a5
cmpq 0x8f7b(%rip), %rax      # 0x1db88
je 0x14c12
incl 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xac7d(%rip), %rax      # 0xd1e0
movq 0xac7e(%rip), %rsi      # 0xd1e8
movq 0xac7f(%rip), %rdx      # 0xd1f0
movq %rax, %rcx
shlq $0x10, %rcx
movq %rsi, 0xac61(%rip)      # 0xd1e0
movq %rdx, 0xac62(%rip)      # 0xd1e8
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x5, %rax
xorq %rcx, %rax
xorq %rax, %rsi
addq %rax, %rax
xorq %rsi, %rax
xorq %rdx, %rax
movq %rax, 0xac4a(%rip)      # 0xd1f0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x79b3(%rip), %xmm0, %k1 # 0xa008
vfnmadd213sd %xmm2, %xmm0, %xmm1 # xmm1 = -(xmm0 * xmm1) + xmm2
vmovsd 0x79ac(%rip), %xmm0 {%k1} # 0xa010
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %rdx
movq (%rdi), %rax
xorl %esi, %esi
leaq 0x799f(%rip), %rdi      # 0xa018
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, 0x30(%rsp)
sets %sil
fildll 0x30(%rsp)
fadds (%rdi,%rsi,4)
fldz
fld %st(0)
fld %st(1)
fld %st(2)
cmpq %rax, %rdx
je 0x26fb
cmpq $0x1, %rcx
fstp %st(0)
fstp %st(0)
fstp %st(1)
fstp %st(0)
fldz
fld %st(0)
fld %st(1)
fld %st(2)
fxch %st(3)
fxch %st(1)
fxch %st(2)
fxch %st(1)
adcq $0x0, %rcx
xorl %edx, %edx
vmovsd (%rax,%rdx,8), %xmm0
vmovsd %xmm0, 0x28(%rsp)
vmulsd %xmm0, %xmm0, %xmm0
fldl 0x28(%rsp)
fadd %st, %st(1)
movl %edx, 0x4(%rsp)
incq %rdx
fildl 0x4(%rsp)
fadd %st, %st(3)
vmovsd %xmm0, 0x20(%rsp)
fxch %st(5)
faddl 0x20(%rsp)
fxch %st(5)
fmulp %st, %st(1)
faddp %st, %st(3)
cmpq %rdx, %rcx
jne 0x26c2
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)
vxorpd %xmm1, %xmm1, %xmm1
vmovsd 0x18(%rsp), %xmm0
vucomisd %xmm1, %xmm0
jb 0x2746
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
leaq 0x79f3(%rip), %rdi      # 0xa140
leaq 0x79f3(%rip), %rsi      # 0xa147
leaq 0x7a0a(%rip), %rcx      # 0xa165
movl $0x19, %edx
fstp %st(2)
fstp %st(1)
fstp %st(0)
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/umatin[P]LogarithmicErrorRegression/./src/competitor_regression.h
// Function: simple_linear_regression_stable(std::vector<double, std::allocator<double>>&)
linear_regression simple_linear_regression_stable(std::vector<double>& data){
    long double count = data.size();
    long double x_mean = 0;
    long double y_mean = 0;
    long double xx_sum = 0;
    long double xy_sum = 0;

    for(int i = 0; i < data.size(); i++){
        x_mean += data[i];
        y_mean += (long double)i;
    }
    x_mean /= count;
    y_mean /= count;

    for(int i = 0; i < data.size(); i++){
        xx_sum += std::pow<long double>((long double)data[i] - x_mean, 2);
        xy_sum += (long double)(i - y_mean) * (long double)(data[i] - x_mean);
    }

    double a = xy_sum / xx_sum;
    double b = y_mean - (a * x_mean);

    assert(a >= 0);
    return linear_regression(a,b);
}

// Assembly:
subq $0x28, %rsp
movq 0x8(%rdi), %rdx
movq (%rdi), %rax
xorl %esi, %esi
leaq 0x7899(%rip), %rdi      # 0xa018
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, 0x20(%rsp)
sets %sil
fildll 0x20(%rsp)
fadds (%rdi,%rsi,4)
fldz
cmpq %rax, %rdx
je 0x2839
cmpq $0x1, %rcx
movq %rcx, %rsi
fstp %st(0)
fldz
fld %st(0)
adcq $0x0, %rsi
xorl %edi, %edi
fxch %st(1)
faddl (%rax,%rdi,8)
movl %edi, 0x4(%rsp)
fxch %st(1)
fiaddl 0x4(%rsp)
incq %rdi
cmpq %rdi, %rsi
jne 0x27b7
fxch %st(1)
fdiv %st(2), %st
fxch %st(1)
fdivp %st, %st(2)
cmpq %rax, %rdx
je 0x2839
cmpq $0x1, %rcx
fldz
fld %st(0)
adcq $0x0, %rcx
xorl %edx, %edx
fld %st(2)
fsubrl (%rax,%rdx,8)
fld %st(0)
fmul %st(1), %st
faddp %st, %st(2)
movl %edx, (%rsp)
fld %st(4)
fisubrl (%rsp)
incq %rdx
fmulp %st, %st(1)
faddp %st, %st(2)
cmpq %rdx, %rcx
jne 0x27e9
fdivrp %st, %st(1)
fstpl 0x18(%rsp)
vxorpd %xmm1, %xmm1, %xmm1
vmovsd 0x18(%rsp), %xmm0
vucomisd %xmm1, %xmm0
jb 0x2839
vmovsd %xmm0, 0x10(%rsp)
fmull 0x10(%rsp)
fsubrp %st, %st(1)
fstpl 0x8(%rsp)
vmovsd 0x8(%rsp), %xmm1
addq $0x28, %rsp
retq
leaq 0x7900(%rip), %rdi      # 0xa140
leaq 0x7900(%rip), %rsi      # 0xa147
leaq 0x7959(%rip), %rcx      # 0xa1a7
movl $0x33, %edx
fstp %st(0)
fstp %st(0)
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/umatin[P]LogarithmicErrorRegression/./src/irls.h
// Function: weighted_mean_x(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>&)
long double weighted_mean_x(std::vector<double> data, std::vector<double>& weights){
    long double w_sum = 0;
    long double d_sum = 0;
    for(int i = 0; i < data.size(); i++){
        w_sum += weights[i];
        d_sum += weights[i] * (long double)data[i];
    }
    return d_sum/w_sum;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
flds 0x7783(%rip)            # 0xa0c8
subq %rax, %rcx
je 0x2975
fstp %st(0)
movq (%rsi), %rdx
sarq $0x3, %rcx
fldz
fld %st(0)
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
fldl (%rdx,%rsi,8)
fadd %st, %st(1)
fmull (%rax,%rsi,8)
incq %rsi
faddp %st, %st(2)
cmpq %rsi, %rcx
jne 0x2961
fdivrp %st, %st(1)
retq
// File: /workspace/github_cpp_makefile_star2_O3/umatin[P]LogarithmicErrorRegression/./src/irls.h
// Function: weighted_mean_y(std::vector<double, std::allocator<double>>&)
long double weighted_mean_y(std::vector<double>& weights){
    long double w_sum = 0;
    long double d_sum = 0;
    for(int i = 0; i < weights.size(); i++){
        w_sum += weights[i];
        d_sum += weights[i] * (long double)i;
    }
    return d_sum/w_sum;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
flds 0x7745(%rip)            # 0xa0c8
subq %rax, %rcx
je 0x29b5
sarq $0x3, %rcx
fstp %st(0)
fldz
fld %st(0)
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
fldl (%rax,%rdx,8)
fadd %st, %st(1)
movl %edx, -0x4(%rsp)
incq %rdx
fimull -0x4(%rsp)
faddp %st, %st(2)
cmpq %rdx, %rcx
jne 0x299c
fdivrp %st, %st(1)
retq
// File: /workspace/github_cpp_makefile_star2_O3/umatin[P]LogarithmicErrorRegression/./src/irls.h
// Function: weighted_simple_regression(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
linear_regression weighted_simple_regression(std::vector<double>& data, std::vector<double>& weights){
    long double x_mean = weighted_mean_x(data, weights);
    long double y_mean = weighted_mean_y(weights);

    long double top = 0;
    long double bot = 0;
    for(int i = 0; i < data.size(); i++){
        top += weights[i] * (data[i] - x_mean) * ((long double)i - y_mean);
        bot += weights[i] * (data[i] - x_mean) * (data[i] - x_mean);
    }

    double a = top/bot;
    double b = y_mean - (a * x_mean);
    return linear_regression(a,b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x38(%rsp), %r15
movq %rdi, %rbx
movq %rsi, %r14
movq %rbx, %rsi
movq %r15, %rdi
callq 0x4a66
movq 0x8(%r15), %rcx
movq (%r15), %rdi
movq %rcx, %rax
subq %rdi, %rax
je 0x2a0f
movq (%r14), %rcx
sarq $0x3, %rax
fldz
fld %st(0)
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %edx, %edx
fldl (%rcx,%rdx,8)
fadd %st, %st(1)
fmull (%rdi,%rdx,8)
incq %rdx
faddp %st, %st(2)
cmpq %rdx, %rax
jne 0x29f9
fdivrp %st, %st(1)
jmp 0x2a22
flds 0x76b3(%rip)            # 0xa0c8
testq %rcx, %rcx
je 0x2a37
fstp %st(0)
flds 0x76a6(%rip)            # 0xa0c8
fstpt 0x14(%rsp)
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2260
fldt 0x14(%rsp)
movq (%r14), %rax
movq 0x8(%r14), %rcx
flds 0x7684(%rip)            # 0xa0c8
subq %rax, %rcx
je 0x2a76
sarq $0x3, %rcx
fstp %st(0)
fldz
fld %st(0)
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
fldl (%rax,%rdx,8)
fadd %st, %st(1)
movl %edx, 0x10(%rsp)
incq %rdx
fimull 0x10(%rsp)
faddp %st, %st(2)
cmpq %rdx, %rcx
jne 0x2a5d
fdivrp %st, %st(1)
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
je 0x2ac6
sarq $0x3, %rdx
fldz
fld %st(0)
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
fld %st(3)
fsubrl (%rcx,%rsi,8)
fld %st(0)
fmull (%rax,%rsi,8)
movl %esi, 0xc(%rsp)
fld %st(4)
fisubrl 0xc(%rsp)
incq %rsi
fmul %st(1), %st
faddp %st, %st(4)
fmulp %st, %st(1)
faddp %st, %st(1)
cmpq %rsi, %rdx
jne 0x2a94
fdivrp %st, %st(1)
fstpl 0x30(%rsp)
vmovsd 0x30(%rsp), %xmm0
jmp 0x2ace
vmovsd 0x7552(%rip), %xmm0     # 0xa020
vmovsd %xmm0, 0x28(%rsp)
fxch %st(1)
fmull 0x28(%rsp)
fsubrp %st, %st(1)
fstpl 0x20(%rsp)
vmovsd 0x20(%rsp), %xmm1
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/umatin[P]LogarithmicErrorRegression/./src/helpers/../exponential_search.h
// Function: exponential_search_lower_bound_steps(int, double, std::vector<double, std::allocator<double>>&, int&)
int exponential_search_lower_bound_steps(int m, double key, std::vector<double> & data, int & steps) {
    // Continue doubling the bound until it contains the lower bound. Then use
    // binary search.
    steps = 1;
    int bound = 1;
    int l, r;  // will do binary search in range [l, r)
    if (data[m] >= key) {
        int size = m;
        while (bound < size && data[m - bound] >= key) {
            bound *= 2;
            steps++;
        }
        l = m - std::min<int>(bound, size);
        r = m - bound / 2;
    } else {
        int size = data.size() - m;
        while (bound < size && data[m + bound] < key) {
            bound *= 2;
            steps++;
        }
        l = m + bound / 2;
        r = m + std::min<int>(bound, size);
    }
    return binary_search_lower_bound(l, r, key, data);
}

// Assembly:
movl $0x1, (%rdx)
movslq %edi, %rax
movq (%rsi), %rcx
vmovsd (%rcx,%rax,8), %xmm1
vucomisd %xmm0, %xmm1
jae 0x2cf7
movq 0x8(%rsi), %r8
movl $0x1, %esi
subq %rcx, %r8
shrq $0x3, %r8
subl %edi, %r8d
cmpl $0x2, %r8d
jl 0x2ce3
movl $0x1, %esi
movl $0x2, %eax
leal (%rsi,%rdi), %r9d
movslq %r9d, %r9
vucomisd (%rcx,%r9,8), %xmm0
jbe 0x2ce3
movl %eax, (%rdx)
addl %esi, %esi
incl %eax
cmpl %r8d, %esi
jl 0x2cc9
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
addl %edi, %eax
cmpl %esi, %r8d
cmovll %r8d, %esi
jmp 0x2d40
movl $0x1, %r8d
cmpl $0x2, %edi
jl 0x2d26
movl $0x2, %eax
movl %edi, %esi
subl %r8d, %esi
movslq %esi, %rsi
vmovsd (%rcx,%rsi,8), %xmm1
vucomisd %xmm0, %xmm1
jb 0x2d26
movl %eax, (%rdx)
addl %r8d, %r8d
incl %eax
cmpl %edi, %r8d
jl 0x2d07
cmpl %edi, %r8d
movl %edi, %edx
movl %r8d, %esi
movl %edi, %eax
cmovll %r8d, %edx
shrl $0x1f, %esi
addl %r8d, %esi
subl %edx, %eax
sarl %esi
negl %esi
addl %edi, %esi
cmpl %esi, %eax
jge 0x2d6f
movl %esi, %edi
subl %eax, %edi
movl %edi, %edx
shrl $0x1f, %edx
addl %edi, %edx
sarl %edx
leal (%rdx,%rax), %edi
movslq %edi, %r8
vmovsd (%rcx,%r8,8), %xmm1
vucomisd %xmm0, %xmm1
jb 0x2d69
movl %edi, %esi
jmp 0x2d42
leal 0x1(%rdx,%rax), %eax
jmp 0x2d42
retq
// File: /workspace/github_cpp_makefile_star2_O3/umatin[P]LogarithmicErrorRegression/./src/helpers/regression_benchmark.h
// Function: benchmark_lookup_linear_regression(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>, linear_regression)
long benchmark_lookup_linear_regression(std::vector<double> & data, std::vector<double> lookups, linear_regression lr){ 
    int data_size = data.size()-1;
    auto start = std::chrono::high_resolution_clock::now();
    
    for(int i = 0; i < lookups.size(); i++){
        long pos = lr.predict(lookups[i]);
        pos = std::max<long>(std::min<long>(pos, data_size), 0);
        DoNotOptimize(exponential_search_lower_bound_linear_head(pos, lookups[i], data));
    }

    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    return duration.count();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r12
movq 0x8(%rdi), %r13
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2040
movq %rax, %r14
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x2e0d
subq %r12, %r13
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
shlq $0x1d, %r13
addq %r13, %r12
xorl %r13d, %r13d
sarq $0x20, %r12
vmovsd (%rax,%r13,8), %xmm0
vmovsd (%rsp), %xmm2
movq %r15, %rsi
vmovapd %xmm0, %xmm1
vfmadd213sd 0x8(%rsp), %xmm2, %xmm1 # xmm1 = (xmm2 * xmm1) + mem
vcvttsd2si %xmm1, %rax
cmpq %rax, %r12
cmovlq %r12, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
andnl %eax, %ecx, %edi
callq 0x2ba8
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x2dc1
callq 0x2040
subq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq