LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x32d0
movq -0x1d0(%rbp), %rdi
movb $0x0, -0x189(%rbp)
callq 0x3300
movl $0x2, %edi
callq 0x18bd0
movl %eax, -0x1c8(%rbp)
jmp 0x18096
movl -0x1c8(%rbp), %eax
movl %eax, -0x190(%rbp)
movl -0x190(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x3340
movq %rax, -0x1e0(%rbp)
jmp 0x180bd
movq -0x1e0(%rbp), %rdi
leaq 0xb25(%rip), %rsi       # 0x18bf0
callq 0x30c0
movq %rax, -0x1e8(%rbp)
jmp 0x180d9
movq -0x1e8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x3410
jmp 0x180ec
leaq -0x1c0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x3230
jmp 0x18101
movq -0x1d0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3270
leaq -0x1c0(%rbp), %rdi
callq 0x3448
movq -0x1d0(%rbp), %rdi
callq 0x3320
subq $0x6, %rax
movl %eax, -0x1c4(%rbp)
cmpl $0x0, -0x1c4(%rbp)
jle 0x18198
movq -0x1d0(%rbp), %rdi
movslq -0x1c4(%rbp), %rsi
leaq 0x74d9(%rip), %rdx      # 0x1f62d
callq 0x3080
jmp 0x1815b
movl -0x1c4(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x1c4(%rbp)
jmp 0x18136
movq -0x1d0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
callq 0x3448
leaq -0x188(%rbp), %rdi
callq 0x3070
jmp 0x181d0
movb $0x1, -0x189(%rbp)
testb $0x1, -0x189(%rbp)
jne 0x181b4
movq -0x1d0(%rbp), %rdi
callq 0x3448
leaq -0x188(%rbp), %rdi
callq 0x3070
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3300
movq 0x10dcc(%rip), %rdi     # 0x28fc8
leaq 0x7392(%rip), %rsi      # 0x1f595
callq 0x3210
movq %rax, -0x40(%rbp)
jmp 0x1820e
movq -0x40(%rbp), %rdi
movq 0x10d97(%rip), %rsi     # 0x28fb0
callq 0x3240
jmp 0x18220
movq 0x10db1(%rip), %rdi     # 0x28fd8
leaq -0x28(%rbp), %rsi
callq 0x3290
jmp 0x18232
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x31c0
jmp 0x18246
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3030
movb %al, -0x41(%rbp)
jmp 0x1825e
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x18267
jmp 0x182ab
movq 0x10d5a(%rip), %rdi     # 0x28fc8
leaq 0x7351(%rip), %rsi      # 0x1f5c6
callq 0x3210
movq %rax, -0x50(%rbp)
jmp 0x18280
movq -0x50(%rbp), %rdi
movq 0x10d25(%rip), %rsi     # 0x28fb0
callq 0x3240
jmp 0x18292
jmp 0x182ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3448
jmp 0x182e1
jmp 0x182ad
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3030
movb %al, -0x51(%rbp)
jmp 0x182c5
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x181f5
jmp 0x182d2
leaq -0x28(%rbp), %rdi
callq 0x3448
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33c0
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3300
movq 0x10cbc(%rip), %rdi     # 0x28fc8
leaq 0x72c3(%rip), %rsi      # 0x1f5d6
callq 0x3210
movq %rax, -0x40(%rbp)
jmp 0x1831e
movq -0x40(%rbp), %rdi
movq 0x10c87(%rip), %rsi     # 0x28fb0
callq 0x3240
jmp 0x18330
movq 0x10ca1(%rip), %rdi     # 0x28fd8
leaq -0x28(%rbp), %rsi
callq 0x3290
jmp 0x18342
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x10, %edx
callq 0x3110
jmp 0x18356
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3030
movb %al, -0x41(%rbp)
jmp 0x1836e
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x18377
jmp 0x183bb
movq 0x10c4a(%rip), %rdi     # 0x28fc8
leaq 0x727c(%rip), %rsi      # 0x1f601
callq 0x3210
movq %rax, -0x50(%rbp)
jmp 0x18390
movq -0x50(%rbp), %rdi
movq 0x10c15(%rip), %rsi     # 0x28fb0
callq 0x3240
jmp 0x183a2
jmp 0x183bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3448
jmp 0x183f1
jmp 0x183bd
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3030
movb %al, -0x51(%rbp)
jmp 0x183d5
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x18305
jmp 0x183e2
leaq -0x28(%rbp), %rdi
callq 0x3448
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33c0
nopw (%rax,%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x32d0
movq -0x1d8(%rbp), %rdi
movb $0x0, -0x189(%rbp)
callq 0x3300
movq -0x1d0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x33b0
jmp 0x1845a
leaq -0x1c0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x3230
jmp 0x1846f
movq -0x1d8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3270
leaq -0x1c0(%rbp), %rdi
callq 0x3448
movq -0x1d8(%rbp), %rdi
callq 0x3320
subq $0x3, %rax
movl %eax, -0x1c4(%rbp)
cmpl $0x0, -0x1c4(%rbp)
jle 0x18506
movq -0x1d8(%rbp), %rdi
movslq -0x1c4(%rbp), %rsi
leaq 0x716b(%rip), %rdx      # 0x1f62d
callq 0x3080
jmp 0x184c9
movl -0x1c4(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x1c4(%rbp)
jmp 0x184a4
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
callq 0x3448
leaq -0x188(%rbp), %rdi
callq 0x3070
jmp 0x1853e
movb $0x1, -0x189(%rbp)
testb $0x1, -0x189(%rbp)
jne 0x18522
movq -0x1d8(%rbp), %rdi
callq 0x3448
leaq -0x188(%rbp), %rdi
callq 0x3070
movq -0x1e0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x33c0
nopw (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1cf70
movq -0x70(%rbp), %rdi
leaq 0xfdc1(%rip), %rax      # 0x28b18
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0x68ca(%rip), %rsi      # 0x1f62f
callq 0x32e0
jmp 0x18d6c
movl $0x68, %edi
callq 0x3220
movq %rax, -0x78(%rbp)
jmp 0x18d7c
movq -0x78(%rbp), %rdi
callq 0x1c910
jmp 0x18d87
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x30, %rdi
leaq 0x10dc2(%rip), %rsi     # 0x29b60
callq 0x13720
jmp 0x18da5
movq -0x70(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x33d0
movq -0x80(%rbp), %rdx
leaq 0x686f(%rip), %rsi      # 0x1f63b
leaq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0x18dd7
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x159a0
jmp 0x18de9
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x98(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x33d0
movq -0x90(%rbp), %rdx
leaq 0x681a(%rip), %rsi      # 0x1f642
leaq -0x60(%rbp), %rdi
callq 0x32f0
jmp 0x18e33
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x159a0
jmp 0x18e45
leaq -0x60(%rbp), %rdi
callq 0x3448
leaq -0x61(%rbp), %rdi
callq 0x3250
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x18edf
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31f0
jmp 0x18edf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x18ea8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
jmp 0x18edf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x18ed6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3448
leaq -0x61(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rdi
callq 0x1cfb0
movq -0x10(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x10bf9(%rip), %rsi     # 0x29ba0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x30f0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x13240
movb %al, -0x49(%rbp)
jmp 0x18fc6
leaq -0x38(%rbp), %rdi
callq 0x3448
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x18fdb
jmp 0x190c6
movq 0xffe6(%rip), %rdi      # 0x28fc8
leaq 0x60cf(%rip), %rsi      # 0x1f0b8
callq 0x3210
movq %rax, %rdi
leaq 0x665d(%rip), %rsi      # 0x1f655
callq 0x3210
movq %rax, %rdi
leaq 0x60cc(%rip), %rsi      # 0x1f0d3
callq 0x3210
movq %rax, %rdi
movq 0xff9a(%rip), %rsi      # 0x28fb0
callq 0x3240
movl $0x0, -0x48(%rbp)
movb $0x1, %al
cmpl $0x1, -0x48(%rbp)
movb %al, -0x69(%rbp)
jl 0x19037
cmpl $0x2, -0x48(%rbp)
setg %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x19040
jmp 0x19092
movq 0xff81(%rip), %rdi      # 0x28fc8
leaq 0x6696(%rip), %rsi      # 0x1f6e4
callq 0x3210
movq %rax, %rdi
leaq 0x669b(%rip), %rsi      # 0x1f6f8
callq 0x3210
movq %rax, %rdi
movq 0xff44(%rip), %rsi      # 0x28fb0
callq 0x3240
callq 0x175c0
movl %eax, -0x48(%rbp)
jmp 0x19022
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3448
jmp 0x190e3
cmpl $0x1, -0x48(%rbp)
jne 0x190c4
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x190b3
movq -0x18(%rbp), %rax
movl $0x1, 0x30(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x190d8
movq -0x18(%rbp), %rax
movl $0x2, 0x30(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x190d8
jmp 0x190c6
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d050
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xc8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x195ef
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1960e
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1962d
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1964c
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1966b
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1968a
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x196a9
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
callq 0x3448
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
callq 0x3448
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x3448
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x3448
movq -0x18(%rbp), %rdi
callq 0x1bea0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
leaq 0x5c47(%rip), %rsi      # 0x1f99d
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x33e0
leaq -0x230(%rbp), %rdi
callq 0x3300
movq 0xf24e(%rip), %rdi      # 0x28fc8
leaq 0x56ab(%rip), %rsi      # 0x1f42c
callq 0x3210
jmp 0x19d88
jmp 0x19d8a
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x3050
movq %rax, -0x248(%rbp)
jmp 0x19da6
movq -0x248(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3280
movb %al, -0x249(%rbp)
jmp 0x19dc4
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x19dd0
jmp 0x19e2f
movq 0xf1f1(%rip), %rdi      # 0x28fc8
leaq -0x230(%rbp), %rsi
callq 0x31e0
movq %rax, -0x258(%rbp)
jmp 0x19dec
movq -0x258(%rbp), %rdi
movq 0xf1b6(%rip), %rsi      # 0x28fb0
callq 0x3240
jmp 0x19e01
jmp 0x19d8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x3448
leaq -0x210(%rbp), %rdi
callq 0x3090
jmp 0x19e8f
movq 0xf192(%rip), %rdi      # 0x28fc8
leaq 0x5b06(%rip), %rsi      # 0x1f943
callq 0x3210
movq %rax, -0x260(%rbp)
jmp 0x19e4b
movq -0x260(%rbp), %rdi
leaq 0x527a(%rip), %rsi      # 0x1f0d3
callq 0x3210
jmp 0x19e60
leaq -0x210(%rbp), %rdi
callq 0x3060
jmp 0x19e6e
leaq -0x230(%rbp), %rdi
callq 0x3448
leaq -0x210(%rbp), %rdi
callq 0x3090
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x33c0
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0xd4de(%rip), %rdi      # 0x28fc8
leaq 0x3e53(%rip), %rsi      # 0x1f944
callq 0x3210
movb $0x1, %al
cmpl $0x1, -0xc(%rbp)
movb %al, -0xd(%rbp)
jl 0x1bb0b
cmpl $0x3, -0xc(%rbp)
setg %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x1bb14
jmp 0x1bb5e
movq 0xd4ad(%rip), %rdi      # 0x28fc8
leaq 0x3d68(%rip), %rsi      # 0x1f88a
callq 0x3210
movq %rax, %rdi
leaq 0x3d7a(%rip), %rsi      # 0x1f8ab
callq 0x3210
movq %rax, %rdi
leaq 0x3d8f(%rip), %rsi      # 0x1f8cf
callq 0x3210
movq %rax, %rdi
movq 0xd461(%rip), %rsi      # 0x28fb0
callq 0x3240
callq 0x175c0
movl %eax, -0xc(%rbp)
jmp 0x1baf6
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xd21d(%rip), %rdi      # 0x28fc8
leaq 0x3d97(%rip), %rsi      # 0x1fb49
callq 0x3210
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x40, %rsi
callq 0x31e0
movq %rax, %rdi
leaq 0x4345(%rip), %rsi      # 0x20116
callq 0x3210
movq %rax, %rdi
leaq 0x3be3(%rip), %rsi      # 0x1f9c3
callq 0x3210
movq -0x18(%rbp), %rax
imull $0xa, 0x38(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x3b, -0xc(%rbp)
jle 0x1be11
movl -0xc(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq 0xd1be(%rip), %rdi      # 0x28fc8
callq 0x33b0
jmp 0x1be24
movq 0xd1b0(%rip), %rdi      # 0x28fc8
leaq 0x3d30(%rip), %rsi      # 0x1fb4f
callq 0x3210
movq 0xd19d(%rip), %rdi      # 0x28fc8
leaq 0x461d(%rip), %rsi      # 0x2044f
callq 0x3210
movl -0xc(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1be5a
movq 0xd17a(%rip), %rdi      # 0x28fc8
leaq 0x3cfa(%rip), %rsi      # 0x1fb4f
callq 0x3210
movl -0xc(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, %esi
movq 0xd15a(%rip), %rdi      # 0x28fc8
callq 0x33b0
movq %rax, %rdi
leaq 0x3256(%rip), %rsi      # 0x1f0d3
callq 0x3210
movq %rax, %rdi
movq 0xd124(%rip), %rsi      # 0x28fb0
callq 0x3240
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1cf70
movq -0x70(%rbp), %rdi
leaq 0xcb41(%rip), %rax      # 0x28be8
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0x4166(%rip), %rsi      # 0x2021b
callq 0x32e0
jmp 0x1c0bc
movq -0x70(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x30, %rax
movq %rax, -0x80(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x33d0
movq -0x78(%rbp), %rdx
leaq 0x413f(%rip), %rsi      # 0x20227
leaq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0x1c0f3
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x159a0
jmp 0x1c102
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x33d0
movq -0x88(%rbp), %rdx
leaq 0x40f7(%rip), %rsi      # 0x20238
leaq -0x60(%rbp), %rdi
callq 0x32f0
jmp 0x1c14c
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x159a0
jmp 0x1c15e
leaq -0x60(%rbp), %rdi
callq 0x3448
leaq -0x61(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq 0xdf21(%rip), %rsi      # 0x2a0a0
callq 0x13720
jmp 0x1c186
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1c1f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1c1c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
jmp 0x1c1f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1c1ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3448
leaq -0x61(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rdi
callq 0x1cfb0
movq -0x10(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x1c(%rax)
jne 0x1c322
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x33d0
movq -0x60(%rbp), %rdx
leaq 0x3fad(%rip), %rsi      # 0x2024b
leaq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0x1c2a9
leaq -0x38(%rbp), %rdi
callq 0x174b0
movb %al, -0x61(%rbp)
jmp 0x1c2b7
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
movb -0x61(%rbp), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x59, %eax
jne 0x1c320
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c340
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
jmp 0x1c320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1c315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
jmp 0x1c337
jmp 0x1c322
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d050
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x33c0
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1cf70
movq -0x70(%rbp), %rdi
leaq 0xc279(%rip), %rax      # 0x28c80
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0x3901(%rip), %rsi      # 0x20316
callq 0x32e0
jmp 0x1ca1c
movl $0x68, %edi
callq 0x3220
movq %rax, -0x78(%rbp)
jmp 0x1ca2c
movq -0x78(%rbp), %rdi
callq 0x1ce30
jmp 0x1ca37
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x33d0
movq -0x80(%rbp), %rdx
leaq 0x38b7(%rip), %rsi      # 0x2031d
leaq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0x1ca71
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x159a0
jmp 0x1ca83
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x98(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x33d0
movq -0x90(%rbp), %rdx
leaq 0x3868(%rip), %rsi      # 0x2032a
leaq -0x60(%rbp), %rdi
callq 0x32f0
jmp 0x1cacd
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x159a0
jmp 0x1cadf
leaq -0x60(%rbp), %rdi
callq 0x3448
leaq -0x61(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq 0xd8a0(%rip), %rsi      # 0x2a3a0
callq 0x13720
jmp 0x1cb07
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1cb8f
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31f0
jmp 0x1cb8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1cb58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
jmp 0x1cb8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1cb86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3448
leaq -0x61(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rdi
callq 0x1cfb0
movq -0x10(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
movb $0x1, %al
cmpl $0x1, -0x8(%rbp)
movb %al, -0x121(%rbp)
je 0x1cc68
cmpl $0x2, -0x8(%rbp)
sete %al
movb %al, -0x121(%rbp)
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0x1cc77
jmp 0x1cd3c
leaq -0x110(%rbp), %rdi
callq 0x190f0
testb $0x1, -0x9(%rbp)
je 0x1cce1
leaq -0x110(%rbp), %rdi
callq 0x1bad0
movl %eax, -0x128(%rbp)
jmp 0x1cc9d
movl -0x128(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jne 0x1ccdf
movl $0x0, -0x4(%rbp)
movl $0x1, -0x120(%rbp)
jmp 0x1cd1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x195c0
jmp 0x1cd4f
jmp 0x1cce1
movl -0x8(%rbp), %esi
leaq -0x110(%rbp), %rdi
callq 0x19700
jmp 0x1ccf2
movb $0x0, -0x9(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x1bad0
movl %eax, -0x12c(%rbp)
jmp 0x1cd0a
movl -0x12c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x120(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x195c0
movl -0x120(%rbp), %eax
testl %eax, %eax
je 0x1cd37
jmp 0x1cd35
jmp 0x1cd43
jmp 0x1cc4d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0x33c0
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1cf50
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movb $0x0, 0x28(%rax)
movl $0x1, 0x24(%rax)
movl $0x0, 0x20(%rax)
movl $0x0, 0x2c(%rax)
movb $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xcee1(%rip), %rdi      # 0x2abe0
callq 0x13610
movq %rax, -0x28(%rbp)
leaq 0xced1(%rip), %rdi      # 0x2abe0
callq 0x13640
movq -0x40(%rbp), %rdx
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x135c0
movq %rax, -0x20(%rbp)
leaq 0xceac(%rip), %rdi      # 0x2abe0
callq 0x13640
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13580
testb $0x1, %al
jne 0x1dd50
jmp 0x1dd5d
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movb $0x0, 0x3b(%rsp)
movl 0x3c(%rsp), %eax
movq %rax, 0x18(%rsp)
leaq 0x3a(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4dc0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4dd0
jmp 0x23cd
leaq 0x3a(%rsp), %rdi
callq 0x4e50
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x245b
callq 0x2060
movq 0x10(%rsp), %rdi
vcvtsi2sd %eax, %xmm0, %xmm1
vmovsd 0xec19(%rip), %xmm0     # 0x11018
vmulsd %xmm1, %xmm0, %xmm0
vmovsd 0xec05(%rip), %xmm1     # 0x11010
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0xebf1(%rip), %xmm1     # 0x11008
vsubsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, (%rsp)
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x4e60
vmovsd (%rsp), %xmm0
vmovsd %xmm0, (%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x23df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3a(%rsp), %rdi
callq 0x4e50
jmp 0x247b
movb $0x1, 0x3b(%rsp)
testb $0x1, 0x3b(%rsp)
jne 0x2471
movq 0x10(%rsp), %rdi
callq 0x4e80
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movb $0x0, 0x4b(%rsp)
movl 0x4c(%rsp), %eax
movq %rax, 0x28(%rsp)
leaq 0x4a(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4dc0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x4dd0
jmp 0x24dd
leaq 0x4a(%rsp), %rdi
callq 0x4e50
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4e60
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, (%rax)
movl $0x1, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jae 0x25af
callq 0x2060
movq 0x20(%rsp), %rdi
vcvtsi2sd %eax, %xmm0, %xmm1
vmovsd 0xeaef(%rip), %xmm0     # 0x11018
vmulsd %xmm1, %xmm0, %xmm0
vmovsd 0xeadb(%rip), %xmm1     # 0x11010
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0xeac7(%rip), %xmm1     # 0x11008
vsubsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
movl 0x38(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4e60
vmovsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rdi
vaddsd (%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
movl 0x38(%rsp), %eax
movl %eax, %esi
callq 0x4e60
vmovsd 0x10(%rsp), %xmm0
vmovsd %xmm0, (%rax)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x2505
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4a(%rsp), %rdi
callq 0x4e50
jmp 0x25cf
movb $0x1, 0x4b(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0x25c5
movq 0x20(%rsp), %rdi
callq 0x4e80
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2210
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq 0x139db(%rip), %rdi     # 0x15fd8
leaq 0x4c(%rsp), %rsi
callq 0x2030
movq 0x28(%rsp), %rdi
movb $0x0, 0x4b(%rsp)
callq 0x4ee0
movq 0x139bb(%rip), %rdi     # 0x15fd8
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2170
movb %al, 0x1f(%rsp)
jmp 0x2632
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x263c
jmp 0x268f
movq 0x28(%rsp), %rdi
vmovss 0x4c(%rsp), %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x4ef0
jmp 0x265d
movq 0x13974(%rip), %rdi     # 0x15fd8
leaq 0x4c(%rsp), %rsi
callq 0x2030
jmp 0x2670
jmp 0x2616
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x4e80
jmp 0x2710
movq 0x13932(%rip), %rdi     # 0x15fc8
leaq 0xe99b(%rip), %rsi      # 0x11038
callq 0x2110
movq %rax, 0x10(%rsp)
jmp 0x26a9
movq 0x28(%rsp), %rdi
callq 0x4f20
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, 0x8(%rsp)
jmp 0x26c7
movq 0x8(%rsp), %rdi
leaq 0xe96d(%rip), %rsi      # 0x11040
callq 0x2110
movq %rax, (%rsp)
jmp 0x26de
movq (%rsp), %rdi
movq 0x138cf(%rip), %rsi     # 0x15fb8
callq 0x2130
jmp 0x26f0
movb $0x1, 0x4b(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0x2706
movq 0x28(%rsp), %rdi
callq 0x4e80
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2210
nopw (%rax,%rax)
// File: lemire[P]runningmaxmin/runningmaxmin.cpp
// Function: process(std::vector<double, std::allocator<double>>&, unsigned int, unsigned int, bool)
void process(std::vector<floattype> & data, uint width = 30, uint times = 1,
             bool doslow = true) {
    std::vector<double> timings;
    for (uint i = 0; i < times; ++i) {
        compareallalgos(data, timings, width, doslow);
    }
    std::cout << "#\tslow\t\tvanHerk\t\tlemire\tsimplelemire\t\tgilkimmel"
              << std::endl;
    std::cout << "\t" << timings[0] << "\t" << timings[1] << "\t" << timings[2]
              << "\t" << timings[5] << "\t\t" << timings[3] << std::endl;
}

// Assembly:
subq $0xa8, %rsp
movb %cl, %al
movq %rdi, 0xa0(%rsp)
movl %esi, 0x9c(%rsp)
movl %edx, 0x98(%rsp)
andb $0x1, %al
movb %al, 0x97(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4ee0
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
cmpl 0x98(%rsp), %eax
jae 0x2df9
movq 0xa0(%rsp), %rdi
movl 0x9c(%rsp), %edx
movzbl 0x97(%rsp), %ecx
andl $0x1, %ecx
leaq 0x78(%rsp), %rsi
callq 0x2720
jmp 0x2dcd
jmp 0x2dcf
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x2d9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4e80
jmp 0x2f78
movq 0x131c8(%rip), %rdi     # 0x15fc8
leaq 0xe248(%rip), %rsi      # 0x1104f
callq 0x2110
movq %rax, 0x58(%rsp)
jmp 0x2e13
movq 0x58(%rsp), %rdi
movq 0x13199(%rip), %rsi     # 0x15fb8
callq 0x2130
jmp 0x2e26
movq 0x1319b(%rip), %rdi     # 0x15fc8
leaq 0xe24c(%rip), %rsi      # 0x11080
callq 0x2110
movq %rax, 0x50(%rsp)
jmp 0x2e40
xorl %eax, %eax
movl %eax, %esi
leaq 0x78(%rsp), %rdi
callq 0x4e60
movq 0x50(%rsp), %rdi
vmovsd (%rax), %xmm0
callq 0x2230
movq %rax, 0x48(%rsp)
jmp 0x2e63
movq 0x48(%rsp), %rdi
leaq 0xe211(%rip), %rsi      # 0x11080
callq 0x2110
movq %rax, 0x40(%rsp)
jmp 0x2e7b
leaq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0x4e60
movq 0x40(%rsp), %rdi
vmovsd (%rax), %xmm0
callq 0x2230
movq %rax, 0x38(%rsp)
jmp 0x2e9f
movq 0x38(%rsp), %rdi
leaq 0xe1d5(%rip), %rsi      # 0x11080
callq 0x2110
movq %rax, 0x30(%rsp)
jmp 0x2eb7
leaq 0x78(%rsp), %rdi
movl $0x2, %esi
callq 0x4e60
movq 0x30(%rsp), %rdi
vmovsd (%rax), %xmm0
callq 0x2230
movq %rax, 0x28(%rsp)
jmp 0x2edb
movq 0x28(%rsp), %rdi
leaq 0xe199(%rip), %rsi      # 0x11080
callq 0x2110
movq %rax, 0x20(%rsp)
jmp 0x2ef3
leaq 0x78(%rsp), %rdi
movl $0x5, %esi
callq 0x4e60
movq 0x20(%rsp), %rdi
vmovsd (%rax), %xmm0
callq 0x2230
movq %rax, 0x18(%rsp)
jmp 0x2f17
movq 0x18(%rsp), %rdi
leaq 0xe15c(%rip), %rsi      # 0x1107f
callq 0x2110
movq %rax, 0x10(%rsp)
jmp 0x2f2f
leaq 0x78(%rsp), %rdi
movl $0x3, %esi
callq 0x4e60
movq 0x10(%rsp), %rdi
vmovsd (%rax), %xmm0
callq 0x2230
movq %rax, 0x8(%rsp)
jmp 0x2f53
movq 0x8(%rsp), %rdi
movq 0x13059(%rip), %rsi     # 0x15fb8
callq 0x2130
jmp 0x2f66
leaq 0x78(%rsp), %rdi
callq 0x4e80
addq $0xa8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: 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 0x18c81(%rip), %rax     # 0x1b228
shlq $0x10, %rax
xorq 0x18c76(%rip), %rax     # 0x1b228
movq %rax, 0x18c6f(%rip)     # 0x1b228
movq 0x18c68(%rip), %rax     # 0x1b228
shrq $0x5, %rax
xorq 0x18c5d(%rip), %rax     # 0x1b228
movq %rax, 0x18c56(%rip)     # 0x1b228
movq 0x18c4f(%rip), %rax     # 0x1b228
shlq %rax
xorq 0x18c45(%rip), %rax     # 0x1b228
movq %rax, 0x18c3e(%rip)     # 0x1b228
movq 0x18c37(%rip), %rax     # 0x1b228
movq %rax, -0x8(%rsp)
movq 0x18c33(%rip), %rax     # 0x1b230
movq %rax, 0x18c24(%rip)     # 0x1b228
movq 0x18c2d(%rip), %rax     # 0x1b238
movq %rax, 0x18c1e(%rip)     # 0x1b230
movq -0x8(%rsp), %rax
xorq 0x18c0a(%rip), %rax     # 0x1b228
xorq 0x18c0b(%rip), %rax     # 0x1b230
movq %rax, 0x18c0c(%rip)     # 0x1b238
movq 0x18c05(%rip), %rax     # 0x1b238
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
vmovsd %xmm0, 0x20(%rsp)
vmovsd %xmm1, 0x18(%rsp)
movq 0x28(%rsp), %rax
subq 0x30(%rsp), %rax
vcvtsi2sd %rax, %xmm0, %xmm0
vmovsd 0x18(%rsp), %xmm1
vsubsd 0x20(%rsp), %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
vcvtsi2sdq 0x28(%rsp), %xmm0, %xmm2
vmovsd 0x18(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm0
vmovq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm1
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovsd %xmm0, 0x8(%rsp)
vmovsd 0x10(%rsp), %xmm0
vmovsd %xmm0, (%rsp)
callq 0x63f0
vmovaps %xmm0, %xmm1
vmovsd (%rsp), %xmm0
vmovq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm1
vucomisd %xmm1, %xmm0
jne 0x29e7
jp 0x29e7
callq 0x63f0
vmovsd %xmm0, 0x10(%rsp)
vmovsd 0x10(%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
leaq 0x38(%rsp), %rdi
callq 0x63b0
vmovsd 0x38(%rsp), %xmm0
vmovsd 0x40(%rsp), %xmm1
addq $0x48, %rsp
retq
nop
// File: 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 $0xc8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x6400
movq %rax, 0x40(%rsp)
testq %rax, %rax
sets %al
movzbl %al, %eax
movl %eax, %ecx
fildll 0x40(%rsp)
leaq 0x125c9(%rip), %rax     # 0x15010
flds (%rax,%rcx,4)
faddp %st, %st(1)
fstpt 0xa0(%rsp)
fldz
fld %st(0)
fstpt 0x90(%rsp)
fld %st(0)
fstpt 0x80(%rsp)
fld %st(0)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movslq 0x5c(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x6400
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x2b75
movq 0xb0(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0x6390
fldl (%rax)
fldt 0x90(%rsp)
faddp %st, %st(1)
fstpt 0x90(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x30(%rsp)
fildl 0x30(%rsp)
fldt 0x80(%rsp)
faddp %st, %st(1)
fstpt 0x80(%rsp)
movq 0xb0(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0x6390
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0xb0(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0x6390
vmovsd 0x8(%rsp), %xmm0
vmovsd (%rax), %xmm1
vmulsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
fldl 0x28(%rsp)
fldt 0x70(%rsp)
faddp %st, %st(1)
fstpt 0x70(%rsp)
movslq 0x5c(%rsp), %rsi
movl %esi, %eax
movl %eax, 0x34(%rsp)
fildl 0x34(%rsp)
fstpt 0x14(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x6390
fldt 0x14(%rsp)
fldl (%rax)
fldt 0x60(%rsp)
fxch %st(2)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpt 0x60(%rsp)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x2a79
fldt 0xa0(%rsp)
fldt 0x60(%rsp)
fldt 0x90(%rsp)
fldt 0x80(%rsp)
fmul %st(1), %st
fxch %st(2)
fmul %st(3), %st
fsubp %st, %st(2)
fldt 0x70(%rsp)
fxch %st(1)
fmul %st, %st(0)
fxch %st(3)
fmulp %st, %st(1)
fsubp %st, %st(2)
fdivp %st, %st(1)
fstpl 0x50(%rsp)
fldt 0x80(%rsp)
fldl 0x50(%rsp)
fldt 0x90(%rsp)
fmulp %st, %st(1)
fsubrp %st, %st(1)
fldt 0xa0(%rsp)
fdivrp %st, %st(1)
fstpl 0x38(%rsp)
vmovsd 0x38(%rsp), %xmm0
vmovsd %xmm0, 0x48(%rsp)
vmovsd 0x50(%rsp), %xmm0
vpxor %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jb 0x2beb
jmp 0x2c0a
leaq 0x12486(%rip), %rdi     # 0x15078
leaq 0x12486(%rip), %rsi     # 0x1507f
movl $0x19, %edx
leaq 0x12498(%rip), %rcx     # 0x1509d
callq 0x2130
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x48(%rsp), %xmm1
leaq 0xb8(%rsp), %rdi
callq 0x63b0
vmovsd 0xb8(%rsp), %xmm0
vmovsd 0xc0(%rsp), %xmm1
addq $0xc8, %rsp
retq
nopl (%rax)
// File: umatin[P]LogarithmicErrorRegression/./src/competitor_regression.h
// Function: simple_linear_regression(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
linear_regression simple_linear_regression(std::vector<double>& datax, std::vector<double>& datay){
    long double count = datax.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 < datax.size(); i++){
        x_sum += datax[i];
        y_sum += datay[i];
        xx_sum += datax[i] * datax[i];
        xy_sum += datay[i] * datax[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;
    return linear_regression(a,b);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x6400
movq %rax, 0x30(%rsp)
testq %rax, %rax
sets %al
movzbl %al, %eax
movl %eax, %ecx
fildll 0x30(%rsp)
leaq 0x12131(%rip), %rax     # 0x15010
flds (%rax,%rcx,4)
faddp %st, %st(1)
fstpt 0x90(%rsp)
fldz
fld %st(0)
fstpt 0x80(%rsp)
fld %st(0)
fstpt 0x70(%rsp)
fld %st(0)
fstpt 0x60(%rsp)
fstpt 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x6400
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x3028
movq 0xb0(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x6390
fldl (%rax)
fldt 0x80(%rsp)
faddp %st, %st(1)
fstpt 0x80(%rsp)
movq 0xa8(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x6390
fldl (%rax)
fldt 0x70(%rsp)
faddp %st, %st(1)
fstpt 0x70(%rsp)
movq 0xb0(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x6390
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0xb0(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x6390
vmovsd 0x8(%rsp), %xmm0
vmovsd (%rax), %xmm1
vmulsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
fldl 0x28(%rsp)
fldt 0x60(%rsp)
faddp %st, %st(1)
fstpt 0x60(%rsp)
movq 0xa8(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x6390
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x10(%rsp)
movq 0xb0(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x6390
vmovsd 0x10(%rsp), %xmm0
vmovsd (%rax), %xmm1
vmulsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
fldl 0x20(%rsp)
fldt 0x50(%rsp)
faddp %st, %st(1)
fstpt 0x50(%rsp)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x2f0e
fldt 0x90(%rsp)
fldt 0x50(%rsp)
fldt 0x80(%rsp)
fldt 0x70(%rsp)
fmul %st(1), %st
fxch %st(2)
fmul %st(3), %st
fsubp %st, %st(2)
fldt 0x60(%rsp)
fxch %st(1)
fmul %st, %st(0)
fxch %st(3)
fmulp %st, %st(1)
fsubp %st, %st(2)
fdivp %st, %st(1)
fstpl 0x40(%rsp)
fldt 0x70(%rsp)
fldl 0x40(%rsp)
fldt 0x80(%rsp)
fmulp %st, %st(1)
fsubrp %st, %st(1)
fldt 0x90(%rsp)
fdivrp %st, %st(1)
fstpl 0x38(%rsp)
vmovsd 0x40(%rsp), %xmm0
vmovsd 0x38(%rsp), %xmm1
leaq 0xb8(%rsp), %rdi
callq 0x63b0
vmovsd 0xb8(%rsp), %xmm0
vmovsd 0xc0(%rsp), %xmm1
addq $0xc8, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
fldz
fld %st(0)
fstpt 0x40(%rsp)
fstpt 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x6400
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x315b
movq 0x58(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x6390
fldl (%rax)
fldt 0x40(%rsp)
faddp %st, %st(1)
fstpt 0x40(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x6390
movq 0x20(%rsp), %rdi
fldl (%rax)
fstpt 0xc(%rsp)
movslq 0x2c(%rsp), %rsi
callq 0x6390
fldt 0xc(%rsp)
fldl (%rax)
fldt 0x30(%rsp)
fxch %st(2)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpt 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x30d7
fldt 0x30(%rsp)
fldt 0x40(%rsp)
fdivrp %st, %st(1)
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
fldz
fld %st(0)
fstpt 0x20(%rsp)
fstpt 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x6400
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x31ff
movq 0x30(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x6390
fldl (%rax)
fldt 0x20(%rsp)
faddp %st, %st(1)
fstpt 0x20(%rsp)
movq 0x30(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x6390
fldl (%rax)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
fildl 0x8(%rsp)
fldt 0x10(%rsp)
fxch %st(2)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpt 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x318d
fldt 0x10(%rsp)
fldt 0x20(%rsp)
fdivrp %st, %st(1)
addq $0x38, %rsp
retq
nop