LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1f9f
leaq 0x3ed5(%rip), %rdi      # 0x60e0
callq 0x12d4
testq %rbx, %rbx
jle 0x231d
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x30(%rsp), %xmm3
movss 0x40(%rsp), %xmm5
movss 0x14(%rsp), %xmm1
movss 0x18(%rsp), %xmm10
movss 0x34(%rsp), %xmm2
movss 0x44(%rsp), %xmm4
movss 0x28(%rsp), %xmm11
movss 0x48(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x1c(%rsp), %xmm8
movss 0x2c(%rsp), %xmm7
movss 0x3c(%rsp), %xmm6
movss 0x8(%rsp), %xmm0
movaps %xmm3, %xmm13
movaps %xmm5, %xmm9
movss %xmm1, 0x8(%rsp)
movaps %xmm2, %xmm15
movaps %xmm4, %xmm12
movaps %xmm10, %xmm3
movaps %xmm11, %xmm2
movss 0xc(%rsp), %xmm14
movaps %xmm8, %xmm5
movaps %xmm7, %xmm4
movss %xmm6, 0xc(%rsp)
movaps %xmm14, %xmm6
movaps %xmm12, %xmm7
movaps %xmm9, %xmm8
movaps %xmm15, %xmm11
movaps %xmm13, %xmm10
movaps %xmm0, %xmm1
decq %rbx
jne 0x2270
movss 0x8(%rsp), %xmm1
movss %xmm1, 0x20(%rsp)
movss %xmm3, 0x30(%rsp)
movss %xmm5, 0x40(%rsp)
movss %xmm0, 0x14(%rsp)
movss %xmm2, 0x34(%rsp)
movss %xmm4, 0x44(%rsp)
movss %xmm13, 0x18(%rsp)
movss %xmm15, 0x28(%rsp)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x48(%rsp)
movss %xmm9, 0x1c(%rsp)
movss %xmm12, 0x2c(%rsp)
movss %xmm14, 0x3c(%rsp)
leaq 0x3dbc(%rip), %rdi      # 0x60e0
callq 0x12e6
callq 0x1040
testl %eax, %eax
jne 0x23c9
callq 0x1040
movl %eax, %ebx
callq 0x1040
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
js 0x23da
movslq %ebx, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rsp, %rcx
addq $0x10, %rcx
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movq 0x3c3e(%rip), %rdi      # 0x5fd8
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x3d10(%rip), %rdi      # 0x60e0
addq $0x50, %rsp
popq %rbx
jmp 0x1350
leaq 0x1e76(%rip), %rdi      # 0x4257
leaq 0x1ea7(%rip), %rsi      # 0x428f
leaq 0x1ebb(%rip), %rcx      # 0x42aa
movl $0x2c, %edx
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rsp, %rdi
callq 0x1f9f
leaq 0x3cc9(%rip), %rdi      # 0x60e0
callq 0x12d4
testq %rbx, %rbx
jle 0x2460
leaq 0x40(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b6c
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)
decq %rbx
jne 0x2429
leaq 0x3c79(%rip), %rdi      # 0x60e0
callq 0x12e6
callq 0x1040
testl %eax, %eax
jne 0x2508
callq 0x1040
movl %eax, %ebx
callq 0x1040
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
js 0x2521
movslq %ebx, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rsp, %rcx
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movq 0x3aff(%rip), %rdi      # 0x5fd8
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x3bd1(%rip), %rdi      # 0x60e0
callq 0x1350
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1d2f(%rip), %rdi      # 0x4257
leaq 0x1d60(%rip), %rsi      # 0x428f
leaq 0x1d74(%rip), %rcx      # 0x42aa
movl $0x2c, %edx
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x1f9f
movups 0x4(%r14), %xmm0
movups 0x14(%r14), %xmm1
movss 0x28(%r14), %xmm2
movss 0x10(%r14), %xmm3
shufps $0xd4, %xmm0, %xmm3     # xmm3 = xmm3[0,1],xmm0[1,3]
unpcklpd (%r14), %xmm0           # xmm0 = xmm0[0],mem[0]
shufps $0x22, %xmm3, %xmm0     # xmm0 = xmm0[2,0],xmm3[2,0]
movaps %xmm0, (%rsp)
unpcklpd 0x20(%r14), %xmm1       # xmm1 = xmm1[0],mem[0]
movaps %xmm1, 0x10(%rsp)
movss %xmm2, 0x20(%rsp)
leaq 0x3b45(%rip), %rdi      # 0x60e0
callq 0x12d4
testq %rbx, %rbx
jle 0x25dc
leaq 0x30(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3012
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
movss 0x50(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
decq %rbx
jne 0x25ad
leaq 0x3afd(%rip), %rdi      # 0x60e0
callq 0x12e6
callq 0x1040
testl %eax, %eax
jne 0x2689
callq 0x1040
movl %eax, %ebx
callq 0x1040
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
js 0x26a2
movslq %ebx, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rsp,%rcx,4), %rcx
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movq 0x397e(%rip), %rdi      # 0x5fd8
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x3a50(%rip), %rdi      # 0x60e0
callq 0x1350
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1bae(%rip), %rdi      # 0x4257
leaq 0x1bc4(%rip), %rsi      # 0x4274
leaq 0x1c4e(%rip), %rcx      # 0x4305
movl $0x2c, %edx
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1f9f
leaq 0x3a06(%rip), %rdi      # 0x60e0
callq 0x12d4
testq %rbx, %rbx
jle 0x2734
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x30(%rsp), %xmm3
movaps 0x40(%rsp), %xmm4
movaps 0x1a51(%rip), %xmm0     # 0x4150
movaps %xmm0, %xmm5
shufps $0x0, %xmm0, %xmm5      # xmm5 = xmm5[0,0],xmm0[0,0]
mulps %xmm1, %xmm5
movaps %xmm0, %xmm6
shufps $0x55, %xmm0, %xmm6     # xmm6 = xmm6[1,1],xmm0[1,1]
mulps %xmm2, %xmm6
addps %xmm5, %xmm6
movaps %xmm0, %xmm5
shufps $0xaa, %xmm0, %xmm5     # xmm5 = xmm5[2,2],xmm0[2,2]
mulps %xmm3, %xmm5
shufps $0xff, %xmm0, %xmm0     # xmm0 = xmm0[3,3,3,3]
mulps %xmm4, %xmm0
addps %xmm5, %xmm0
addps %xmm6, %xmm0
decq %rbx
jne 0x26ff
jmp 0x273b
movaps 0x1a15(%rip), %xmm0     # 0x4150
movaps %xmm0, (%rsp)
leaq 0x399a(%rip), %rdi      # 0x60e0
callq 0x12e6
callq 0x1040
testl %eax, %eax
jne 0x27a8
callq 0x1040
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x4, %ecx
subl %ecx, %eax
js 0x27b9
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rsp,%rax,4), %xmm0
movq 0x385f(%rip), %rdi      # 0x5fd8
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x3931(%rip), %rdi      # 0x60e0
addq $0x50, %rsp
popq %rbx
jmp 0x1350
leaq 0x1a97(%rip), %rdi      # 0x4257
leaq 0x1ac8(%rip), %rsi      # 0x428f
leaq 0x1adc(%rip), %rcx      # 0x42aa
movl $0x2c, %edx
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x38d5(%rip), %ebp      # 0x60c0
testl %ebp, %ebp
jle 0x2863
movq %rdi, %r14
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorpd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x38b3(%rip), %rdi      # 0x60c8
callq *%r14
testl %r15d, %r15d
je 0x2837
movapd %xmm0, %xmm2
minsd 0x10(%rsp), %xmm2
ucomisd 0x8(%rsp), %xmm0
jbe 0x2841
movsd %xmm0, 0x8(%rsp)
jmp 0x2841
movsd %xmm0, 0x8(%rsp)
movapd %xmm0, %xmm2
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incl %r15d
movl 0x3868(%rip), %ebp      # 0x60c0
movapd %xmm2, %xmm1
cmpl %ebp, %r15d
jl 0x2808
jmp 0x2876
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm2, %xmm2
movsd %xmm0, (%rsp)
movsd %xmm2, 0x10(%rsp)
testq %rbx, %rbx
je 0x289d
movq %rbx, %rdi
callq 0x1050
movq 0x3748(%rip), %rdi      # 0x5fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x10e0
jmp 0x28bb
movq 0x3734(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x1130
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq 0x3701(%rip), %rbx      # 0x5fd8
leaq 0x1892(%rip), %rsi      # 0x4170
movl $0x8, %edx
movq %rbx, %rdi
callq 0x10e0
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x1110
movq %rax, %rbx
leaq 0x1877(%rip), %rsi      # 0x4179
movl $0x9, %edx
movq %rax, %rdi
callq 0x10e0
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x1110
movq %rax, %rbx
leaq 0x185c(%rip), %rsi      # 0x4183
movl $0x9, %edx
movq %rax, %rdi
callq 0x10e0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1110
movq %rax, %rbx
leaq 0x1841(%rip), %rsi      # 0x418d
movl $0x2, %edx
movq %rax, %rdi
callq 0x10e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
xorl %edi, %edi
callq 0x2160
movl %eax, %edi
callq 0x2170
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x35f0
movq %rbx, %rdi
callq 0x447c
leaq 0x8(%rsp), %rbx
leaq 0x98(%rsp), %r14
movq %rbx, %rdi
callq 0x795e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x751a
cmpl $0x1, %eax
je 0x261c
cmpl $0x2, %eax
jne 0x25f6
jmp 0x2636
movq %r14, %rdi
callq 0x35f0
movq %r14, %rdi
callq 0x447c
movq %r14, %rdi
callq 0x7a8e
jmp 0x25f6
leaq 0x8(%rsp), %rdi
callq 0x7a8e
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
jmp 0x2663
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x7a8e
jmp 0x2666
jmp 0x2663
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7a8e
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x14(%rdi)
jne 0x2cb7
movq 0x12354(%rip), %r14     # 0x14fd0
leaq 0xa8b1(%rip), %rsi      # 0xd534
movl $0xd, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x10(%rbx)
jne 0x2cff
movq 0x1230c(%rip), %r14     # 0x14fd0
leaq 0xa877(%rip), %rsi      # 0xd542
movl $0x7, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x12(%rbx)
jne 0x2d47
movq 0x122c4(%rip), %r14     # 0x14fd0
leaq 0xa837(%rip), %rsi      # 0xd54a
movl $0xa, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x11(%rbx)
jne 0x2d8f
movq 0x1227c(%rip), %r14     # 0x14fd0
leaq 0xa7fa(%rip), %rsi      # 0xd555
movl $0x6, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x13(%rbx)
jne 0x2dd7
movq 0x12234(%rip), %r14     # 0x14fd0
leaq 0xa7b9(%rip), %rsi      # 0xd55c
movl $0x8, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x15(%rbx)
jne 0x2e26
movq 0x121ec(%rip), %rbx     # 0x14fd0
leaq 0xa77a(%rip), %rsi      # 0xd565
movl $0x6, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x11fad(%rip), %r15     # 0x14fd0
leaq 0xa559(%rip), %rsi      # 0xd583
movl $0x15, %edx
movq %r15, %rdi
callq 0x21c0
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
movq %r15, %rdi
callq 0x21c0
movq %rax, %r12
leaq 0xb01d(%rip), %rsi      # 0xe074
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa506(%rip), %rsi      # 0xd599
movl $0x1a, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa4e6(%rip), %rsi      # 0xd5b4
movl $0x28, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa4d4(%rip), %rsi      # 0xd5dd
movl $0x26, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movq %r14, %rsi
callq 0xabf6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x11b8d(%rip), %r15     # 0x14fd0
leaq 0xa139(%rip), %rsi      # 0xd583
movl $0x15, %edx
movq %r15, %rdi
callq 0x21c0
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
movq %r15, %rdi
callq 0x21c0
movq %rax, %r12
leaq 0xabfd(%rip), %rsi      # 0xe074
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa0e6(%rip), %rsi      # 0xd599
movl $0x1a, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa145(%rip), %rsi      # 0xd633
movl $0x22, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa12d(%rip), %rsi      # 0xd656
movl $0x41, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movq %r14, %rsi
callq 0xabf6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdaaf(%rip), %rbx      # 0x14fe0
movq 0xda98(%rip), %r12      # 0x14fd0
leaq 0x8194(%rip), %r13      # 0xf6d3
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
callq 0x20d0
movl 0x4(%rsp), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebp, %eax
setg %al
orb %cl, %al
jne 0x7571
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x7627
movl $0x21, %edx
movq %r12, %rdi
leaq 0x812b(%rip), %rsi      # 0xf6ab
callq 0x21c0
movq %r12, %rdi
movl %r14d, %esi
callq 0x2260
movq %rax, %r15
movl $0x5, %edx
movq %rax, %rdi
leaq 0x812b(%rip), %rsi      # 0xf6cd
callq 0x21c0
movq %r15, %rdi
movl %ebp, %esi
callq 0x2260
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x6ab1(%rip), %rsi      # 0xe074
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0x12, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2250
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20e0
jmp 0x753f
addq %rax, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2250
movq 0xd9a5(%rip), %rdi      # 0x14fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
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_O3/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 0x7aa1
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rdi
movl $0x591, %esi            # imm = 0x591
callq 0x21a0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x7abd
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x7acc
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x7adb
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x7aea
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x7af9
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x7b08
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x7b17
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x7b26
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x7b35
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x68(%rbx), %rdi
addq $0x78, %rbx
cmpq %rbx, %rdi
je 0x7b4e
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x21a0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %ecx, %ecx
cmpb $0x2a, (%rdi,%rcx)
jne 0x8a12
movb $0x20, (%rdi,%rcx)
incq %rcx
cmpq $0x39, %rcx
jne 0x8a08
incq %rax
addq $0x39, %rdi
cmpq $0x19, %rax
jne 0x8a06
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %r12d, %r12d
movq 0xc3dc(%rip), %rbx      # 0x14fd0
leaq 0xf(%rsp), %r15
movq $-0x39, %r13
movb 0x39(%r14,%r13), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21c0
incq %r13
jne 0x8c00
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
incq %r12
addq $0x39, %r14
cmpq $0x19, %r12
jne 0x8bf9
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb1fd(%rip), %r15      # 0x14fd0
leaq 0x64ac(%rip), %rsi      # 0x10286
movl $0xb, %edx
movq %r15, %rdi
callq 0x21c0
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
movq %r15, %rdi
callq 0x21c0
movq %rax, %r12
leaq 0x648b(%rip), %rsi      # 0x10292
movl $0x8, %edx
movq %rax, %rdi
callq 0x21c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6458(%rip), %rsi      # 0x1029b
movl $0x32, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6450(%rip), %rsi      # 0x102ce
movl $0x29, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x643f(%rip), %rsi      # 0x102f8
movl $0x23, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movq %r14, %rsi
callq 0xabf6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movw $0x0, 0x14(%rdi)
movq $0x0, 0xc(%rdi)
movq 0xaf7a(%rip), %rbx      # 0x14fd0
leaq 0x62f1(%rip), %rsi      # 0x1034e
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x62e6(%rip), %rsi      # 0x1037e
movl $0x18, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x62c4(%rip), %rsi      # 0x10397
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x62b6(%rip), %rsi      # 0x103c4
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6299(%rip), %rsi      # 0x103e2
movl $0x2e, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
callq 0x21f0
leaq 0x6288(%rip), %rsi      # 0x10411
movl $0x28, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6276(%rip), %rsi      # 0x1043a
movl $0x33, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa20c
incl %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x11(%rdi)
jne 0xa217
incl %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x15(%rdi)
jne 0xa222
incl %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x12(%rdi)
jne 0xa22d
incl %eax
movl %eax, 0xc(%rdi)
cmpb $0x1, 0x14(%rdi)
jne 0xa238
incl %eax
movl %eax, 0xc(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0xaadd(%rip), %rax      # 0x14d30
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r14
movq %r14, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x32f6(%rip), %rcx      # 0xd57b
movl $0x7, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
movq 0x30(%r15), %rdx
leaq 0x32d9(%rip), %rcx      # 0xd57b
movl $0x7, %r8d
movq %r12, %rdi
xorl %esi, %esi
callq 0x2220
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r15)
movups %xmm0, 0x58(%r15)
movups %xmm0, 0x48(%r15)
movb $0x0, 0x78(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0xa2eb
movq (%r13), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22b1
movq %r15, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x1, %esi
movl $0x2, %edx
callq 0xac80
cmpl $0x1, %eax
je 0xac3e
cmpl $0x2, %eax
jne 0xac59
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20c0
jmp 0xac59
movq 0x8(%rbx), %rdx
leaq 0x2dfc(%rip), %rcx      # 0xda45
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2220
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xac78
movq (%r15), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa33a(%rip), %r14      # 0x14fd0
leaq 0x4ce5(%rip), %rsi      # 0xf982
movl $0x12, %edx
movq %r14, %rdi
callq 0x21c0
movq 0xa32f(%rip), %r15      # 0x14fe0
leaq 0x4a1b(%rip), %r13      # 0xf6d3
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
callq 0x20d0
movl 0x4(%rsp), %eax
cmpl %ebp, %eax
setl %cl
cmpl %ebx, %eax
setg %al
orb %cl, %al
jne 0xacea
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
je 0xada0
movl $0x21, %edx
movq %r14, %rdi
leaq 0x49b2(%rip), %rsi      # 0xf6ab
callq 0x21c0
movq %r14, %rdi
movl %ebp, %esi
callq 0x2260
movq %rax, %r12
movl $0x5, %edx
movq %rax, %rdi
leaq 0x49b3(%rip), %rsi      # 0xf6cd
callq 0x21c0
movq %r12, %rdi
movl %ebx, %esi
callq 0x2260
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3339(%rip), %rsi      # 0xe074
callq 0x21c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0x12, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x2250
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movl $0xa, %edx
callq 0x20e0
jmp 0xacb8
addq %rax, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2250
movq 0xa22c(%rip), %rdi      # 0x14fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
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_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0xb236
leaq 0x20(%r14), %rax
cmpq %r15, %rax
je 0xb236
movl $0x20, %r12d
callq 0x2050
cltq
movq %r12, %rcx
sarq $0x5, %rcx
incq %rcx
cqto
idivq %rcx
shlq $0x5, %rdx
cmpq %rdx, %r12
je 0xb225
leaq (%r14,%r12), %rdi
addq %r14, %rdx
movq %rdx, %rsi
callq 0x2120
leaq (%r14,%r12), %rax
addq $0x20, %rax
addq $0x20, %r12
cmpq %r15, %rax
jne 0xb1f7
movq 0x9d93(%rip), %r14      # 0x14fd0
leaq 0x5552(%rip), %rsi      # 0x10796
movl $0x2, %edx
movq %r14, %rdi
callq 0x21c0
movq 0x20(%rbx), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq %r14, %rdi
callq 0x21c0
movq %rax, %r15
leaq 0x552a(%rip), %rsi      # 0x10799
movl $0x2d, %edx
movq %rax, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x20(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x20(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0xb2c7
movq (%rax), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0xb31e
leaq 0x4ee9(%rip), %rsi      # 0x101bf
movl $0x1c, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x8(%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r14
cmpq %r14, %r15
je 0xb368
movq %r14, %rax
subq %r15, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb895
movq %r15, %rdi
movq %r14, %rsi
callq 0xb969
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r14
leaq 0x21d5(%rip), %rdx      # 0xd544
movq %r15, %rdi
movq %r14, %rsi
callq 0xb4ed
testb %al, %al
jne 0xb382
movb $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x21cd(%rip), %rdx      # 0xd55e
callq 0xb51d
testb %al, %al
jne 0xb39e
movb $0x0, 0x13(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x21aa(%rip), %rdx      # 0xd557
callq 0xb54d
testb %al, %al
jne 0xb3ba
movb $0x0, 0x11(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x219e(%rip), %rdx      # 0xd567
callq 0xb54d
testb %al, %al
jne 0xb3d6
movb $0x0, 0x15(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x2167(%rip), %rdx      # 0xd54c
callq 0xb57d
testb %al, %al
jne 0xb3f2
movb $0x0, 0x12(%rbx)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x2135(%rip), %rdx      # 0xd536
callq 0xb5ad
testb %al, %al
jne 0xb40e
movb $0x0, 0x14(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movabsq $-0x3b314601e57a13ad, %rax # imm = 0xC4CEB9FE1A85EC53
leaq 0x28(%rsp), %r15
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq %r15, -0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%r15)
movq $0x0, 0x8(%r15)
movq $0x20, 0x10(%r15)
movl $0x0, (%rsp)
testl %edi, %edi
jne 0x15c6
xorl %edx, %edx
jmp 0x1682
movl %esi, %ebp
movl %edi, %r14d
movl %edi, %ebx
shrl $0x2, %ebx
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movq %rsp, %r13
movl %ebp, %eax
shll $0xf, %eax
notl %eax
addl %ebp, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ebp
shrl $0x10, %ebp
xorl %eax, %ebp
movl %ebp, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
xorl %eax, %ecx
movl %ecx, 0x4(%rsp)
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1774
cmpb $0x0, 0x50(%rsp)
jne 0x1667
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %r15, %rdi
callq 0x1702
movl (%rsp), %eax
incl %eax
movl %eax, (%rsp)
cmpl %r14d, %eax
jb 0x15dd
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %r15
movq 0x2957(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0x9e2(%rip), %rsi       # 0x2075
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x10d0
movq 0x20(%rsp), %rbx
cmpq $0x0, 0x28(%rsp)
je 0x16c1
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x16c1
callq 0x10a0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpq $0x0, 0x28(%rsp)
je 0x16fa
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x16fa
callq 0x10a0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
subq 0x8(%rdi), %rsi
sarq $0x3, %rsi
callq 0x1e8e
decq 0x18(%r15)
cmpb $0x0, (%r14)
jne 0x1768
addq $0x8, %rbx
movq 0x1(%r14), %rax
testq %rax, %rax
je 0x1739
incq %r14
jmp 0x1751
addq $0x9, %r14
addq $0x40, %rbx
movq (%r14), %rax
addq $0x8, %r14
testq %rax, %rax
je 0x173d
addq $-0x8, %r14
movq %r14, %rcx
bsfq %rax, %rax
movl %eax, %r14d
shrl $0x3, %r14d
addq %rcx, %r14
andl $-0x8, %eax
addq %rax, %rbx
movq %rbx, %rax
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: std::pair<robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::Iter<false>, bool> robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::try_emplace_impl<unsigned int, unsigned int&>(unsigned int&&, unsigned int&)
std::pair<iterator, bool> try_emplace_impl(OtherKey&& key, Args&&... args) {
        ROBIN_HOOD_TRACE(this)
        auto idxAndState = insertKeyPrepareEmptySpot(key);
        switch (idxAndState.second) {
        case InsertionState::key_found:
            break;

        case InsertionState::new_node:
            ::new (static_cast<void*>(&mKeyVals[idxAndState.first])) Node(
                *this, std::piecewise_construct, std::forward_as_tuple(std::forward<OtherKey>(key)),
                std::forward_as_tuple(std::forward<Args>(args)...));
            break;

        case InsertionState::overwrite_node:
            mKeyVals[idxAndState.first] = Node(*this, std::piecewise_construct,
                                               std::forward_as_tuple(std::forward<OtherKey>(key)),
                                               std::forward_as_tuple(std::forward<Args>(args)...));
            break;

        case InsertionState::overflow_error:
            throwOverflowError();
            break;
        }

        return std::make_pair(iterator(mKeyVals + idxAndState.first, mInfo + idxAndState.first),
                              InsertionState::key_found != idxAndState.second);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1814
movq %rax, %r15
movl %edx, %ebp
testl %edx, %edx
je 0x17d9
cmpl $0x3, %ebp
je 0x17c0
cmpl $0x2, %ebp
jne 0x17e1
movq 0x8(%r14), %rax
movl (%r13), %ecx
movl %ecx, (%rax,%r15,8)
movl (%r12), %ecx
movl %ecx, 0x4(%rax,%r15,8)
jmp 0x17e1
movl (%r13), %eax
movq 0x8(%r14), %rcx
movl (%r12), %edx
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, (%rcx,%r15,8)
jmp 0x17e1
movq %r14, %rdi
callq 0x1936
movq %r15, %rax
shlq $0x3, %rax
addq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
addq %r15, %rcx
cmpl $0x1, %ebp
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
setne 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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>>::increase_size()
bool increase_size() {
        // nothing allocated yet? just allocate InitialNumElements
        if (0 == mMask) {
            initData(InitialNumElements);
            return true;
        }

        auto const maxNumElementsAllowed = calcMaxNumElementsAllowed(mMask + 1);
        if (mNumElements < maxNumElementsAllowed && try_increase_info()) {
            return true;
        }

        ROBIN_HOOD_LOG("mNumElements=" << mNumElements << ", maxNumElementsAllowed="
                                       << maxNumElementsAllowed << ", load="
                                       << (static_cast<double>(mNumElements) * 100.0 /
                                           (static_cast<double>(mMask) + 1)))

        if (mNumElements * 2 < calcMaxNumElementsAllowed(mMask + 1)) {
            // we have to resize, even though there would still be plenty of space left!
            // Try to rehash instead. Delete freed memory so we don't steadyily increase mem in case
            // we have to rehash a few times
            nextHashMultiplier();
            rehashPowerOfTwo(mMask + 1, true);
        } else {
            // we've reached the capacity of the map, so the hash seems to work nice. Keep using it.
            rehashPowerOfTwo((mMask + 1) * 2, false);
        }
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x1a27
movabsq $0x28f5c28f5c28f5c, %r15 # imm = 0x28F5C28F5C28F5C
leaq 0x1(%rcx), %rsi
movabsq $0x28f5c28f5c28f5c3, %r14 # imm = 0x28F5C28F5C28F5C3
movq %rsi, %rax
cmpq %r15, %rsi
ja 0x1a50
shlq $0x4, %rax
leaq (%rax,%rax,4), %rax
shrq $0x2, %rax
mulq %r14
shrq $0x2, %rdx
movq 0x18(%rbx), %rdi
cmpq %rdx, %rdi
jae 0x19ed
movq %rbx, %rdi
callq 0x1bbc
testb %al, %al
jne 0x1a48
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rcx
leaq 0x1(%rcx), %rsi
addq %rdi, %rdi
movq %rsi, %rax
cmpq %r15, %rsi
ja 0x1a68
shlq $0x4, %rax
leaq (%rax,%rax,4), %rax
shrq $0x2, %rax
mulq %r14
shrq $0x2, %rdx
cmpq %rdx, %rdi
jae 0x1a36
movabsq $-0x3b314601e57a13ac, %rax # imm = 0xC4CEB9FE1A85EC54
addq %rax, (%rbx)
movq %rbx, %rdi
movl $0x1, %edx
jmp 0x1a43
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1aea
jmp 0x1a48
leaq 0x2(,%rcx,2), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1ca0
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
shrq $0x2, %rax
mulq %r14
shlq $0x2, %rdx
andq $-0x10, %rdx
leaq (%rdx,%rdx,4), %rdx
jmp 0x19cc
shrq $0x2, %rax
mulq %r14
shlq $0x2, %rdx
andq $-0x10, %rdx
leaq (%rdx,%rdx,4), %rdx
jmp 0x1a0b
nop