LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chiku[P]cmatrix/src/impl/matrix/properties.cpp
// Function: cmatrix::Matrix<double>::isUnit() const
bool Matrix<Type>::isUnit() const
{
    if (!isSquare()) {
        return false;
    }

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            if (( i != j && access(i, j) != 0) || (i == j && access(i, j) != 1)) {
                return false;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x20b20
testb $0x1, %al
jne 0x208b6
movb $0x0, -0x1(%rbp)
jmp 0x20978
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jge 0x20974
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jge 0x20964
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x20926
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x122e0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x20951
jp 0x20951
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x20957
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x122e0
movsd 0x446d1(%rip), %xmm1    # 0x65018
ucomisd %xmm1, %xmm0
jne 0x20951
jp 0x20951
jmp 0x20957
movb $0x0, -0x1(%rbp)
jmp 0x20978
jmp 0x20959
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x208e5
jmp 0x20966
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x208bd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::IncompatibleMultiplication[abi:cxx11](cmatrix::Size, cmatrix::Size)
static std::basic_string<char> IncompatibleMultiplication(Size first, Size second)
        {
            std::stringstream message;
            message << "Cannot multiply [" << first.getRows() << ", " << first.getColumns() << "] "
                    <<  "with [" << second.getRows() << ", " << second.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62a0
leaq -0x1a0(%rbp), %rdi
leaq 0x44e94(%rip), %rsi     # 0x66b7e
callq 0x6410
movq %rax, -0x1c8(%rbp)
jmp 0x21cf8
leaq -0x18(%rbp), %rdi
callq 0x10990
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x1e0(%rbp)
jmp 0x21d19
movq -0x1e0(%rbp), %rdi
leaq 0x47f10(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x1e8(%rbp)
jmp 0x21d35
leaq -0x18(%rbp), %rdi
callq 0x10b80
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x1f0(%rbp)
jmp 0x21d56
movq -0x1f0(%rbp), %rdi
leaq 0x488bf(%rip), %rsi     # 0x6a623
callq 0x6410
movq %rax, -0x1f8(%rbp)
jmp 0x21d72
movq -0x1f8(%rbp), %rdi
leaq 0x44e10(%rip), %rsi     # 0x66b90
callq 0x6410
movq %rax, -0x200(%rbp)
jmp 0x21d8e
leaq -0x28(%rbp), %rdi
callq 0x10990
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x208(%rbp)
jmp 0x21daf
movq -0x208(%rbp), %rdi
leaq 0x47e7a(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x210(%rbp)
jmp 0x21dcb
leaq -0x28(%rbp), %rdi
callq 0x10b80
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x218(%rbp)
jmp 0x21dec
movq -0x218(%rbp), %rdi
leaq 0x45d65(%rip), %rsi     # 0x67b5f
callq 0x6410
jmp 0x21e01
movq -0x1d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x63f0
jmp 0x21e16
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1d0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1b8(%rbp), %rdi
callq 0x67c0
nopl (%rax)
// File: chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::BadSizeOnMutate[abi:cxx11](cmatrix::Size, long, long)
static std::basic_string<char> BadSizeOnMutate(Size bounds, long int rows, long int columns)
        {
            std::stringstream message;
            message << "Invalid attempt to add element at negative row (" << rows << ") or column (" << columns
                    << ") to matrix [" << bounds.getRows() << ", " << bounds.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62a0
leaq -0x1a0(%rbp), %rdi
leaq 0x3f6e7(%rip), %rsi     # 0x67021
callq 0x6410
movq %rax, -0x1c8(%rbp)
jmp 0x27948
movq -0x1c8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6810
movq %rax, -0x1e0(%rbp)
jmp 0x27961
movq -0x1e0(%rbp), %rdi
leaq 0x3f6e3(%rip), %rsi     # 0x67052
callq 0x6410
movq %rax, -0x1e8(%rbp)
jmp 0x2797d
movq -0x1e8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6810
movq %rax, -0x1f0(%rbp)
jmp 0x27996
movq -0x1f0(%rbp), %rdi
leaq 0x3f6bc(%rip), %rsi     # 0x67060
callq 0x6410
movq %rax, -0x1f8(%rbp)
jmp 0x279b2
leaq -0x18(%rbp), %rdi
callq 0x10990
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x200(%rbp)
jmp 0x279d3
movq -0x200(%rbp), %rdi
leaq 0x42256(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x208(%rbp)
jmp 0x279ef
leaq -0x18(%rbp), %rdi
callq 0x10b80
movq -0x208(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x210(%rbp)
jmp 0x27a10
movq -0x210(%rbp), %rdi
leaq 0x40141(%rip), %rsi     # 0x67b5f
callq 0x6410
jmp 0x27a25
movq -0x1d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x63f0
jmp 0x27a3a
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1d0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1b8(%rbp), %rdi
callq 0x67c0
// File: chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double>::operator+=(cmatrix::Matrix<double>)
Matrix<Type>& Matrix<Type>::operator += (const Matrix<Type> secondMatrix)
{
    if (size != secondMatrix.size) {
        throw Exception::IncompatibleAddition(ExceptionBody::IncompatibleAddition(size, secondMatrix.size));
    }

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            access(i, j) = access(i, j) + secondMatrix.access(i, j);
        }
    }

    return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x12600
testb $0x1, %al
jne 0x2f81d
jmp 0x2f8cb
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x61c0
movq -0x70(%rbp), %rcx
movq %rax, %rdx
movq -0x78(%rbp), %rax
movq %rdx, -0x80(%rbp)
movups (%rcx), %xmm0
movaps %xmm0, -0x40(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r8
leaq -0x30(%rbp), %rdi
callq 0x2fa10
jmp 0x2f863
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fbd0
jmp 0x2f872
movq -0x80(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq 0x56fff(%rip), %rsi     # 0x86880
leaq 0x388(%rip), %rdx       # 0x2fc10
callq 0x6760
jmp 0x2f9b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2f8b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6230
testb $0x1, -0x5d(%rbp)
jne 0x2f8bd
jmp 0x2f8c6
movq -0x80(%rbp), %rdi
callq 0x62c0
jmp 0x2f9b0
movl $0x0, -0x64(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x64(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jge 0x2f9a3
movl $0x0, -0x68(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jge 0x2f993
movq -0x70(%rbp), %rdi
movslq -0x64(%rbp), %rsi
movslq -0x68(%rbp), %rdx
callq 0x10e80
movq -0x78(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movslq -0x64(%rbp), %rsi
movslq -0x68(%rbp), %rdx
callq 0x122e0
movq -0x70(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0xa0(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x98(%rbp)
movslq -0x64(%rbp), %rsi
movslq -0x68(%rbp), %rdx
callq 0x10e80
movsd -0x98(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x2f900
jmp 0x2f995
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x2f8d2
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x67c0
nopl (%rax)
// File: chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::IncompatibleAddition[abi:cxx11](cmatrix::Size, cmatrix::Size)
static std::basic_string<char> IncompatibleAddition(Size first, Size second)
        {
            std::stringstream message;
            message << "Cannot add [" << first.getRows() << ", " << first.getColumns() << "] "
                    <<  "and [" << second.getRows() << ", " << second.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62a0
leaq -0x1a0(%rbp), %rdi
leaq 0x37b7c(%rip), %rsi     # 0x675d6
callq 0x6410
movq %rax, -0x1c8(%rbp)
jmp 0x2fa68
leaq -0x18(%rbp), %rdi
callq 0x10990
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x1e0(%rbp)
jmp 0x2fa89
movq -0x1e0(%rbp), %rdi
leaq 0x3a1a0(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x1e8(%rbp)
jmp 0x2faa5
leaq -0x18(%rbp), %rdi
callq 0x10b80
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x1f0(%rbp)
jmp 0x2fac6
movq -0x1f0(%rbp), %rdi
leaq 0x3ab4f(%rip), %rsi     # 0x6a623
callq 0x6410
movq %rax, -0x1f8(%rbp)
jmp 0x2fae2
movq -0x1f8(%rbp), %rdi
leaq 0x37af3(%rip), %rsi     # 0x675e3
callq 0x6410
movq %rax, -0x200(%rbp)
jmp 0x2fafe
leaq -0x28(%rbp), %rdi
callq 0x10990
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x208(%rbp)
jmp 0x2fb1f
movq -0x208(%rbp), %rdi
leaq 0x3a10a(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x210(%rbp)
jmp 0x2fb3b
leaq -0x28(%rbp), %rdi
callq 0x10b80
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x218(%rbp)
jmp 0x2fb5c
movq -0x218(%rbp), %rdi
leaq 0x37ff5(%rip), %rsi     # 0x67b5f
callq 0x6410
jmp 0x2fb71
movq -0x1d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x63f0
jmp 0x2fb86
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1d0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1b8(%rbp), %rdi
callq 0x67c0
nopl (%rax)
// File: chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double>::operator-=(cmatrix::Matrix<double>)
Matrix<Type>& Matrix<Type>::operator -= (const Matrix<Type> secondMatrix)
{
    if (size != secondMatrix.size) {
        throw Exception::IncompatibleSubtraction(ExceptionBody::IncompatibleSubtraction(size, secondMatrix.size));
    }

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            access(i, j) = access(i, j) - secondMatrix.access(i, j);
        }
    }

    return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x12600
testb $0x1, %al
jne 0x2ff2d
jmp 0x2ffdb
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x61c0
movq -0x70(%rbp), %rcx
movq %rax, %rdx
movq -0x78(%rbp), %rax
movq %rdx, -0x80(%rbp)
movups (%rcx), %xmm0
movaps %xmm0, -0x40(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %r8
leaq -0x30(%rbp), %rdi
callq 0x30220
jmp 0x2ff73
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x303e0
jmp 0x2ff82
movq -0x80(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq 0x5692f(%rip), %rsi     # 0x868c0
leaq 0x488(%rip), %rdx       # 0x30420
callq 0x6760
jmp 0x300c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2ffc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6230
testb $0x1, -0x5d(%rbp)
jne 0x2ffcd
jmp 0x2ffd6
movq -0x80(%rbp), %rdi
callq 0x62c0
jmp 0x300c0
movl $0x0, -0x64(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x64(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jge 0x300b3
movl $0x0, -0x68(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jge 0x300a3
movq -0x70(%rbp), %rdi
movslq -0x64(%rbp), %rsi
movslq -0x68(%rbp), %rdx
callq 0x10e80
movq -0x78(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movslq -0x64(%rbp), %rsi
movslq -0x68(%rbp), %rdx
callq 0x122e0
movq -0x70(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0xa0(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x98(%rbp)
movslq -0x64(%rbp), %rsi
movslq -0x68(%rbp), %rdx
callq 0x10e80
movsd -0x98(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x30010
jmp 0x300a5
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x2ffe2
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x67c0
nopl (%rax)
// File: chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double>::operator-()
Matrix<Type> Matrix<Type>::operator - ()
{
    Matrix<Type> result(rows(), columns());

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            result.access(i, j) = -access(i, j);
        }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x10160
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x10330
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x100e0
movl $0x0, -0x18(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jge 0x301ed
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jge 0x301dd
movq -0x48(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x10e80
movq %rax, -0x68(%rbp)
jmp 0x3017f
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rax
movsd (%rax), %xmm0
movaps 0x36efe(%rip), %xmm1    # 0x67090
pxor %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
movslq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x10e80
movq %rax, -0x70(%rbp)
jmp 0x301ae
movq -0x70(%rbp), %rax
movsd -0x78(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3014b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x105f0
jmp 0x3020d
jmp 0x301df
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x30123
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x30200
movq -0x40(%rbp), %rdi
callq 0x105f0
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x67c0
nopw %cs:(%rax,%rax)
// File: chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::IncompatibleSubtraction[abi:cxx11](cmatrix::Size, cmatrix::Size)
static std::basic_string<char> IncompatibleSubtraction(Size first, Size second)
        {
            std::stringstream message;
            message << "Cannot subtract [" << second.getRows() << ", " << second.getColumns() << "] "
                    <<  "from [" << first.getRows() << ", " << first.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62a0
leaq -0x1a0(%rbp), %rdi
leaq 0x3771a(%rip), %rsi     # 0x67984
callq 0x6410
movq %rax, -0x1c8(%rbp)
jmp 0x30278
leaq -0x28(%rbp), %rdi
callq 0x10990
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x1e0(%rbp)
jmp 0x30299
movq -0x1e0(%rbp), %rdi
leaq 0x39990(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x1e8(%rbp)
jmp 0x302b5
leaq -0x28(%rbp), %rdi
callq 0x10b80
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x1f0(%rbp)
jmp 0x302d6
movq -0x1f0(%rbp), %rdi
leaq 0x3a33f(%rip), %rsi     # 0x6a623
callq 0x6410
movq %rax, -0x1f8(%rbp)
jmp 0x302f2
movq -0x1f8(%rbp), %rdi
leaq 0x35770(%rip), %rsi     # 0x65a70
callq 0x6410
movq %rax, -0x200(%rbp)
jmp 0x3030e
leaq -0x18(%rbp), %rdi
callq 0x10990
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x208(%rbp)
jmp 0x3032f
movq -0x208(%rbp), %rdi
leaq 0x398fa(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x210(%rbp)
jmp 0x3034b
leaq -0x18(%rbp), %rdi
callq 0x10b80
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x218(%rbp)
jmp 0x3036c
movq -0x218(%rbp), %rdi
leaq 0x377e5(%rip), %rsi     # 0x67b5f
callq 0x6410
jmp 0x30381
movq -0x1d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x63f0
jmp 0x30396
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1d0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1b8(%rbp), %rdi
callq 0x67c0
nopl (%rax)
// File: chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double>::scale(double)
Matrix<Type> Matrix<Type>::scale(Type value)
{
    Matrix<Type> result(rows(), columns());

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            result.access(i, j) = value * access(i, j);
        }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x10160
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x10330
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x100e0
movl $0x0, -0x20(%rbp)
movq -0x50(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jge 0x305a7
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jge 0x30597
movq -0x50(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movslq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x10e80
movq %rax, -0x70(%rbp)
jmp 0x30532
movq -0x48(%rbp), %rdi
movsd -0x78(%rbp), %xmm0
movq -0x70(%rbp), %rax
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
movslq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x10e80
movq %rax, -0x80(%rbp)
jmp 0x30562
movq -0x80(%rbp), %rax
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x304f0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x105f0
jmp 0x305c7
jmp 0x30599
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x304c8
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x305ba
movq -0x48(%rbp), %rdi
callq 0x105f0
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x67c0
// File: chiku[P]cmatrix/src/impl/matrix/properties.cpp
// Function: cmatrix::Matrix<double>::isZero() const
bool Matrix<Type>::isZero() const
{
    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            if (access(i, j) != 0) {
                return false;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jge 0x3529a
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jge 0x3528d
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x122e0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3527a
jp 0x3527a
jmp 0x35280
movb $0x0, -0x1(%rbp)
jmp 0x3529e
jmp 0x35282
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3523f
jmp 0x3528f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3521b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH07_Classes/examples/useDebug.cc
// Function: main
int main()
{
	constexpr Debug io_sub(false, true, false);  // debugging IO    
	if (io_sub.any())  // equivalent to if(true)
		cerr << "print appropriate error messages" << endl;

	constexpr Debug prod(false); // no debugging during production
	if (prod.any())    // equivalent to if(false)
		cerr << "print an error message" << endl;

	IO_Subsystem ioErrs;        // by default, don't print any debugging
	// no debugging here
	if (ioErrs.default_debug()) // if (false || debug.any())
		cerr << "print message 3" << endl;
	ioErrs.set_debug(true);     // turn on debugging
	if (ioErrs.default_debug()) // if (false || debug.any())
		cerr << "print message 4" << endl;
	ioErrs.set_debug(false);    // okay, debugging section complete

	HW_Subsystem hw;
	hw.set_debug(true);
	if (ioErrs.default_debug() || hw.default_debug()) // if (false || debug.any())
		cerr << "print message 5" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movw 0xe34(%rip), %ax        # 0x200a
movw %ax, -0x7(%rbp)
movb 0xe2c(%rip), %al        # 0x200c
movb %al, -0x5(%rbp)
movq 0x2e06(%rip), %rdi      # 0x3ff0
leaq 0xe1c(%rip), %rsi       # 0x200d
callq 0x1050
movq %rax, %rdi
movq 0x2dc8(%rip), %rsi      # 0x3fc8
callq 0x1060
leaq -0xa(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x1030
leaq -0xd(%rbp), %rdi
callq 0x1300
leaq -0xd(%rbp), %rdi
callq 0x1320
testb $0x1, %al
jne 0x122d
jmp 0x124f
movq 0x2dbc(%rip), %rdi      # 0x3ff0
leaq 0xdf3(%rip), %rsi       # 0x202e
callq 0x1050
movq %rax, %rdi
movq 0x2d7e(%rip), %rsi      # 0x3fc8
callq 0x1060
leaq -0xd(%rbp), %rdi
movl $0x1, %esi
callq 0x1340
leaq -0xd(%rbp), %rdi
callq 0x1320
testb $0x1, %al
jne 0x126c
jmp 0x128e
movq 0x2d7d(%rip), %rdi      # 0x3ff0
leaq 0xdc4(%rip), %rsi       # 0x203e
callq 0x1050
movq %rax, %rdi
movq 0x2d3f(%rip), %rsi      # 0x3fc8
callq 0x1060
leaq -0xd(%rbp), %rdi
xorl %esi, %esi
callq 0x1340
leaq -0x10(%rbp), %rdi
callq 0x1370
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1390
leaq -0xd(%rbp), %rdi
callq 0x1320
testb $0x1, %al
jne 0x12cc
leaq -0x10(%rbp), %rdi
callq 0x13c0
testb $0x1, %al
jne 0x12cc
jmp 0x12ee
movq 0x2d1d(%rip), %rdi      # 0x3ff0
leaq 0xd74(%rip), %rsi       # 0x204e
callq 0x1050
movq %rax, %rdi
movq 0x2cdf(%rip), %rsi      # 0x3fc8
callq 0x1060
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/Backpack.cpp
// Function: Backpack::printContents()
void Backpack::printContents()
{
    std::cout << NARRATOR_COLOR;
    if (contents.empty())
    {
        std::cout << "\nYour pack is empty." << RESET << std::endl;
    }
    else
    {
        //cast from unsigned int to avoid compiler warnings
        int size = static_cast<int>(contents.size());

        std::cout << "\nYour pack contains: \n" << ITEM_COLOR;
        for (int i = 0; i < size; i++)
        {
            std::cout << contents[i] << "\n";
        }
        std::cout << 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 0x163fd(%rip), %rdi     # 0x28fc8
leaq 0xc4e6(%rip), %rsi      # 0x1f0b8
callq 0x3210
movq -0x18(%rbp), %rdi
callq 0x13450
testb $0x1, %al
jne 0x12be6
jmp 0x12c1c
movq 0x163db(%rip), %rdi     # 0x28fc8
leaq 0xc4ca(%rip), %rsi      # 0x1f0be
callq 0x3210
movq %rax, %rdi
leaq 0xc4d0(%rip), %rsi      # 0x1f0d3
callq 0x3210
movq %rax, %rdi
movq 0x1639e(%rip), %rsi     # 0x28fb0
callq 0x3240
jmp 0x12cb1
movq -0x18(%rbp), %rdi
callq 0x13490
movl %eax, -0xc(%rbp)
movq 0x16399(%rip), %rdi     # 0x28fc8
leaq 0xc4a2(%rip), %rsi      # 0x1f0d8
callq 0x3210
movq %rax, %rdi
leaq 0xc4aa(%rip), %rsi      # 0x1f0ef
callq 0x3210
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x12c8f
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x134b0
movq %rax, %rsi
movq 0x16358(%rip), %rdi     # 0x28fc8
callq 0x31e0
movq %rax, %rdi
leaq 0xccc5(%rip), %rsi      # 0x1f944
callq 0x3210
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12c51
movq 0x16332(%rip), %rdi     # 0x28fc8
leaq 0xc436(%rip), %rsi      # 0x1f0d3
callq 0x3210
movq %rax, %rdi
movq 0x16304(%rip), %rsi     # 0x28fb0
callq 0x3240
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/Backpack.cpp
// Function: Backpack::displayFormula()
void Backpack::displayFormula()
{
    std::cout << PROLOGUE_COLOR
              << "\nNEUTRALIZATION FORMULA"
              << "\n-quadriprohyl alcohol"
              << "\n-ecitobeniphal"
              << "\n-black iron oxide"
              << "\n-tricarbonated liquid"
              << "\n-injection device\n" << RESET << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x15f55(%rip), %rdi     # 0x28fc8
leaq 0xc075(%rip), %rsi      # 0x1f0ef
callq 0x3210
movq %rax, %rdi
leaq 0xc10a(%rip), %rsi      # 0x1f193
callq 0x3210
movq %rax, %rdi
leaq 0xc113(%rip), %rsi      # 0x1f1ab
callq 0x3210
movq %rax, %rdi
leaq 0xc11b(%rip), %rsi      # 0x1f1c2
callq 0x3210
movq %rax, %rdi
leaq 0xc11c(%rip), %rsi      # 0x1f1d2
callq 0x3210
movq %rax, %rdi
leaq 0xc120(%rip), %rsi      # 0x1f1e5
callq 0x3210
movq %rax, %rdi
leaq 0xc128(%rip), %rsi      # 0x1f1fc
callq 0x3210
movq %rax, %rdi
leaq 0xbff0(%rip), %rsi      # 0x1f0d3
callq 0x3210
movq %rax, %rdi
movq 0x15ebe(%rip), %rsi     # 0x28fb0
callq 0x3240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/Backpack.cpp
// Function: Backpack::menu()
void Backpack::menu()
{
    if (contents.empty())
    {
        printContents();
        //no need for options if pack is empty
        return;
    }

    int input = 0;

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

        input = getInteger();

        if (input == 3)
        {
            return;
        }

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

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

        input = 0;
    }





}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x13450
testb $0x1, %al
jne 0x1311f
jmp 0x1312d
movq -0x18(%rbp), %rdi
callq 0x12bb0
jmp 0x131c6
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12bb0
movq 0x15e84(%rip), %rdi     # 0x28fc8
leaq 0xc009(%rip), %rsi      # 0x1f154
callq 0x3210
movq %rax, %rdi
leaq 0xc00f(%rip), %rsi      # 0x1f169
callq 0x3210
movq %rax, %rdi
leaq 0xc020(%rip), %rsi      # 0x1f189
callq 0x3210
movq %rax, %rdi
movq 0x15e38(%rip), %rsi     # 0x28fb0
callq 0x3240
callq 0x175c0
movl %eax, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x1318d
jmp 0x131c6
cmpl $0x2, -0xc(%rbp)
jne 0x131a9
movq -0x18(%rbp), %rdi
callq 0x13060
movsd 0xbe64(%rip), %xmm0     # 0x1f008
callq 0x188c0
cmpl $0x1, -0xc(%rbp)
jne 0x131ba
movq -0x18(%rbp), %rdi
callq 0x12cc0
jmp 0x131c6
movl $0x0, -0xc(%rbp)
jmp 0x13134
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/Bridge.cpp
// Function: Bridge::Bridge()
Bridge::Bridge()
{
    //set up room
    this->roomName = "Bridge";
    occupant = new Harper;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1cf70
movq -0x98(%rbp), %rdi
leaq 0x1378b(%rip), %rax     # 0x28968
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0xa070(%rip), %rsi      # 0x1f25b
callq 0x32e0
jmp 0x151f2
movl $0x68, %edi
callq 0x3220
movq %rax, -0xa0(%rbp)
jmp 0x15205
movq -0xa0(%rbp), %rdi
callq 0x1bee0
jmp 0x15213
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rax
movq %rax, -0xb0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x33d0
movq -0xa8(%rbp), %rdx
leaq 0x9e25(%rip), %rsi      # 0x1f073
leaq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0x15259
movq -0xb0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x159a0
jmp 0x1526b
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
movq -0x98(%rbp), %rax
addq $0x30, %rax
movq %rax, -0xc0(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x33d0
movq -0xb8(%rbp), %rdx
leaq 0x9dce(%rip), %rsi      # 0x1f07b
leaq -0x60(%rbp), %rdi
callq 0x32f0
jmp 0x152b8
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x159a0
jmp 0x152ca
leaq -0x60(%rbp), %rdi
callq 0x3448
leaq -0x61(%rbp), %rdi
callq 0x3250
movq -0x98(%rbp), %rax
addq $0x30, %rax
movq %rax, -0xd0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x33d0
movq -0xc8(%rbp), %rdx
leaq 0x9f53(%rip), %rsi      # 0x1f262
leaq -0x88(%rbp), %rdi
callq 0x32f0
jmp 0x1531d
movq -0xd0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x159a0
jmp 0x15332
leaq -0x88(%rbp), %rdi
callq 0x3448
leaq -0x89(%rbp), %rdi
callq 0x3250
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1540f
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31f0
jmp 0x1540f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x153a4
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 0x1540f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x153d2
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
jmp 0x1540f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x15403
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3448
leaq -0x89(%rbp), %rdi
callq 0x3250
movq -0x98(%rbp), %rdi
callq 0x1cfb0
movq -0x10(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/CaptainsQuarters.cpp
// Function: CaptainsQuarters::CaptainsQuarters()
CaptainsQuarters::CaptainsQuarters()
{
    //set up room
    this->roomName = "Captain's Quarters";
    occupant = new Holly;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1cf70
movq -0x48(%rbp), %rdi
leaq 0x12de4(%rip), %rax     # 0x289c8
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0x97c7(%rip), %rsi      # 0x1f3b9
callq 0x32e0
jmp 0x15bf9
movl $0x68, %edi
callq 0x3220
movq %rax, -0x50(%rbp)
jmp 0x15c09
movq -0x50(%rbp), %rdi
callq 0x1bfb0
jmp 0x15c14
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x30, %rdi
leaq 0x139d5(%rip), %rsi     # 0x29600
callq 0x13720
jmp 0x15c32
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
leaq 0x1391f(%rip), %rsi     # 0x29560
callq 0x13720
jmp 0x15c48
movq -0x48(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x33d0
movq -0x58(%rbp), %rdx
leaq 0x9760(%rip), %rsi      # 0x1f3cc
leaq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0x15c77
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x159a0
jmp 0x15c86
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x15cef
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31f0
jmp 0x15cef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x15ce6
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
movq -0x48(%rbp), %rdi
callq 0x1cfb0
movq -0x10(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/CaptainsQuarters.cpp
// Function: CaptainsQuarters::administerCompound(Player&)
bool CaptainsQuarters::administerCompound(Player& markNelson)
{
    //call base first
    bool continueGame = Space::administerCompound(markNelson);

    //apply ending if parasite hasn't incubated
    if (!markNelson.incubated)
    {
        if (markNelson.crewDead == 0)
        {
            //best ending, won game
            markNelson.state = SAVED_WIFE;
            return false;
        }
        if (markNelson.crewDead == 1)
        {
            markNelson.state = SHOT_ONE_THEN_SAVED_WIFE;
            return false;
        }
        if (markNelson.crewDead == (ALL_CREW - 1)) //all but wife
        {
            markNelson.state = SHOT_ALL_THEN_SAVED_WIFE;
            return false;
        }
        if (markNelson.crewDead > 1)
        {
            markNelson.state = SHOT_SOME_THEN_SAVED_WIFE;
            return false;
        }
    }
    //if we make it here, continue game
    return continueGame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e460
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0x15e2a
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x15dd7
movq -0x18(%rbp), %rax
movl $0x6, 0x30(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x15e32
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x15df2
movq -0x18(%rbp), %rax
movl $0x7, 0x30(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x15e32
movq -0x18(%rbp), %rax
cmpl $0x4, 0x20(%rax)
jne 0x15e0d
movq -0x18(%rbp), %rax
movl $0x9, 0x30(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x15e32
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jle 0x15e28
movq -0x18(%rbp), %rax
movl $0x8, 0x30(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x15e32
jmp 0x15e2a
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/CrewQuarters.cpp
// Function: CrewQuarters::CrewQuarters()
CrewQuarters::CrewQuarters()
{
    //set up room
    this->roomName = "Crew Quarters";
    occupant = new Nate;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1cf70
movq -0x70(%rbp), %rdi
leaq 0x11961(%rip), %rax     # 0x28ab8
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0x82e7(%rip), %rsi      # 0x1f44c
callq 0x32e0
jmp 0x1716c
movl $0x68, %edi
callq 0x3220
movq %rax, -0x78(%rbp)
jmp 0x1717c
movq -0x78(%rbp), %rdi
callq 0x1cd60
jmp 0x17187
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 0x82a4(%rip), %rsi      # 0x1f45a
leaq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0x171c1
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x159a0
jmp 0x171d3
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3250
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq 0x127dc(%rip), %rsi     # 0x299d0
callq 0x13720
jmp 0x171fb
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 0x823c(%rip), %rsi      # 0x1f464
leaq -0x60(%rbp), %rdi
callq 0x32f0
jmp 0x17233
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x159a0
jmp 0x17245
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 0x172df
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31f0
jmp 0x172df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x172a8
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 0x172df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x172d6
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/dansLibrary.cpp
// Function: getLetters[abi:cxx11]()
std::string getLetters()
{
    std::string input;

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

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

		std::cin.clear();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x3300
jmp 0x173a2
movq -0x30(%rbp), %rsi
movb $0x1, -0xa(%rbp)
movq 0x11c27(%rip), %rdi     # 0x28fd8
callq 0x3050
jmp 0x173b8
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x38(%rbp)
callq 0x3170
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x1742a
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x3430
movq %rax, -0x40(%rbp)
jmp 0x173ef
movq -0x40(%rbp), %rax
movsbl (%rax), %edi
callq 0x3360
cmpl $0x0, %eax
jne 0x1741d
movb $0x0, -0xa(%rbp)
jmp 0x1741d
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3448
jmp 0x1749b
jmp 0x1741f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x173bf
testb $0x1, -0xa(%rbp)
jne 0x1745d
movq 0x11b91(%rip), %rdi     # 0x28fc8
leaq 0x8062(%rip), %rsi      # 0x1f4a0
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0x17449
movq -0x48(%rbp), %rdi
movq 0x11b5c(%rip), %rsi     # 0x28fb0
callq 0x3240
jmp 0x1745b
jmp 0x17469
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x17491
jmp 0x17488
movq 0x11b68(%rip), %rdi     # 0x28fd8
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x33a0
jmp 0x17483
jmp 0x173a0
movq -0x30(%rbp), %rdi
callq 0x3448
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: getYesNo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char getYesNo(std::string prompt)
{
    std::cout << prompt << std::endl;
    char yesOrNo;
	std::cin >> yesOrNo;
    std::cin.clear();
    std::cin.ignore(LARGE_NUMBER, '\n');

	yesOrNo = toupper(yesOrNo);

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

    return yesOrNo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movq 0x11b02(%rip), %rdi     # 0x28fc8
callq 0x31e0
movq %rax, %rdi
movq 0x11adb(%rip), %rsi     # 0x28fb0
callq 0x3240
movq 0x11af7(%rip), %rdi     # 0x28fd8
leaq -0x9(%rbp), %rsi
callq 0x32c0
movq 0x11ae7(%rip), %rax     # 0x28fd8
movq (%rax), %rax
movq 0x11add(%rip), %rdi     # 0x28fd8
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x33a0
movq 0x11acb(%rip), %rdi     # 0x28fd8
movl $0x186a0, %esi          # imm = 0x186A0
movl $0xa, %edx
callq 0x3150
movsbl -0x9(%rbp), %edi
callq 0x3400
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl $0x59, %ecx
movb %al, -0xa(%rbp)
je 0x17543
movsbl -0x9(%rbp), %eax
cmpl $0x4e, %eax
setne %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
testb $0x1, %al
jne 0x1754c
jmp 0x175b2
movq 0x11a75(%rip), %rdi     # 0x28fc8
leaq 0x7f6d(%rip), %rsi      # 0x1f4c7
callq 0x3210
movq 0x11a72(%rip), %rdi     # 0x28fd8
leaq -0x9(%rbp), %rsi
callq 0x32c0
movq 0x11a62(%rip), %rax     # 0x28fd8
movq (%rax), %rax
movq 0x11a58(%rip), %rdi     # 0x28fd8
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x33a0
movq 0x11a46(%rip), %rdi     # 0x28fd8
movl $0x186a0, %esi          # imm = 0x186A0
movl $0xa, %edx
callq 0x3150
movsbl -0x9(%rbp), %edi
callq 0x3400
movb %al, -0x9(%rbp)
jmp 0x17528
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dnegovan[P]Intruder-On-Donnar-V/dansLibrary.cpp
// Function: getDouble()
double getDouble()
{
    double input;

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

	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x11569(%rip), %rdi     # 0x28fd8
leaq -0x8(%rbp), %rsi
callq 0x31b0
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3280
testb $0x1, %al
jne 0x17a8d
jmp 0x17ab1
callq 0x18bc0
movq %rax, %rsi
movq 0x1153c(%rip), %rdi     # 0x28fd8
movl $0xa, %edx
callq 0x3150
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
movq 0x11538(%rip), %rdi     # 0x28ff0
leaq 0x7a4a(%rip), %rsi      # 0x1f509
callq 0x3210
movq %rax, %rdi
movq 0x114e2(%rip), %rsi     # 0x28fb0
callq 0x3240
movq 0x114fe(%rip), %rax     # 0x28fd8
movq (%rax), %rax
movq 0x114f4(%rip), %rdi     # 0x28fd8
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x33a0
movq 0x114e2(%rip), %rdi     # 0x28fd8
callq 0x3260
cmpl $0xa, %eax
je 0x17b02
jmp 0x17aef
jmp 0x17b04
jmp 0x17a68
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0x1149a(%rip), %rdi     # 0x28fc8
callq 0x31e0
movq %rax, %rdi
movq 0x11473(%rip), %rsi     # 0x28fb0
callq 0x3240
callq 0x175c0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0x15(%rbp)
jl 0x17b63
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
setg %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x17b6c
jmp 0x17bcf
movq 0x11455(%rip), %rdi     # 0x28fc8
leaq 0x79ac(%rip), %rsi      # 0x1f526
callq 0x3210
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x33b0
movq %rax, %rdi
leaq 0x881f(%rip), %rsi      # 0x203b3
callq 0x3210
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x33b0
movq %rax, %rdi
leaq 0x79e5(%rip), %rsi      # 0x1f593
callq 0x3210
movq %rax, %rdi
movq 0x113f3(%rip), %rsi     # 0x28fb0
callq 0x3240
callq 0x175c0
movl %eax, -0x14(%rbp)
jmp 0x17b4a
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq 0x113c8(%rip), %rdi     # 0x28fc8
callq 0x31e0
movq %rax, %rdi
leaq 0x7924(%rip), %rsi      # 0x1f533
callq 0x3210
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x3410
movq %rax, %rdi
leaq 0x8788(%rip), %rsi      # 0x203b3
callq 0x3210
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x3410
movq %rax, %rdi
movq 0x11369(%rip), %rsi     # 0x28fb0
callq 0x3240
callq 0x17a60
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
ja 0x17c7b
movsd -0x20(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x17c84
jmp 0x17cde
movq 0x1133d(%rip), %rdi     # 0x28fc8
leaq 0x7894(%rip), %rsi      # 0x1f526
callq 0x3210
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x3410
movq %rax, %rdi
leaq 0x8705(%rip), %rsi      # 0x203b3
callq 0x3210
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x3410
movq %rax, %rdi
movq 0x112e6(%rip), %rsi     # 0x28fb0
callq 0x3240
callq 0x17a60
movsd %xmm0, -0x20(%rbp)
jmp 0x17c56
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)