LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: createRandomMatrix()
m4 createRandomMatrix(){
    return m4(
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100)
                     );
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movss 0x10e9(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x3c(%rsp)
movss 0x10d6(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x38(%rsp)
movss 0x10c3(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x34(%rsp)
movss 0x10b0(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x30(%rsp)
movss 0x109d(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x2c(%rsp)
movss 0x108a(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x28(%rsp)
movss 0x1077(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x24(%rsp)
movss 0x1064(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x20(%rsp)
movss 0x1051(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x1c(%rsp)
movss 0x103e(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x18(%rsp)
movss 0x102b(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x14(%rsp)
movss 0x1018(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0x10(%rsp)
movss 0x1005(%rip), %xmm0     # 0x3030
callq 0x1f17
movss %xmm0, 0xc(%rsp)
movss 0xff2(%rip), %xmm0      # 0x3030
callq 0x1f17
movss %xmm0, 0x8(%rsp)
movss 0xfdf(%rip), %xmm0      # 0x3030
callq 0x1f17
movss %xmm0, 0x4(%rsp)
movss 0xfcc(%rip), %xmm0      # 0x3030
callq 0x1f17
movss 0x3c(%rsp), %xmm1
movss %xmm1, (%rbx)
movss 0x38(%rsp), %xmm1
movss %xmm1, 0x4(%rbx)
movss 0x34(%rsp), %xmm1
movss %xmm1, 0x8(%rbx)
movss 0x30(%rsp), %xmm1
movss %xmm1, 0xc(%rbx)
movss 0x2c(%rsp), %xmm1
movss %xmm1, 0x10(%rbx)
movss 0x28(%rsp), %xmm1
movss %xmm1, 0x14(%rbx)
movss 0x24(%rsp), %xmm1
movss %xmm1, 0x18(%rbx)
movss 0x20(%rsp), %xmm1
movss %xmm1, 0x1c(%rbx)
movss 0x1c(%rsp), %xmm1
movss %xmm1, 0x20(%rbx)
movss 0x18(%rsp), %xmm1
movss %xmm1, 0x24(%rbx)
movss 0x14(%rsp), %xmm1
movss %xmm1, 0x28(%rbx)
movss 0x10(%rsp), %xmm1
movss %xmm1, 0x2c(%rbx)
movss 0xc(%rsp), %xmm1
movss %xmm1, 0x30(%rbx)
movss 0x8(%rsp), %xmm1
movss %xmm1, 0x34(%rbx)
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x38(%rbx)
movss %xmm0, 0x3c(%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testMultiplication(long)
double testMultiplication(long count){
    m4 m1 = createRandomMatrix();
    m4 m2 = createRandomMatrix();    
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = m1 * m2;
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
leaq 0x40(%rsp), %rdi
callq 0x1f37
movq %rsp, %rdi
callq 0x1f37
leaq 0x2f8c(%rip), %rbx      # 0x50c8
movq %rbx, %rdi
callq 0x12a2
movq %rbx, %rdi
callq 0x12b2
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
jmp 0x1318
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testTranslation(long)
double testTranslation(long count){
    m4 m1 = createRandomMatrix();
    v3 v1 = v3(1, 2, 3);

    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::translate(m1,v1);
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rdi
callq 0x1f37
leaq 0x2f58(%rip), %rbx      # 0x50c8
movq %rbx, %rdi
callq 0x12a2
movq %rbx, %rdi
callq 0x12b2
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x1318
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testScale(long)
double testScale(long count){
    m4 m1 = createRandomMatrix();
    v3 v1 = v3(1, 2, 3);
    
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::scale(m1,v1);
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rdi
callq 0x1f37
leaq 0x2f27(%rip), %rbx      # 0x50c8
movq %rbx, %rdi
callq 0x12a2
movq %rbx, %rdi
callq 0x12b2
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x1318
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testRotationArbitraryAxis(long)
double testRotationArbitraryAxis(long count){
    m4 m1 = createRandomMatrix();
    v3 v1 = v3(1, 2, 3);
    floatType a = (floatType)M_PI /2;
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::rotate(m1,a,v1);
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rdi
callq 0x1f37
leaq 0x2ef6(%rip), %rbx      # 0x50c8
movq %rbx, %rdi
callq 0x12a2
movq %rbx, %rdi
callq 0x12b2
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x1318
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testTranspose(long)
double testTranspose(long count){
    m4 m1 = createRandomMatrix();

    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::transpose(m1);
    }
    t.stop();
    if (rand()==0){ // force compiler to not optimize loop away
        std::cout<<m1[rand()%3][rand()%3]<<std::endl;
    }

    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1f37
leaq 0x2ebb(%rip), %rdi      # 0x50c8
callq 0x12a2
movss 0x10(%r14), %xmm0
movss %xmm0, (%rsp)
movss 0x20(%r14), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x30(%r14), %xmm1
movss 0x4(%r14), %xmm11
movss 0x8(%r14), %xmm9
movss 0x24(%r14), %xmm5
movss 0x34(%r14), %xmm4
movss 0x18(%r14), %xmm10
movss 0x38(%r14), %xmm0
movss 0xc(%r14), %xmm8
movss 0x1c(%r14), %xmm7
movss 0x2c(%r14), %xmm6
xorl %eax, %eax
testq %rbx, %rbx
cmovgq %rbx, %rax
incq %rax
movss (%rsp), %xmm3
movss 0x4(%rsp), %xmm2
movaps %xmm1, %xmm15
movss %xmm11, (%rsp)
movaps %xmm5, %xmm14
movaps %xmm4, %xmm13
movss %xmm9, 0x4(%rsp)
movaps %xmm10, %xmm5
movaps %xmm0, %xmm12
movaps %xmm8, %xmm1
movaps %xmm7, %xmm4
movaps %xmm6, %xmm0
movaps %xmm12, %xmm6
movaps %xmm13, %xmm7
movaps %xmm15, %xmm8
movaps %xmm14, %xmm10
movaps %xmm2, %xmm9
movaps %xmm3, %xmm11
decq %rax
jne 0x2271
movss %xmm3, 0x18(%rsp)
movss %xmm2, 0x28(%rsp)
movss %xmm15, 0x38(%rsp)
movss (%rsp), %xmm2
movss %xmm2, 0xc(%rsp)
movss %xmm14, 0x2c(%rsp)
movss %xmm13, 0x3c(%rsp)
movss 0x4(%rsp), %xmm2
movss %xmm2, 0x10(%rsp)
movss %xmm5, 0x20(%rsp)
movss %xmm12, 0x40(%rsp)
movss %xmm1, 0x14(%rsp)
movss %xmm4, 0x24(%rsp)
movss %xmm0, 0x34(%rsp)
leaq 0x2da6(%rip), %rdi      # 0x50c8
callq 0x12b2
callq 0x1030
testl %eax, %eax
jne 0x2376
callq 0x1030
movl %eax, %ebx
callq 0x1030
pushq $0x3
popq %rsi
cltd
idivl %esi
testl %edx, %edx
js 0x2389
movl %edx, %ecx
movl %ebx, %eax
cltd
idivl %esi
movslq %edx, %rax
shlq $0x4, %rax
addq %rsp, %rax
addq $0x8, %rax
movl %ecx, %ecx
movss (%rax,%rcx,4), %xmm0
movq 0x2c6f(%rip), %rdi      # 0x4fd8
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x2d4b(%rip), %rdi      # 0x50c8
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x1318
leaq 0xea7(%rip), %rdi       # 0x3237
leaq 0xed8(%rip), %rsi       # 0x326f
leaq 0xeec(%rip), %rcx       # 0x328a
pushq $0x2c
popq %rdx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testInverse(long)
double testInverse(long count){
    m4 m1 = createRandomMatrix();
    
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::inverse(m1);
    }
    t.stop();
    if (rand()==0){ // force compiler to not optimize loop away
        std::cout<<m1[rand()%3][rand()%3]<<std::endl;
    }

    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1f37
leaq 0x2d01(%rip), %rdi      # 0x50c8
callq 0x12a2
xorl %r15d, %r15d
testq %r14, %r14
cmovgq %r14, %r15
leaq 0x40(%rsp), %r14
subq $0x1, %r15
jb 0x2415
movq %r14, %rdi
movq %rbx, %rsi
callq 0x292c
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movaps 0x70(%rsp), %xmm3
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm3, 0x30(%rsp)
jmp 0x23db
leaq 0x2cac(%rip), %rdi      # 0x50c8
callq 0x12b2
callq 0x1030
testl %eax, %eax
jne 0x246c
callq 0x1030
movl %eax, %ebx
callq 0x1030
pushq $0x3
popq %rsi
cltd
idivl %esi
testl %edx, %edx
js 0x2485
movl %edx, %ecx
movl %ebx, %eax
cltd
idivl %esi
movslq %edx, %rax
shlq $0x4, %rax
addq %rsp, %rax
movl %ecx, %ecx
movss (%rax,%rcx,4), %xmm0
movq 0x2b79(%rip), %rdi      # 0x4fd8
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x2c55(%rip), %rdi      # 0x50c8
callq 0x1318
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xdab(%rip), %rdi       # 0x3237
leaq 0xddc(%rip), %rsi       # 0x326f
leaq 0xdf0(%rip), %rcx       # 0x328a
pushq $0x2c
popq %rdx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testInverseMat3(long)
double testInverseMat3(long count){
    m4 m1 = createRandomMatrix();
    m3 m2;
    m2 = m3(m1); // note that this benchmark is actually doing less than 
    t.start();
    for (int i = 0; i < count; i++) {
        m2 = glm::inverse(m2);
    }
    t.stop();
    if (rand()==0){ // force compiler to not optimize loop away
        std::cout<<m2[rand()%3][rand()%3]<<std::endl;
    }
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x1f37
movups 0x4(%r15), %xmm0
movups 0x14(%r15), %xmm1
movss 0x10(%r15), %xmm2
shufps $0xd4, %xmm0, %xmm2     # xmm2 = xmm2[0,1],xmm0[1,3]
unpcklpd (%r15), %xmm0           # xmm0 = xmm0[0],mem[0]
movss 0x28(%r15), %xmm3
shufps $0x22, %xmm2, %xmm0     # xmm0 = xmm0[2,0],xmm2[2,0]
movq %rsp, %rbx
movaps %xmm0, (%rbx)
unpcklpd 0x20(%r15), %xmm1       # xmm1 = xmm1[0],mem[0]
movaps %xmm1, 0x10(%rbx)
movss %xmm3, 0x20(%rbx)
leaq 0x2bcb(%rip), %rdi      # 0x50c8
callq 0x12a2
xorl %r15d, %r15d
testq %r14, %r14
cmovgq %r14, %r15
leaq 0x30(%rsp), %r14
subq $0x1, %r15
jb 0x2543
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2dd2
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
movss 0x50(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
jmp 0x2511
leaq 0x2b7e(%rip), %rdi      # 0x50c8
callq 0x12b2
callq 0x1030
testl %eax, %eax
jne 0x259a
callq 0x1030
movl %eax, %ebx
callq 0x1030
pushq $0x3
popq %rsi
cltd
idivl %esi
testl %edx, %edx
js 0x25b3
movl %edx, %ecx
movl %ebx, %eax
cltd
idivl %esi
movslq %edx, %rax
imulq $0xc, %rax, %rax
addq %rsp, %rax
movl %ecx, %ecx
movss (%rax,%rcx,4), %xmm0
movq 0x2a4b(%rip), %rdi      # 0x4fd8
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x2b27(%rip), %rdi      # 0x50c8
callq 0x1318
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc7d(%rip), %rdi       # 0x3237
leaq 0xc93(%rip), %rsi       # 0x3254
leaq 0xd1d(%rip), %rcx       # 0x32e5
pushq $0x2c
popq %rdx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testVectorTransformation(long)
double testVectorTransformation(long count){
    m4 m1 = createRandomMatrix();
    v4 v1 = v4(1,2,3,1);
    t.start();
    for (int i = 0; i < count; i++) {
        v1 = m1*v1;
    }
    t.stop();
    if (rand()==0){ // force compiler to keep input
        std::cout<<v1[rand()%4]<<std::endl;
    }
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1f37
leaq 0x2ada(%rip), %rdi      # 0x50c8
callq 0x12a2
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movaps 0x30(%r14), %xmm3
xorl %eax, %eax
testq %rbx, %rbx
cmovgq %rbx, %rax
movaps 0xb1a(%rip), %xmm4      # 0x3130
subq $0x1, %rax
jb 0x264c
movaps %xmm4, %xmm5
shufps $0x0, %xmm4, %xmm5      # xmm5 = xmm5[0,0],xmm4[0,0]
mulps %xmm0, %xmm5
movaps %xmm4, %xmm6
shufps $0x55, %xmm4, %xmm6     # xmm6 = xmm6[1,1],xmm4[1,1]
mulps %xmm1, %xmm6
addps %xmm5, %xmm6
movaps %xmm4, %xmm5
shufps $0xaa, %xmm4, %xmm5     # xmm5 = xmm5[2,2],xmm4[2,2]
mulps %xmm2, %xmm5
shufps $0xff, %xmm4, %xmm4     # xmm4 = xmm4[3,3,3,3]
mulps %xmm3, %xmm4
addps %xmm5, %xmm4
addps %xmm6, %xmm4
jmp 0x2616
movaps %xmm4, (%rsp)
leaq 0x2a71(%rip), %rdi      # 0x50c8
callq 0x12b2
callq 0x1030
testl %eax, %eax
jne 0x268f
callq 0x1030
pushq $0x4
popq %rcx
cltd
idivl %ecx
testl %edx, %edx
js 0x26a2
movl %edx, %eax
movss (%rsp,%rax,4), %xmm0
movq 0x2956(%rip), %rdi      # 0x4fd8
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x2a32(%rip), %rdi      # 0x50c8
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x1318
leaq 0xb8e(%rip), %rdi       # 0x3237
leaq 0xbbf(%rip), %rsi       # 0x326f
leaq 0xbd3(%rip), %rcx       # 0x328a
pushq $0x2c
popq %rdx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: runTestCase(double (*)(long), char*)
void runTestCase(double(*f)(long), char* name){
    double totalTime = 0;
    double minTime = 0;
    double maxTime = 0;
    
    for(int i = 0; i < runCount; ++i) {
        double time = f(internalRunCount);
        if(i == 0) {
            minTime = time;
            maxTime = time;
        } else {
            if(minTime > time) { minTime = time; }
            if(maxTime < time) { maxTime = time; }
        }
        totalTime += time;
    }
    
    double avg = totalTime / runCount;
    
    std::cout<<name<<" - Avg: "<<avg<<"ms, Min: "<<minTime<<"ms, Max: "<<maxTime<<"ms"<<std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
xorpd %xmm2, %xmm2
movl 0x29bf(%rip), %eax      # 0x50a8
cmpl %eax, %ebp
jge 0x2739
movsd %xmm2, 0x8(%rsp)
movq 0x29b6(%rip), %rdi      # 0x50b0
callq *%r14
testl %ebp, %ebp
je 0x271b
movapd %xmm0, %xmm1
minsd 0x18(%rsp), %xmm1
ucomisd 0x10(%rsp), %xmm0
jbe 0x2725
movsd %xmm0, 0x10(%rsp)
jmp 0x2725
movsd %xmm0, 0x10(%rsp)
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
addsd %xmm0, %xmm2
incl %ebp
movsd %xmm1, 0x18(%rsp)
jmp 0x26e3
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
movq 0x288a(%rip), %rdi      # 0x4fd8
movq %rbx, %rsi
callq 0x10c0
leaq 0x9f3(%rip), %rsi       # 0x3150
movq %rax, %rdi
callq 0x10c0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x10f0
leaq 0x9df(%rip), %rsi       # 0x3159
movq %rax, %rdi
callq 0x10c0
movq %rax, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x10f0
leaq 0x9cc(%rip), %rsi       # 0x3163
movq %rax, %rdi
callq 0x10c0
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x10f0
leaq 0x9b9(%rip), %rsi       # 0x316d
movq %rax, %rdi
callq 0x10c0
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O2/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: main
int main (int argc, const char * argv[])
{
	if (argc>=2){
		internalRunCount = atoi(argv[1]);
		std::cout<<"InternalRunCount: "<<internalRunCount<<std::endl;
	}
	if (argc>=3){
		runCount = atoi(argv[2]);
		std::cout<<"Run count: "<<runCount<<std::endl;
	}

    /* initialize random seed: */
    srand ( time(NULL) );
        
    int matrixBytes = sizeof(createRandomMatrix());
    
    std::cout<<"Using double precision "<<((matrixBytes>64)?"true":"false")<<std::endl;
    runTestCase(&testMultiplication,"testMultiplication");
    runTestCase(&testTranslation,"testTranslation");
    runTestCase(&testScale,"testScale");
    runTestCase(&testRotationArbitraryAxis,"testRotationArbitraryAxis");
    runTestCase(&testTranspose,"testTranspose");
    runTestCase(&testInverse,"testInverse");    
    runTestCase(&testInverseMat3,"testInverseMat3");    
    runTestCase(&testVectorTransformation,"testVectorTransformation");        

    
    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x2852
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rdi
callq 0x10e0
cltq
movq %rax, 0x28c5(%rip)      # 0x50b0
movq 0x27e6(%rip), %rdi      # 0x4fd8
leaq 0x977(%rip), %rsi       # 0x3170
callq 0x10c0
movq 0x28ab(%rip), %rsi      # 0x50b0
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1040
cmpl $0x2, %ebp
je 0x2852
movq 0x10(%rbx), %rdi
callq 0x10e0
movl %eax, 0x287f(%rip)      # 0x50a8
movq 0x27a8(%rip), %rdi      # 0x4fd8
leaq 0x94c(%rip), %rsi       # 0x3183
callq 0x10c0
movl 0x2866(%rip), %esi      # 0x50a8
movq %rax, %rdi
callq 0x1110
movq %rax, %rdi
callq 0x1040
xorl %edi, %edi
callq 0x1090
movl %eax, %edi
callq 0x10b0
movq 0x2771(%rip), %rdi      # 0x4fd8
leaq 0x921(%rip), %rsi       # 0x318f
callq 0x10c0
leaq 0x92d(%rip), %rsi       # 0x31a7
movq %rax, %rdi
callq 0x10c0
movq %rax, %rdi
callq 0x1040
leaq -0x776(%rip), %rdi      # 0x211b
leaq 0x915(%rip), %rsi       # 0x31ad
callq 0x26bf
leaq -0x748(%rip), %rdi      # 0x215c
leaq 0x915(%rip), %rsi       # 0x31c0
callq 0x26bf
leaq -0x72a(%rip), %rdi      # 0x218d
leaq 0x912(%rip), %rsi       # 0x31d0
callq 0x26bf
leaq -0x70c(%rip), %rdi      # 0x21be
leaq 0x909(%rip), %rsi       # 0x31da
callq 0x26bf
leaq -0x6ee(%rip), %rdi      # 0x21ef
leaq 0x910(%rip), %rsi       # 0x31f4
callq 0x26bf
leaq -0x54a(%rip), %rdi      # 0x23a6
leaq 0x90b(%rip), %rsi       # 0x3202
callq 0x26bf
leaq -0x461(%rip), %rdi      # 0x24a2
leaq 0x904(%rip), %rsi       # 0x320e
callq 0x26bf
leaq -0x346(%rip), %rdi      # 0x25d0
leaq 0x901(%rip), %rsi       # 0x321e
callq 0x26bf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/main.cpp
// Function: main
int main() {
	// Set a random generator seed
	// Referenced from Program 3-32 of C++ Early Objects, 9th Edition
	unsigned seed;

	seed = static_cast<unsigned>(time(nullptr));
	srand(seed);

	// Construct and begin game
	Game game;
	game.startGame();

	// Give player the option to play again
	int repeatChoice = 0;

	do {
		game.repeatMenu();
		repeatChoice = game.intValidation(1,2);

		switch(repeatChoice) {
			case 1: {
				Game repeatGame;
				repeatGame.startGame();
				break;
			}
			case 2:
				break;
			default:
				break;
		}
	} while (repeatChoice != 2);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
xorl %edi, %edi
callq 0x2180
movl %eax, %edi
callq 0x2190
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ee8
movq %rbx, %rdi
callq 0x385a
leaq 0x8(%rsp), %rbx
pushq $0x1
popq %rbp
pushq $0x2
popq %r14
leaq 0x98(%rsp), %r15
movq %rbx, %rdi
callq 0x53f2
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x506a
cmpl $0x1, %eax
je 0x25d1
cmpl $0x2, %eax
jne 0x25b0
jmp 0x25eb
movq %r15, %rdi
callq 0x2ee8
movq %r15, %rdi
callq 0x385a
movq %r15, %rdi
callq 0x546e
jmp 0x25b0
leaq 0x8(%rsp), %rdi
callq 0x546e
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x261b
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x546e
jmp 0x261e
jmp 0x261b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x546e
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/basicSatchel.cpp
// Function: BasicSatchel::printWeapons() const
void BasicSatchel::printWeapons() const {
	if (candlestick) {
		cout << "- candlestick" << endl;
	}
	if (knife) {
		cout << "- knife" << endl;
	}
	if (revolver) {
		cout << "- revolver" << endl;
	}
	if (rope) {
		cout << "- rope" << endl;
	}
	if (wrench) {
		cout << "- wrench" << endl;
	}

	if (pipe) {
		cout << "- pipe" << endl;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x14(%rdi)
jne 0x2a03
movq 0xe5e1(%rip), %rdi      # 0x10fd0
leaq 0x6b3e(%rip), %rsi      # 0x9534
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
cmpb $0x1, 0x10(%rbx)
jne 0x2a24
movq 0xe5c0(%rip), %rdi      # 0x10fd0
leaq 0x6b2b(%rip), %rsi      # 0x9542
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
cmpb $0x1, 0x12(%rbx)
jne 0x2a45
movq 0xe59f(%rip), %rdi      # 0x10fd0
leaq 0x6b12(%rip), %rsi      # 0x954a
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
cmpb $0x1, 0x11(%rbx)
jne 0x2a66
movq 0xe57e(%rip), %rdi      # 0x10fd0
leaq 0x6afc(%rip), %rsi      # 0x9555
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
cmpb $0x1, 0x13(%rbx)
jne 0x2a87
movq 0xe55d(%rip), %rdi      # 0x10fd0
leaq 0x6ae2(%rip), %rsi      # 0x955c
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
cmpb $0x1, 0x15(%rbx)
jne 0x2aa9
movq 0xe53c(%rip), %rdi      # 0x10fd0
leaq 0x6aca(%rip), %rsi      # 0x9565
callq 0x21a0
movq %rax, %rdi
popq %rbx
jmp 0x20c0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/eat.cpp
// Function: Eat::action[abi:cxx11]()
std::string Eat::action() {
	cout << "You have come across " << foodItem << "." << endl;
	cout << "What would you like to do?" << endl;
	cout << "1. Do nothing. Food only slows you down." << endl;
	cout << "2. Eat it. This may be your last meal." << endl;

	return Space::action();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0xe3be(%rip), %r15      # 0x10fd0
leaq 0x696a(%rip), %rsi      # 0x9583
movq %r15, %rdi
callq 0x21a0
leaq 0x80(%r14), %rsi
movq %rax, %rdi
callq 0x2170
leaq 0x73c9(%rip), %rsi      # 0xa000
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x694b(%rip), %rsi      # 0x9599
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x694f(%rip), %rsi      # 0x95b4
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x6961(%rip), %rsi      # 0x95dd
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x791e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/entertain.cpp
// Function: Entertain::action[abi:cxx11]()
std::string Entertain::action() {
	cout << "You have come across " << gameItem << "." << endl;
	cout << "What would you like to do?" << endl;
	cout << "1. Do nothing. It's too dangerous." << endl;
	cout << "2. You're under a lot of pressure. Entertain yourself for a bit. "
			<< endl;

	return Space::action();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0xe1b2(%rip), %r15      # 0x10fd0
leaq 0x675e(%rip), %rsi      # 0x9583
movq %r15, %rdi
callq 0x21a0
leaq 0x80(%r14), %rsi
movq %rax, %rdi
callq 0x2170
leaq 0x71bd(%rip), %rsi      # 0xa000
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x673f(%rip), %rsi      # 0x9599
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x6798(%rip), %rsi      # 0x9609
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x67a4(%rip), %rsi      # 0x962c
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x791e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/game.cpp
// Function: Game::intValidation(int, int) const
int Game::intValidation(int min, int max) const {
	int input;
	cin >> input;

	// Try again if input is out of range or fails
	while (input < min || input > max || cin.fail()) {
		cout << "Input must be an integer between " << min << " and "
		     << max << "." << endl;
		cout << "Please try again: ";
		cin.clear();
		cin.ignore(256, '\n');
		cin >> input;
	}

	// Flush buffer after successful input
	cin.clear();
	cin.ignore(256, '\n');

	return input;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq 0xbf5f(%rip), %rbx      # 0x10fe0
movq 0xbf48(%rip), %r12      # 0x10fd0
leaq 0x65d0(%rip), %r15      # 0xb65f
pushq $0xa
popq %r13
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
callq 0x20f0
movl 0x4(%rsp), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebp, %eax
setg %al
orb %cl, %al
jne 0x50c1
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x513c
movq %r12, %rdi
leaq 0x656c(%rip), %rsi      # 0xb637
callq 0x21a0
movq %rax, %rdi
movl %r14d, %esi
callq 0x2280
movq %rax, %rdi
leaq 0x6574(%rip), %rsi      # 0xb659
callq 0x21a0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2280
movq %rax, %rdi
leaq 0x4f02(%rip), %rsi      # 0xa000
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x21a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2270
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movl %r13d, %edx
callq 0x2100
jmp 0x5093
addq %rax, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2270
movq 0xbe90(%rip), %rdi      # 0x10fe0
pushq $0xa
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x2100
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/game.cpp
// Function: Game::repeatMenu() const
void Game::repeatMenu() const {
	cout << "\n\t PLAY AGAIN?" << endl;
	cout << "1. Try your hand at joining Hydra again." << endl;
	cout << "** Remember: the room with the secret escape changes for each "
			"trial." << endl;
	cout << "2. Exit the program." << endl;
	cout << "Make your choice: " << endl;
}

// Assembly:
pushq %rbx
movq 0xbbd6(%rip), %rbx      # 0x10fd0
leaq 0x6653(%rip), %rsi      # 0xba54
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x664b(%rip), %rsi      # 0xba63
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x665d(%rip), %rsi      # 0xba8c
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x668b(%rip), %rsi      # 0xbad1
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x64b1(%rip), %rsi      # 0xb90e
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
popq %rbx
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/game.cpp
// Function: Game::~Game()
Game::~Game() {
	delete satchel;
	delete map;

	// Free memory for all rooms
	delete study;
	delete library;
	delete billiards;
	delete conservatory;
	delete ballroom;
	delete kitchen;
	delete dining;
	delete lounge;
	delete hall;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5481
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rdi
movl $0x591, %esi            # imm = 0x591
callq 0x21c0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x549d
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x54ac
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x54bb
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x54ca
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x54d9
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x54e8
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x54f7
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x5506
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x5515
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x68, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/map.cpp
// Function: Map::clearPlayer()
void Map::clearPlayer() {
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 57; j++) {
			if (board[i][j] == '*') {
				board[i][j] = ' ';
			}
		}
	}
}

// Assembly:
xorl %eax, %eax
cmpq $0x19, %rax
je 0x5efc
xorl %ecx, %ecx
cmpq $0x39, %rcx
je 0x5ef3
cmpb $0x2a, (%rdi,%rcx)
jne 0x5eee
movb $0x20, (%rdi,%rcx)
incq %rcx
jmp 0x5ede
incq %rax
addq $0x39, %rdi
jmp 0x5ed6
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/map.cpp
// Function: Map::printBoard() const
void Map::printBoard() const {
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 57; j++) {
			std::cout << board[i][j];
		}
		std::cout << std::endl;
	}
	std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0xb01b(%rip), %r14      # 0x10fd0
cmpq $0x19, %r15
je 0x5fe7
xorl %r12d, %r12d
cmpq $0x39, %r12
je 0x5fd6
movsbl (%rbx,%r12), %esi
movq %r14, %rdi
callq 0x21d0
incq %r12
jmp 0x5fbe
movq %r14, %rdi
callq 0x20c0
incq %r15
addq $0x39, %rbx
jmp 0x5fb5
movq 0xafe2(%rip), %rdi      # 0x10fd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/queueSatchel.cpp
// Function: QueueSatchel::updateWeapons()
void QueueSatchel::updateWeapons() {
	// Count weapons in deque
	long count;

	// Search for each weapon type in bag and set bool flag to false if not found
	count = std::count(satchel.begin(), satchel.end(), "knife");
	if (count == 0) {
		knife = false;
	}

	count = std::count(satchel.begin(), satchel.end(), "wrench");
	if (count == 0) {
		wrench = false;
	}

	count = std::count(satchel.begin(), satchel.end(), "rope");
	if (count == 0) {
		rope = false;
	}

	count = std::count(satchel.begin(), satchel.end(), "pipe");
	if (count == 0) {
		pipe = false;
	}

	count = std::count(satchel.begin(), satchel.end(), "revolver");
	if (count == 0) {
		revolver = false;
	}

	count = std::count(satchel.begin(), satchel.end(), "candlestick");
	if (count == 0) {
		candlestick = false;
	}
}

// Assembly:
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
movups 0x28(%rdi), %xmm0
leaq 0x160(%rsp), %rdi
movaps %xmm0, (%rdi)
movups 0x38(%rbx), %xmm0
movaps %xmm0, 0x10(%rdi)
movups 0x48(%rbx), %xmm0
leaq 0x140(%rsp), %rsi
movaps %xmm0, (%rsi)
movups 0x58(%rbx), %xmm0
movaps %xmm0, 0x10(%rsi)
leaq 0x320a(%rip), %rdx      # 0x9544
callq 0x6582
testq %rax, %rax
jne 0x6348
movb $0x0, 0x10(%rbx)
movups 0x28(%rbx), %xmm0
leaq 0x120(%rsp), %rdi
movaps %xmm0, (%rdi)
movups 0x38(%rbx), %xmm0
movaps %xmm0, 0x10(%rdi)
movups 0x48(%rbx), %xmm0
leaq 0x100(%rsp), %rsi
movaps %xmm0, (%rsi)
movups 0x58(%rbx), %xmm0
movaps %xmm0, 0x10(%rsi)
leaq 0x31e1(%rip), %rdx      # 0x955e
callq 0x65ba
testq %rax, %rax
jne 0x638b
movb $0x0, 0x13(%rbx)
movups 0x28(%rbx), %xmm0
leaq 0xe0(%rsp), %rdi
movaps %xmm0, (%rdi)
movups 0x38(%rbx), %xmm0
movaps %xmm0, 0x10(%rdi)
movups 0x48(%rbx), %xmm0
leaq 0xc0(%rsp), %rsi
movaps %xmm0, (%rsi)
movups 0x58(%rbx), %xmm0
movaps %xmm0, 0x10(%rsi)
leaq 0x3197(%rip), %rdx      # 0x9557
callq 0x65f2
testq %rax, %rax
jne 0x63ce
movb $0x0, 0x11(%rbx)
movups 0x28(%rbx), %xmm0
leaq 0xa0(%rsp), %rdi
movaps %xmm0, (%rdi)
movups 0x38(%rbx), %xmm0
movaps %xmm0, 0x10(%rdi)
movups 0x48(%rbx), %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, (%rsi)
movups 0x58(%rbx), %xmm0
movaps %xmm0, 0x10(%rsi)
leaq 0x3164(%rip), %rdx      # 0x9567
callq 0x65f2
testq %rax, %rax
jne 0x6411
movb $0x0, 0x15(%rbx)
movups 0x28(%rbx), %xmm0
leaq 0x60(%rsp), %rdi
movaps %xmm0, (%rdi)
movups 0x38(%rbx), %xmm0
movaps %xmm0, 0x10(%rdi)
movups 0x48(%rbx), %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
movups 0x58(%rbx), %xmm0
movaps %xmm0, 0x10(%rsi)
leaq 0x310c(%rip), %rdx      # 0x954c
callq 0x662a
testq %rax, %rax
jne 0x644e
movb $0x0, 0x12(%rbx)
movups 0x28(%rbx), %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movups 0x38(%rbx), %xmm0
movaps %xmm0, 0x10(%rdi)
movups 0x48(%rbx), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movups 0x58(%rbx), %xmm0
movaps %xmm0, 0x10(%rsi)
leaq 0x30bb(%rip), %rdx      # 0x9536
callq 0x6662
testq %rax, %rax
jne 0x6489
movb $0x0, 0x14(%rbx)
addq $0x180, %rsp            # imm = 0x180
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/quiet.cpp
// Function: Quiet::action[abi:cxx11]()
std::string Quiet::action() {
	cout << "You notice " << quietItem << " nearby." << endl;
	cout << "Would you like to use it for some peace and quiet?" << endl;
	cout << "1. Yes, it's a good time for me to relax." << endl;
	cout << "2. No, that sounds like a bad idea." << endl;

	return Space::action();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x9fee(%rip), %r15      # 0x10fd0
leaq 0x5253(%rip), %rsi      # 0xc23c
movq %r15, %rdi
callq 0x21a0
leaq 0x80(%r14), %rsi
movq %rax, %rdi
callq 0x2170
leaq 0x5241(%rip), %rsi      # 0xc248
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x5233(%rip), %rsi      # 0xc251
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x524f(%rip), %rsi      # 0xc284
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x5262(%rip), %rsi      # 0xc2ae
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x791e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/satchel.cpp
// Function: Satchel::clearContents()
void Satchel::clearContents() {
	candlestick = rope = revolver = pipe = knife = wrench = false;
	numUniqueWeapons = 0;
	cout << "Uh oh! You dropped your satchel, butterfingers!" << endl;
	cout << "Someone might be coming." << endl;
	cout << "Pick up your satchel and forget the weapons." << endl;
	cout << "Hydra will take care of them." << endl;
	cout << "\nPress enter to pick up your satchel and hide." << endl;
	getchar();
	cout << "The footsteps you heard fade away. Phew!" << endl;
	cout << "Unfortunately, however, your satchel is now empty.\n" << endl;
}

// Assembly:
pushq %rbx
andw $0x0, 0x14(%rdi)
andq $0x0, 0xc(%rdi)
movq 0x9e8e(%rip), %rbx      # 0x10fd0
leaq 0x51bb(%rip), %rsi      # 0xc304
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x51d4(%rip), %rsi      # 0xc334
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x51d6(%rip), %rsi      # 0xc34d
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x51ec(%rip), %rsi      # 0xc37a
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x51f3(%rip), %rsi      # 0xc398
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
callq 0x2220
leaq 0x5206(%rip), %rsi      # 0xc3c7
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x5218(%rip), %rsi      # 0xc3f0
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
popq %rbx
jmp 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/satchel.cpp
// Function: Satchel::getNumUniqueWeapons()
int Satchel::getNumUniqueWeapons() {
	// Reset unique weapon count
	numUniqueWeapons = 0;

	if (knife) {
		numUniqueWeapons++;
	}
	if (wrench) {
		numUniqueWeapons++;
	}
	if (rope) {
		numUniqueWeapons++;
	}
	if (pipe) {
		numUniqueWeapons++;
	}
	if (revolver) {
		numUniqueWeapons++;
	}
	if (candlestick) {
		numUniqueWeapons++;
	}
	return numUniqueWeapons;
}

// Assembly:
movzbl 0x10(%rdi), %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x13(%rdi)
jne 0x71fc
incl %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x11(%rdi)
jne 0x7207
incl %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x15(%rdi)
jne 0x7212
incl %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x12(%rdi)
jne 0x721d
incl %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x14(%rdi)
jne 0x7228
incl %eax
movl %eax, 0xc(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/space.cpp
// Function: Space::Space()
Space::Space() {
	name = "default";
	weapon = "default";
	top = right = left = bottom = corner = nullptr;
	newMove = nullptr;
	cornerAccess = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x9af1(%rip), %rax      # 0x10d30
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x2308(%rip), %rsi      # 0x957b
movq %rbx, %rdi
callq 0x22b0
leaq 0x22f9(%rip), %rsi      # 0x957b
movq %r15, %rdi
callq 0x22b0
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x48(%r14)
movb $0x0, 0x78(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/space.cpp
// Function: Space::Space(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Space::Space(string nameIn, string weaponIn) {
	name = nameIn;
	weapon = weaponIn;
	top = right = left = bottom = corner = nullptr;
	newMove = nullptr;
	cornerAccess = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
leaq 0x9a59(%rip), %rax      # 0x10d30
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rbx, %rdi
callq 0x20e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x48(%r14)
movb $0x0, 0x78(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/space.cpp
// Function: Space::action[abi:cxx11]()
std::string Space::action() {
	string received;

	int actionChoice = intValidation(1, 2);

	switch (actionChoice) {
		case 1:
			// User made the "wrong" choice and does not receive a weapon
			received = "none";
			break;
		case 2:
			// Return the string of the weapon that the current Space includes
			received = weapon;
			break;
		default:
			break;
	}

	return received;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
callq 0x798c
cmpl $0x1, %eax
je 0x795e
cmpl $0x2, %eax
jne 0x796d
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20e0
jmp 0x796d
leaq 0x206c(%rip), %rsi      # 0x99d1
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/space.cpp
// Function: Space::intValidation(int, int)
int Space::intValidation(int min, int max) {
	cout << "Make your choice: ";

	int input;
	cin >> input;

	// Try again if input is out of range or fails
	while (input < min || input > max || cin.fail()) {
		cout << "Input must be an integer between " << min << " and "
		     << max << "." << endl;
		cout << "Please try again: ";
		cin.clear();
		cin.ignore(256, '\n');
		cin >> input;
	}

	// Flush buffer after successful input
	cin.clear();
	cin.ignore(256, '\n');

	return input;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq 0x962e(%rip), %r14      # 0x10fd0
leaq 0x3f65(%rip), %rsi      # 0xb90e
movq %r14, %rdi
callq 0x21a0
movq 0x9628(%rip), %r15      # 0x10fe0
leaq 0x3ca0(%rip), %r13      # 0xb65f
pushq $0xa
popq %r12
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
callq 0x20f0
movl 0x4(%rsp), %eax
cmpl %ebp, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0x79f1
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
je 0x7a6b
movq %r14, %rdi
leaq 0x3c3c(%rip), %rsi      # 0xb637
callq 0x21a0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2280
movq %rax, %rdi
leaq 0x3c45(%rip), %rsi      # 0xb659
callq 0x21a0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2280
movq %rax, %rdi
leaq 0x25d3(%rip), %rsi      # 0xa000
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
movq %r14, %rdi
movq %r13, %rsi
callq 0x21a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x2270
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movl %r12d, %edx
callq 0x2100
jmp 0x79c3
addq %rax, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2270
movq 0x9561(%rip), %rdi      # 0x10fe0
pushq $0xa
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x2100
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/vectorSatchel.cpp
// Function: VectorSatchel::randomDrop()
void VectorSatchel::randomDrop() {
	// Randomly shuffle the contents of vector
	std::random_shuffle(satchel.begin(),satchel.end());

	cout << "A " << satchel.back() << " has been selected at random for you "
												 "to drop." << endl;

	// Delete last element
	satchel.pop_back();

	// Update weapon status after one was deleted
	updateWeapons();

	// Print current weapons
	cout << "Your current weapon list is:" << endl;
	printWeapons();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rsi
callq 0x7f0e
movq 0x9280(%rip), %r15      # 0x10fd0
leaq 0x49f5(%rip), %rsi      # 0xc74c
movq %r15, %rdi
callq 0x21a0
movq 0x20(%rbx), %rsi
addq $-0x20, %rsi
movq %rax, %rdi
callq 0x2170
leaq 0x49d9(%rip), %rsi      # 0xc74f
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x7f6e
movq %rbx, %rdi
callq 0x7dbc
leaq 0x43d8(%rip), %rsi      # 0xc175
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/angelapwen[P]text-based-game/vectorSatchel.cpp
// Function: VectorSatchel::updateWeapons()
void VectorSatchel::updateWeapons() {
	// Sort bag for binary search
	std::sort(satchel.begin(),satchel.end());

	// Search for each weapon type in bag and set bool flag to false if not found
	if (!std::binary_search(satchel.begin(),satchel.end(),"knife")) {
		knife = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"wrench")) {
		wrench = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"rope")) {
		rope = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"pipe")) {
		pipe = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"revolver")) {
		revolver = false;
	}
	if (!std::binary_search(satchel.begin(),satchel.end(),"candlestick")) {
		candlestick = false;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rsi
callq 0x82a2
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x1768(%rip), %rdx      # 0x9544
callq 0x7f82
testb %al, %al
jne 0x7de9
movb $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x1766(%rip), %rdx      # 0x955e
callq 0x7faf
testb %al, %al
jne 0x7e05
movb $0x0, 0x13(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x1743(%rip), %rdx      # 0x9557
callq 0x7fdc
testb %al, %al
jne 0x7e21
movb $0x0, 0x11(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x1737(%rip), %rdx      # 0x9567
callq 0x7fdc
testb %al, %al
jne 0x7e3d
movb $0x0, 0x15(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x1700(%rip), %rdx      # 0x954c
callq 0x8009
testb %al, %al
jne 0x7e59
movb $0x0, 0x12(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x16ce(%rip), %rdx      # 0x9536
callq 0x8036
testb %al, %al
jne 0x7e75
movb $0x0, 0x14(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/robin_hood/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	robin_hood::unordered_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
#ifndef UDB2_TEST_DEL
		z += ++h[get_key(n, x)];
#else
		auto p = h.try_emplace(get_key(n, x), i);
		if (p.second == false) h.erase(p.first);
#endif
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movl %edi, %ebx
movabsq $-0x3b314601e57a13ad, %rax # imm = 0xC4CEB9FE1A85EC53
leaq 0x40(%rsp), %rcx
movq %rax, -0x20(%rcx)
movq %rcx, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rcx)
movq $0x20, 0x10(%rcx)
xorl %eax, %eax
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x4(%rsp), %r12
movq %rsp, %r13
movl %eax, (%rsp)
cmpl %ebx, %eax
jae 0x155e
movl %ebp, %edi
callq 0x124c
movl %eax, %ebp
movl %ebx, %edi
movl %eax, %esi
callq 0x1277
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1620
cmpb $0x0, 0x18(%rsp)
jne 0x1557
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x15b2
movl (%rsp), %eax
incl %eax
jmp 0x1510
movq 0x2a7b(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0x20(%rsp), %rbx
movq 0x18(%rbx), %rdx
leaq 0xb0d(%rip), %rsi       # 0x2085
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x10d0
movl 0x18(%rbx), %ebp
movq %rbx, %rdi
callq 0x1602
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1602
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::erase(robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::Iter<false>)
iterator erase(iterator pos) {
        ROBIN_HOOD_TRACE(this)
        // we assume that pos always points to a valid entry, and not end().
        auto const idx = static_cast<size_t>(pos.mKeyVals - mKeyVals);

        shiftDown(idx);
        --mNumElements;

        if (*pos.mInfo) {
            // we've backward shifted, return this again
            return pos;
        }

        // no backward shift, return next element
        return ++pos;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
subq 0x8(%rdi), %rsi
sarq $0x3, %rsi
callq 0x1d18
decq 0x18(%r15)
cmpb $0x0, (%rbx)
jne 0x15f2
movq %rsp, %rdi
callq 0x1d4a
movq (%rax), %r14
movq 0x8(%rax), %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq