LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/stream.cpp
// Function: utf8stream::readbuf(unsigned long)
bool readbuf(size_t size = BUFSIZE)
    {
        if(bufread >= bufcarry) { if(bufcarry > 0 && bufcarry < buflen) memmove(buf, &buf[bufcarry], buflen - bufcarry); buflen -= bufcarry; bufread = bufcarry = 0; }
        size_t n = file->read(&buf[buflen], min(size, BUFSIZE - buflen));
        if(n <= 0) return false;
        buflen += n;
        size_t carry = bufcarry;
        bufcarry += decodeutf8(&buf[bufcarry], BUFSIZE-bufcarry, &buf[bufcarry], buflen-bufcarry, &carry);
        if(carry > bufcarry && carry < buflen) { memmove(&buf[bufcarry], &buf[carry], buflen - carry); buflen -= carry - bufcarry; }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %r15
cmpq %r15, 0x18(%rdi)
jb 0x1516f
leaq 0x18(%rbx), %r12
testq %r15, %r15
je 0x15163
movq 0x28(%rbx), %rdx
subq %r15, %rdx
jbe 0x15163
leaq 0x33(%rbx), %rdi
leaq (%rbx,%r15), %rsi
addq $0x33, %rsi
callq 0x2340
subq %r15, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rax
leaq (%rbx,%rax), %rsi
addq $0x33, %rsi
movl $0x1000, %r12d          # imm = 0x1000
movl $0x1000, %edx           # imm = 0x1000
subq %rax, %rdx
cmpq %rdx, %r14
cmovbq %r14, %rdx
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %r14
testq %rax, %rax
je 0x1520b
leaq 0x33(%rbx), %r15
movq 0x28(%rbx), %rcx
addq %r14, %rcx
movq %rcx, 0x28(%rbx)
movq 0x20(%rbx), %rax
leaq -0x30(%rbp), %r13
movq %rax, (%r13)
leaq (%r15,%rax), %rdi
subq %rax, %r12
subq %rax, %rcx
movq %r12, %rsi
movq %rdi, %rdx
movq %r13, %r8
callq 0x130b0
addq 0x20(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r13), %r12
cmpq %rax, %r12
jbe 0x1520b
movq 0x28(%rbx), %rdx
subq %r12, %rdx
jbe 0x1520b
addq %r15, %rax
addq %r12, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x2340
movq 0x20(%rbx), %rax
subq %r12, %rax
addq %rax, 0x28(%rbx)
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/tools.cpp
// Function: seedMT(unsigned int)
void seedMT(uint seed)
{
    state[0] = seed;
    for(uint i = 1; i < N; i++)
        state[i] = seed = 1812433253U * (seed ^ (seed >> 30)) + i;
    next = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, 0xa4a3(%rip)      # 0x1f7b0
movl $0x1, %eax
leaq 0xa497(%rip), %rcx      # 0x1f7b0
movl %edi, %edx
shrl $0x1e, %edx
xorl %edi, %edx
imull $0x6c078965, %edx, %edi # imm = 0x6C078965
addl %eax, %edi
movl %edi, (%rcx,%rax,4)
incq %rax
cmpq $0x270, %rax            # imm = 0x270
jne 0x15319
movl $0x0, 0x8f08(%rip)      # 0x1e248
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/tools.cpp
// Function: randomMT()
uint randomMT()
{
    int cur = next;
    if(++next >= N)
    {
        if(next > N) { seedMT(5489U + time(NULL)); cur = next++; }
        else next = 0;
    }
    uint y = (state[cur] & 0x80000000U) | (state[next] & 0x7FFFFFFFU);
    state[cur] = y = state[cur < N-M ? cur + M : cur + M-N] ^ (y >> 1) ^ (-int(y & 1U) & K);
    y ^= (y >> 11);
    y ^= (y <<  7) & 0x9D2C5680U;
    y ^= (y << 15) & 0xEFC60000U;
    y ^= (y >> 18);
    return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x8efa(%rip), %ebx      # 0x1e248
leal 0x1(%rbx), %eax
movl %eax, 0x8ef1(%rip)      # 0x1e248
cmpl $0x26f, %ebx            # imm = 0x26F
jl 0x153b2
xorl %eax, %eax
cmpl $0x26f, %ebx            # imm = 0x26F
je 0x153ac
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x2170
addl $0x1571, %eax           # imm = 0x1571
movl %eax, 0xa433(%rip)      # 0x1f7b0
movl $0x1, %ecx
leaq 0xa427(%rip), %rdx      # 0x1f7b0
movl %eax, %esi
shrl $0x1e, %esi
xorl %eax, %esi
imull $0x6c078965, %esi, %eax # imm = 0x6C078965
addl %ecx, %eax
movl %eax, (%rdx,%rcx,4)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x15389
movl $0x1, %eax
movl %eax, 0x8e96(%rip)      # 0x1e248
movslq %ebx, %rax
leaq 0xa3f4(%rip), %rcx      # 0x1f7b0
leal -0xe3(%rax), %edx
leal 0x18d(%rax), %esi
cmpl $0xe3, %eax
cmovgel %edx, %esi
movslq 0x8e71(%rip), %rdx      # 0x1e248
movl $0x80000000, %edi       # imm = 0x80000000
andl (%rcx,%rax,4), %edi
movl (%rcx,%rdx,4), %edx
movl %edx, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orl %edi, %r8d
movslq %esi, %rsi
shrl %r8d
xorl (%rcx,%rsi,4), %r8d
andl $0x1, %edx
negl %edx
andl $0x9908b0df, %edx       # imm = 0x9908B0DF
xorl %r8d, %edx
movl %edx, (%rcx,%rax,4)
movl %edx, %eax
shrl $0xb, %eax
xorl %edx, %eax
movl %eax, %ecx
shll $0x7, %ecx
andl $0x9d2c5680, %ecx       # imm = 0x9D2C5680
xorl %eax, %ecx
movl %ecx, %edx
shll $0xf, %edx
andl $0xefc60000, %edx       # imm = 0xEFC60000
xorl %ecx, %edx
movl %edx, %eax
shrl $0x12, %eax
xorl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/tools.cpp
// Function: getint(databuf<unsigned char>&)
int getint(ucharbuf &p)
{
    int c = (char)p.get();
    if(c==-128) { int n = p.get(); n |= char(p.get())<<8; return n; }
    else if(c==-127) { int n = p.get(); n |= p.get()<<8; n |= p.get()<<16; return n|(p.get()<<24); }
    else return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x8(%rdi), %rax
movl 0xc(%rdi), %ecx
cmpl %ecx, %eax
jge 0x15619
leal 0x1(%rax), %edx
movl %edx, 0x8(%rdi)
addq (%rdi), %rax
jmp 0x15624
orb $0x1, 0x10(%rdi)
leaq 0xab4c(%rip), %rax      # 0x20170
movzbl (%rax), %eax
cmpl $0x81, %eax
je 0x15648
cmpl $0x80, %eax
jne 0x1565b
movslq 0x8(%rdi), %rax
cmpl %ecx, %eax
jge 0x15663
leal 0x1(%rax), %edx
movl %edx, 0x8(%rdi)
addq (%rdi), %rax
jmp 0x1566e
movslq 0x8(%rdi), %rax
cmpl %ecx, %eax
jge 0x1569c
leal 0x1(%rax), %edx
movl %edx, 0x8(%rdi)
addq (%rdi), %rax
jmp 0x156a7
movsbl %al, %eax
jmp 0x1571c
orb $0x1, 0x10(%rdi)
leaq 0xab02(%rip), %rax      # 0x20170
movzbl (%rax), %edx
movslq 0x8(%rdi), %rax
cmpl %ecx, %eax
jge 0x15684
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
addq (%rdi), %rax
jmp 0x1568f
orb $0x1, 0x10(%rdi)
leaq 0xaae1(%rip), %rax      # 0x20170
movsbl (%rax), %eax
shll $0x8, %eax
orl %edx, %eax
jmp 0x1571c
orb $0x1, 0x10(%rdi)
leaq 0xaac9(%rip), %rax      # 0x20170
movzbl (%rax), %edx
movslq 0x8(%rdi), %rax
cmpl %ecx, %eax
jge 0x156bd
leal 0x1(%rax), %esi
movl %esi, 0x8(%rdi)
addq (%rdi), %rax
jmp 0x156c8
orb $0x1, 0x10(%rdi)
leaq 0xaaa8(%rip), %rax      # 0x20170
movzbl (%rax), %eax
shll $0x8, %eax
orl %edx, %eax
movslq 0x8(%rdi), %rdx
cmpl %ecx, %edx
jge 0x156e3
leal 0x1(%rdx), %esi
movl %esi, 0x8(%rdi)
addq (%rdi), %rdx
jmp 0x156ee
orb $0x1, 0x10(%rdi)
leaq 0xaa82(%rip), %rdx      # 0x20170
movzbl (%rdx), %edx
shll $0x10, %edx
orl %edx, %eax
movslq 0x8(%rdi), %rdx
cmpl %ecx, %edx
jge 0x15709
leal 0x1(%rdx), %ecx
movl %ecx, 0x8(%rdi)
addq (%rdi), %rdx
jmp 0x15714
orb $0x1, 0x10(%rdi)
leaq 0xaa5c(%rip), %rdx      # 0x20170
movzbl (%rdx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/tools.cpp
// Function: getuint(databuf<unsigned char>&)
int getuint(ucharbuf &p)
{
    int n = p.get();
    if(n & 0x80)
    {
        n += (p.get() << 7) - 0x80;
        if(n & (1<<14)) n += (p.get() << 14) - (1<<14);
        if(n & (1<<21)) n += (p.get() << 21) - (1<<21);
        if(n & (1<<28)) n |= -1<<28;
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x8(%rdi), %rax
movl 0xc(%rdi), %ecx
cmpl %ecx, %eax
jge 0x1594c
leal 0x1(%rax), %edx
movl %edx, 0x8(%rdi)
addq (%rdi), %rax
jmp 0x15957
orb $0x1, 0x10(%rdi)
leaq 0xa819(%rip), %rax      # 0x20170
movzbl (%rax), %eax
testb %al, %al
jns 0x159fe
movslq 0x8(%rdi), %rdx
cmpl %ecx, %edx
jge 0x15975
leal 0x1(%rdx), %esi
movl %esi, 0x8(%rdi)
addq (%rdi), %rdx
jmp 0x15980
orb $0x1, 0x10(%rdi)
leaq 0xa7f0(%rip), %rdx      # 0x20170
movzbl (%rdx), %esi
movl %esi, %edx
shll $0x7, %edx
addl %eax, %edx
addl $-0x80, %edx
testb %sil, %sil
jns 0x159be
movslq 0x8(%rdi), %rax
cmpl %ecx, %eax
jge 0x159a5
leal 0x1(%rax), %esi
movl %esi, 0x8(%rdi)
addq (%rdi), %rax
jmp 0x159b0
orb $0x1, 0x10(%rdi)
leaq 0xa7c0(%rip), %rax      # 0x20170
movzbl (%rax), %eax
shll $0xe, %eax
addl %eax, %edx
addl $0xffffc000, %edx       # imm = 0xFFFFC000
btl $0x15, %edx
jae 0x159f0
movslq 0x8(%rdi), %rax
cmpl %ecx, %eax
jge 0x159d7
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
addq (%rdi), %rax
jmp 0x159e2
orb $0x1, 0x10(%rdi)
leaq 0xa78e(%rip), %rax      # 0x20170
movzbl (%rax), %eax
shll $0x15, %eax
addl %eax, %edx
addl $0xffe00000, %edx       # imm = 0xFFE00000
movl %edx, %eax
orl $0xf0000000, %eax       # imm = 0xF0000000
btl $0x1c, %edx
cmovael %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/tools.cpp
// Function: getstring(char*, databuf<unsigned char>&, unsigned long)
void getstring(char *text, ucharbuf &p, size_t len)
{
    char *t = text;
    do
    {
        if(t>=&text[len]) { text[len-1] = 0; return; }
        if(!p.remaining()) { *t = 0; return; }
        *t = getint(p);
    }
    while(*t++);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq %rdi, %r14
cmpq %r14, %rbx
jae 0x15baa
movl 0xc(%r15), %eax
cmpl 0x8(%r15), %eax
je 0x15bb0
movq %r15, %rdi
callq 0x155ff
movb %al, (%rbx)
incq %rbx
testb %al, %al
jne 0x15b88
jmp 0x15bb3
decq %r14
movq %r14, %rbx
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/tools.cpp
// Function: filtertext(char*, char const*, bool, unsigned long)
void filtertext(char *dst, const char *src, bool whitespace, size_t len)
{
    for(int c = uchar(*src); c; c = uchar(*++src))
    {
        if(c == '\f')
        {
            if(!*++src) break;
            continue;
        }
        if(iscubeprint(c) || (iscubespace(c) && whitespace))
        {
            *dst++ = c;
            if(!--len) break;
        }
    }
    *dst = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1547(%rip), %rax      # 0x17110
xorb $0x1, %dl
movzbl (%rsi), %r8d
cmpl $0xc, %r8d
je 0x15bff
testl %r8d, %r8d
je 0x15c0d
movb (%rax,%r8), %r9b
testb $0x1, %r9b
jne 0x15bf2
testb $0x2, %r9b
sete %r9b
orb %dl, %r9b
jne 0x15c08
movb %r8b, (%rdi)
incq %rdi
decq %rcx
jne 0x15c08
jmp 0x15c0d
cmpb $0x0, 0x1(%rsi)
je 0x15c0d
incq %rsi
incq %rsi
jmp 0x15bcc
movb $0x0, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/main.cc
// Function: readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char (*) [89])
void readFile(std::string file, char display[27][89]) {
	std::string str;
	std::ifstream in (file);
	for (int i = 0; i < 27; i++)
    {
        getline(in, str);
        for (int j = 0; j < 89; j++)
        {
            display[i][j] = str[j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x250(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x4220
xorl %r13d, %r13d
leaq -0x48(%rbp), %r15
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4270
movq -0x48(%rbp), %rax
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq $0x59, %rcx
jne 0x4584
incq %r13
addq $0x59, %rbx
cmpq $0x1b, %r13
jne 0x4558
leaq -0x250(%rbp), %rdi
callq 0x4050
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x45c1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x4170
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x45e7
movq %rax, %rbx
leaq -0x250(%rbp), %rdi
callq 0x4050
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x45fc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x4170
movq %rbx, %rdi
callq 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/main.cc
// Function: printDisplay(char (*) [89])
void printDisplay(char display[27][89]) {
	std::cout << "\033[2J\033[1;1H";
	for (int i = 0; i < 27; i++) {
		for (int j = 0; j < 89; j++) {
			std::cout << display[i][j];
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1f9b4(%rip), %r14     # 0x23fd0
leaq 0x189e1(%rip), %rsi     # 0x1d004
movl $0xa, %edx
movq %r14, %rdi
callq 0x41a0
xorl %r12d, %r12d
leaq -0x29(%rbp), %r15
movq $-0x59, %r13
movb 0x59(%rbx,%r13), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x41a0
incq %r13
jne 0x463e
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x40e0
incq %r12
addq $0x59, %rbx
cmpq $0x1b, %r12
jne 0x4637
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/main.cc
// Function: printEnd()
void printEnd() {
	std::cout << "\033[2J\033[1;1H";
	std::cout << "Thanks for playing Chamber Crawler 3000 +" << std::endl << std::endl;
	std::cout << "Project by Malcolm Yeh, Zayaan Moez, Kai Lu for CS246" << std::endl;
	std::cout << std::endl << std::endl << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x1f924(%rip), %rbx     # 0x23fd0
leaq 0x18951(%rip), %rsi     # 0x1d004
movl $0xa, %edx
movq %rbx, %rdi
callq 0x41a0
leaq 0x18948(%rip), %rsi     # 0x1d00f
movl $0x29, %edx
movq %rbx, %rdi
callq 0x41a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x40e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x40e0
leaq 0x1890d(%rip), %rsi     # 0x1d039
movl $0x35, %edx
movq %rbx, %rdi
callq 0x41a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x40e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x40e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x40e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x40e0
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/posn.cc
// Function: Posn::getNew(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Posn Posn::getNew(std::string dir) {
	Posn p;
	if (dir == "ea") {
		p.x = this->x + 1;
		p.y = this->y;
	} else if (dir == "we") {
		p.x = this->x - 1;
		p.y = this->y;
	} else if (dir == "no") {
		p.x = this->x;
		p.y = this->y-1;
	} else if (dir == "so") {
		p.x = this->x;
		p.y = this->y+1;
	} else if (dir == "ne") {
		p.x = this->x + 1;
		p.y = this->y - 1;
	} else if (dir == "nw") {
		p.x = this->x - 1;
		p.y = this->y - 1;
	} else if (dir == "se") {
		p.x = this->x + 1;
		p.y = this->y + 1;
	} else if (dir == "sw") {
		p.x = this->x - 1;
		p.y = this->y + 1;
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18105(%rip), %rsi     # 0x1d1cd
movq %r14, %rdi
callq 0x4070
testl %eax, %eax
je 0x516a
leaq 0x180f1(%rip), %rsi     # 0x1d1d0
movq %r14, %rdi
callq 0x4070
testl %eax, %eax
je 0x5173
leaq 0x180dd(%rip), %rsi     # 0x1d1d3
movq %r14, %rdi
callq 0x4070
testl %eax, %eax
je 0x517c
leaq 0x180cd(%rip), %rsi     # 0x1d1d6
movq %r14, %rdi
callq 0x4070
testl %eax, %eax
je 0x5183
leaq 0x180bd(%rip), %rsi     # 0x1d1d9
movq %r14, %rdi
callq 0x4070
testl %eax, %eax
je 0x518c
leaq 0x180ad(%rip), %rsi     # 0x1d1dc
movq %r14, %rdi
callq 0x4070
testl %eax, %eax
je 0x5195
leaq 0x1809d(%rip), %rsi     # 0x1d1df
movq %r14, %rdi
callq 0x4070
testl %eax, %eax
je 0x51ac
leaq 0x1808d(%rip), %rsi     # 0x1d1e2
movq %r14, %rdi
callq 0x4070
testl %eax, %eax
jne 0x519e
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
decl %ecx
jmp 0x5188
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
incl %ecx
jmp 0x519e
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
decl %ecx
jmp 0x519e
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
jmp 0x519c
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
incl %edx
jmp 0x519e
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
incl %ecx
jmp 0x519c
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
decl %ecx
decl %edx
shlq $0x20, %rdx
movl %ecx, %eax
orq %rdx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
incl %ecx
jmp 0x5188
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/chamber.cc
// Function: Chamber::checkRange(Posn)
bool Chamber::checkRange(Posn p) {
	int x = p.x;
	int y = p.y;
	if (num == 1 || num == 2 || num == 4) {
		return (x >= col && x <= maxCol && y >= row && y <= maxRow);
	} else if (num == 3) {
		if (x >= col && y >= row && x <= 60 && y <= 6) {
			return true;
		} else if (x == 61 && y >= 3 && y <= 12) {
			return true;
		} else if (x >= 62 && y >= 5 && x <= 69 && y <= 12) {
			return true;
		} else if (x >= 70 && y >= 6 && x <= 72 && y <= 12) {
			return true;
		} else if (x >= 73 && y >= 7 && x <= 75 && y <= 12) {
			return true;
		}
	} else if (num == 5) {
		if (x >= 37 && y >= 19 && x <= 64 && y <= 21) {
			return true;
		} else if (x >= 65 && y >= 16 && x <= 75 && y <= 21) {
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
decl %eax
cmpl $0x4, %eax
ja 0x52fa
movq %rsi, %rcx
shrq $0x20, %rcx
leaq 0x17f53(%rip), %rdx     # 0x1d1e8
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
xorl %eax, %eax
cmpl %esi, 0x10(%rdi)
jg 0x5369
cmpl %esi, 0x8(%rdi)
jl 0x5369
cmpl %ecx, 0xc(%rdi)
jg 0x5369
cmpl %ecx, 0x4(%rdi)
setge %al
jmp 0x5369
leal -0x25(%rsi), %eax
cmpl $0x1c, %eax
setb %dl
leal -0x13(%rcx), %eax
cmpl $0x3, %eax
setb %dil
movb $0x1, %al
testb %dil, %dl
jne 0x5369
leal -0x41(%rsi), %edx
cmpl $0xb, %edx
setb %dl
addl $-0x10, %ecx
cmpl $0x6, %ecx
setb %cl
testb %cl, %dl
jne 0x5369
xorl %eax, %eax
jmp 0x5369
cmpl %esi, 0x10(%rdi)
jle 0x5358
cmpl $0x3d, %esi
sete %dl
leal -0x3(%rcx), %eax
cmpl $0xa, %eax
setb %dil
movb $0x1, %al
testb %dil, %dl
jne 0x5369
leal -0x3e(%rsi), %edx
cmpl $0x8, %edx
setb %dl
leal -0x5(%rcx), %edi
cmpl $0x8, %edi
setb %dil
testb %dil, %dl
jne 0x5369
leal -0x46(%rsi), %edx
cmpl $0x3, %edx
setb %dl
leal -0x6(%rcx), %edi
cmpl $0x7, %edi
setb %dil
testb %dil, %dl
jne 0x5369
leal -0x49(%rsi), %edx
cmpl $0x3, %edx
setb %dl
addl $-0x7, %ecx
jmp 0x52f0
cmpl $0x6, %ecx
jg 0x5303
cmpl %ecx, 0xc(%rdi)
jg 0x5303
movb $0x1, %al
cmpl $0x3d, %esi
jge 0x5303
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/chamber.cc
// Function: Chamber::getPosition()
Posn Chamber::getPosition() {
	Posn p;
	do {

		int r = rand() % maxRow;
		int c = rand() % maxCol;
		p.x = c;
		p.y = r;
	} while (!checkRange(p));

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4060
cltd
idivl 0x4(%rbx)
movl %edx, %r15d
callq 0x4060
cltd
idivl 0x8(%rbx)
movl %edx, %r14d
shlq $0x20, %r15
orq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x527a
testb %al, %al
je 0x5379
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/display.cc
// Function: Display::readFloor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Display::readFloor(std::string file) {
	std::ifstream in (file);
	std::string str;
	for (int i = 0; i < 25; i++) {
		getline(in, str);
		for (int j = 0; j < 79; j++) {
			this->displayGrid[i][j] = str[j];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq -0x250(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x4220
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
xorl %r13d, %r13d
leaq -0x48(%rbp), %r15
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4150
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4270
movq -0x48(%rbp), %rax
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq $0x4f, %rcx
jne 0x542d
incq %r13
addq $0x4f, %rbx
cmpq $0x19, %r13
jne 0x5401
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x545e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x4170
leaq -0x250(%rbp), %rdi
callq 0x4050
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x5494
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x4170
leaq -0x250(%rbp), %rdi
callq 0x4050
movq %rbx, %rdi
callq 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/floor.cc
// Function: Floor::Floor(int, bool, bool)
Floor::Floor(int level, bool hostile, bool spawned) {
	this->level = level;
	this->merchantHostile = hostile;
	this->barrierSpawned = spawned;
	this->player = NULL;
	this->stair = NULL;
	this->suit = NULL;
	for (int i = 0; i < 6; ++i){
		this->knownPotion[i] = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x810(%rdi)
movups %xmm0, 0x800(%rdi)
movups %xmm0, 0x7f0(%rdi)
movups %xmm0, 0x7e0(%rdi)
movups %xmm0, 0x7d0(%rdi)
movups %xmm0, 0x7c0(%rdi)
movl %esi, (%rdi)
movb %dl, 0x4(%rdi)
movb %cl, 0x5(%rdi)
movups %xmm0, 0xfd8(%rdi)
movups %xmm0, 0xfe6(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/floor.cc
// Function: Floor::~Floor()
Floor::~Floor() {
	for (int i = 0; i < enemies.size(); ++i) {
		//delete enemies.at(i);
		Enemy * temp = enemies.at(i);
		enemies.erase(enemies.begin() + i);
		delete temp;
		--i;
	}
	for (int i = 0; i < golds.size(); ++i) { 
		//delete golds.at(i); 
		Gold * temp = golds.at(i);
		golds.erase(golds.begin() + i);
		delete temp;
		--i;
	}
	for (int i = 0; i < potions.size(); ++i) {
		//delete potions.at(i);
		Potion * temp = potions.at(i);
		potions.erase(potions.begin() + i);
		delete temp;
		--i;
	}
	for (int i = 0; i < chambers.size(); ++i) {
		//delete chambers.at(i);
		Chamber * temp = chambers.at(i);
		chambers.erase(chambers.begin() + i);
		delete temp;
		--i;
	}
	delete this->player;
	delete this->stair;
	delete this->suit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x7c0(%rdi), %rdi
movq 0x7c8(%rbx), %rdx
cmpq %rdi, %rdx
je 0x58f8
movq (%rdi), %r14
leaq 0x8(%rdi), %rsi
cmpq %rdx, %rsi
je 0x5893
subq %rsi, %rdx
callq 0x4230
addq $-0x8, 0x7c8(%rbx)
testq %r14, %r14
je 0x58a9
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movq 0x7c0(%rbx), %rdi
jmp 0x5873
movq (%rdi), %r14
leaq 0x8(%rdi), %rsi
cmpq %rdx, %rsi
je 0x58c6
subq %rsi, %rdx
callq 0x4230
addq $-0x8, 0x7e0(%rbx)
testq %r14, %r14
je 0x58f8
movq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
cmpq %rax, %rdi
je 0x58eb
movq (%rax), %rsi
incq %rsi
callq 0x4170
movl $0x38, %esi
movq %r14, %rdi
callq 0x4170
movq 0x7d8(%rbx), %rdi
movq 0x7e0(%rbx), %rdx
cmpq %rdi, %rdx
jne 0x58b2
jmp 0x5953
movq (%rdi), %r14
leaq 0x8(%rdi), %rsi
cmpq %rdx, %rsi
je 0x5921
subq %rsi, %rdx
callq 0x4230
addq $-0x8, 0x7f8(%rbx)
testq %r14, %r14
je 0x5953
movq 0x10(%r14), %rdi
leaq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x5946
movq (%rax), %rsi
incq %rsi
callq 0x4170
movl $0x30, %esi
movq %r14, %rdi
callq 0x4170
movq 0x7f0(%rbx), %rdi
movq 0x7f8(%rbx), %rdx
cmpq %rdi, %rdx
jne 0x590d
jmp 0x5996
movq (%rdi), %r14
leaq 0x8(%rdi), %rsi
cmpq %rdx, %rsi
je 0x597c
subq %rsi, %rdx
callq 0x4230
addq $-0x8, 0x810(%rbx)
testq %r14, %r14
je 0x5996
movl $0x14, %esi
movq %r14, %rdi
callq 0x4170
movq 0x808(%rbx), %rdi
movq 0x810(%rbx), %rdx
cmpq %rdi, %rdx
jne 0x5968
movq 0xfe0(%rbx), %rdi
testq %rdi, %rdi
je 0x59bb
movq (%rdi), %rax
callq *0x60(%rax)
movq 0xfd8(%rbx), %rdi
testq %rdi, %rdi
je 0x59d1
movl $0xc, %esi
callq 0x4170
movq 0xfe8(%rbx), %rdi
testq %rdi, %rdi
je 0x59e7
movl $0x10, %esi
callq 0x4170
movq 0x808(%rbx), %rdi
testq %rdi, %rdi
je 0x5a02
movq 0x818(%rbx), %rsi
subq %rdi, %rsi
callq 0x4170
movq 0x7f0(%rbx), %rdi
testq %rdi, %rdi
je 0x5a1d
movq 0x800(%rbx), %rsi
subq %rdi, %rsi
callq 0x4170
movq 0x7d8(%rbx), %rdi
testq %rdi, %rdi
je 0x5a38
movq 0x7e8(%rbx), %rsi
subq %rdi, %rsi
callq 0x4170
movq 0x7c0(%rbx), %rdi
testq %rdi, %rdi
je 0x5a57
movq 0x7d0(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4170
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/floor.cc
// Function: Floor::generatePosition(int&, Posn&)
void Floor::generatePosition(int &id, Posn &pos) {
	id = rand() % 5 + 1;

	Chamber *c = chambers.at(id - 1);
	Posn p;
	do {
		p = c->getPosition();
	} while (!this->validTile(p));
	pos = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x4060
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
movl %eax, %edx
subl %ecx, %edx
negl %ecx
addl %ecx, %eax
incl %eax
movl %eax, (%r15)
movslq %edx, %rsi
movq 0x808(%r14), %rax
movq 0x810(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x5b0c
movq (%rax,%rsi,8), %r15
leaq -0x30(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %r15, %rdi
callq 0x536c
movq %rax, -0x38(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x51e2
movq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x5b1a
testb %al, %al
je 0x5aca
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x51e2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17cbc(%rip), %rdi     # 0x1d7cf
xorl %eax, %eax
callq 0x41e0
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/floor.cc
// Function: Floor::initFloor(char)
void Floor::initFloor(char type) {
	int id;
	int dragons = 0;
	srand(time(NULL));
	generateChamber();
	generatePlayer(type, id);
	generateStair(id);
	generateItems(dragons);
	generateEnemies(dragons);
	assignCompass();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x24(%rbp), %r14
movl $0x0, (%r14)
xorl %edi, %edi
callq 0x4130
movl %eax, %edi
callq 0x4140
movq %rbx, %rdi
callq 0x5ef8
leaq -0x28(%rbp), %r12
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x5f8e
movl (%r12), %esi
movq %rbx, %rdi
callq 0x6130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6226
movl (%r14), %esi
movq %rbx, %rdi
callq 0x6948
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6aee
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/floor.cc
// Function: Floor::generatePlayer(char, int&)
void Floor::generatePlayer(char type, int &id) {


	id = rand() % 5 + 1;

	Chamber *c = chambers.at(id - 1);
	Posn p;
	do {
		p = c->getPosition();
	} while (!(this->displayGrid[p.y][p.x] == '.'));


	if (type == 'h') {
	 	this->player = new Human(140, 0, p);
	} else if (type == 'o') {
		this->player = new Orc(1800, 0, p);
	} else if (type == 'e') {
		this->player = new Elf(1400, 0, p);
	} else if (type == 'd') {
		this->player = new Dwarf(1000, 0, p);
	}
	displayGrid[p.y][p.x] = '@';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movl %esi, -0x34(%rbp)
movq %rdi, %rbx
callq 0x4060
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
movl %eax, %edx
subl %ecx, %edx
negl %ecx
addl %ecx, %eax
incl %eax
movl %eax, (%r15)
movslq %edx, %rsi
movq 0x808(%rbx), %rax
movq 0x810(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x6104
movq (%rax,%rsi,8), %r15
leaq 0x820(%rbx), %r14
leaq -0x30(%rbp), %r12
leaq -0x40(%rbp), %r13
movq %r15, %rdi
callq 0x536c
movq %rax, -0x40(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x51e2
movslq -0x2c(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x4f, %rax, %rax
addq %r14, %rax
cmpb $0x2e, (%rcx,%rax)
jne 0x6007
movsbl -0x34(%rbp), %eax
cmpl $0x67, %eax
jg 0x606c
cmpl $0x64, %eax
je 0x6098
cmpl $0x65, %eax
jne 0x60e1
movl $0x50, %edi
callq 0x4160
movq %rax, %r15
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movl $0x578, %esi            # imm = 0x578
xorl %edx, %edx
callq 0xe5b4
jmp 0x60da
cmpl $0x6f, %eax
je 0x60ba
cmpl $0x68, %eax
jne 0x60e1
movl $0x50, %edi
callq 0x4160
movq %rax, %r15
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movl $0x8c, %esi
xorl %edx, %edx
callq 0xc12c
jmp 0x60da
movl $0x50, %edi
callq 0x4160
movq %rax, %r15
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
xorl %edx, %edx
callq 0xf80c
jmp 0x60da
movl $0x50, %edi
callq 0x4160
movq %rax, %r15
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movl $0x708, %esi            # imm = 0x708
xorl %edx, %edx
callq 0xc300
movq %r15, 0xfe0(%rbx)
movslq -0x2c(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x4f, %rax, %rax
addq %rax, %r14
movb $0x40, (%rcx,%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x176c4(%rip), %rdi     # 0x1d7cf
xorl %eax, %eax
callq 0x41e0
jmp 0x6118
jmp 0x6118
jmp 0x6118
movq %rax, %rbx
movl $0x50, %esi
movq %r15, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/floor.cc
// Function: Floor::generateStair(int)
void Floor::generateStair(int id) {
	int id2;
	Posn p;
	do {
		id2 = rand() % 5 + 1;
	} while (id == id2);
	Chamber *c = chambers.at(id2 - 1);
	do {
		p = c->getPosition();
	} while (!(this->displayGrid[p.y][p.x] == '.'));
	 
	this->stair = new Stair(p);
	//this->displayGrid[p.y][p.x] == '/';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x4060
movslq %eax, %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
movl %ecx, %edx
negl %edx
addl %eax, %edx
incl %edx
cmpl %r14d, %edx
je 0x6147
subl %ecx, %eax
movslq %eax, %rsi
movq 0x808(%rbx), %rax
movq 0x810(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x6200
movq (%rax,%rsi,8), %r14
leaq 0x820(%rbx), %r13
leaq -0x30(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %r14, %rdi
callq 0x536c
movq %rax, -0x38(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x51e2
movslq -0x2c(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x4f, %rax, %rax
addq %r13, %rax
cmpb $0x2e, (%rcx,%rax)
jne 0x61a5
movl $0xc, %edi
callq 0x4160
movq %rax, %r14
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x51f8
movq %r14, 0xfd8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x175c8(%rip), %rdi     # 0x1d7cf
xorl %eax, %eax
callq 0x41e0
movq %rax, %rbx
movl $0xc, %esi
movq %r14, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/floor.cc
// Function: Floor::generateEnemies(int)
void Floor::generateEnemies(int dragons) {
	for (int i = 0; i < 20 - dragons; i++) {
		int num = rand() % 18 + 1;
		int id;
		Posn pos;
		generatePosition(id, pos);
		Enemy *e;
		if (num <= 4) {
			e = new Werewolf(pos, id);
			this->enemies.push_back(e);
		} else if (num > 4 && num <= 7) {
			e = new Vampire(pos, id);
			this->enemies.push_back(e);
		} else if (num > 7 && num <= 12) {
			e = new Goblin(pos, id);
			this->enemies.push_back(e);
		} else if (num > 12 && num <= 14) {
			e = new Troll(pos, id);
			this->enemies.push_back(e);
		} else if (num > 14 && num <= 16) {
			e = new Phoenix(pos, id);
			this->enemies.push_back(e);
		} else if (num > 16 && num <= 18) {
			e = new Merchant(pos, id);
			this->enemies.push_back(e);
		}
		displayGrid[pos.y][pos.x] = e->getSymbol();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x13, %esi
jg 0x6abd
movq %rdi, %rbx
movl $0x14, %eax
subl %esi, %eax
leaq 0x7c0(%rdi), %rcx
movq %rcx, -0x48(%rbp)
cmpl $0x2, %eax
movl $0x1, %r14d
cmovgel %eax, %r14d
leaq 0x820(%rdi), %r15
callq 0x4060
movslq %eax, %r12
imulq $0x38e38e39, %r12, %rax # imm = 0x38E38E39
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rax
addl %ecx, %eax
addl %eax, %eax
leal (%rax,%rax,8), %eax
subl %eax, %r12d
movq %rbx, %rdi
leaq -0x34(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x5a5c
movl $0x50, %edi
cmpl $0x3, %r12d
jg 0x69e6
callq 0x4160
movq %rax, %r13
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
movq %rax, %rdi
callq 0x15378
jmp 0x6a6a
cmpl $0x6, %r12d
jg 0x6a05
callq 0x4160
movq %rax, %r13
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
movq %rax, %rdi
callq 0x145f4
jmp 0x6a6a
cmpl $0xb, %r12d
jg 0x6a24
callq 0x4160
movq %rax, %r13
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
movq %rax, %rdi
callq 0x10b20
jmp 0x6a6a
cmpl $0xd, %r12d
jg 0x6a43
callq 0x4160
movq %rax, %r13
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
movq %rax, %rdi
callq 0x129c8
jmp 0x6a6a
callq 0x4160
movq %rax, %r13
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
cmpl $0xf, %r12d
jg 0x6a62
movq %r13, %rdi
callq 0x117c0
jmp 0x6a6a
movq %r13, %rdi
callq 0x116a0
movq %r13, -0x30(%rbp)
movq 0x7c8(%rbx), %rsi
cmpq 0x7d0(%rbx), %rsi
je 0x6a8b
movq %r13, (%rsi)
addq $0x8, 0x7c8(%rbx)
jmp 0x6a98
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xa75c
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movslq -0x3c(%rbp), %rcx
movslq -0x40(%rbp), %rdx
imulq $0x4f, %rcx, %rcx
addq %r15, %rcx
movb %al, (%rdx,%rcx)
decl %r14d
jne 0x698b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ad6
jmp 0x6ad6
jmp 0x6ad6
jmp 0x6ad6
jmp 0x6ad6
movq %rax, %rbx
movl $0x50, %esi
movq %r13, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/floor.cc
// Function: Floor::talkMerchant(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Floor::talkMerchant(std::string direction){
	if (this->getHostile()){
		return "You are my enemy!";
	}
	Posn p = this->player->getPosition().getNew(direction);
	for (int i = 0; i < this->enemies.size(); ++i){
		if (p == this->enemies.at(i)->getPosition()){
			if (this->enemies.at(i)->getRace() == "Merchant") {
				return "(B)uckler Shield: 3g (T)arge Shield: 6g (P)avise Shield: 12g (N)odachi: 3g (K)atana: 7g (U)chigatana: 15g";
			}
		}
	}
	return "Invalid input. Try again.";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r13
cmpb $0x1, 0x4(%rsi)
jne 0x85ca
leaq 0x10(%r13), %rax
movq %rax, (%r13)
leaq 0x14e91(%rip), %rsi     # 0x1d444
leaq 0x14e9b(%rip), %rdx     # 0x1d455
movq %r13, %rdi
callq 0x501a
movq %r13, %rax
jmp 0x8720
movq %rdx, %r15
movq %rsi, %r14
movq 0xfe0(%rsi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq -0x58(%rbp), %rbx
movq %rax, (%rbx)
leaq -0x68(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %r15
movq %r15, %rdi
callq 0xa582
movq %rbx, %rdi
movq %r15, %rsi
callq 0x50b4
movq %r13, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x862b
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x4170
movq 0x7c0(%r14), %rax
cmpq %rax, 0x7c8(%r14)
je 0x86e1
xorl %r15d, %r15d
leaq -0x38(%rbp), %r12
leaq -0x58(%rbp), %r13
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x58(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x51b6
testb %al, %al
je 0x86c0
movq 0x7c0(%r14), %rax
movq 0x7c8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x872f
movq (%rax,%r15,8), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x28(%rax)
movq %r13, %rdi
leaq 0x14c2e(%rip), %rsi     # 0x1d2ca
callq 0x4070
movl %eax, %ebx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x86bc
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x4170
testl %ebx, %ebx
je 0x86fc
incq %r15
movq 0x7c0(%r14), %rax
movq 0x7c8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x864a
movq -0x30(%rbp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x14dcd(%rip), %rsi     # 0x1d4c0
leaq 0x14ddf(%rip), %rdx     # 0x1d4d9
jmp 0x8715
movq -0x30(%rbp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x14d48(%rip), %rsi     # 0x1d456
leaq 0x14daa(%rip), %rdx     # 0x1d4bf
movq %rbx, %rdi
callq 0x501a
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15099(%rip), %rdi     # 0x1d7cf
movq %r15, %rsi
xorl %eax, %eax
callq 0x41e0
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x8758
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x4170
movq %rbx, %rdi
callq 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/player.cc
// Function: Player::takeDamage(int)
void Player::takeDamage(int amount)
{
    if (this->barrier())
    {
        this->HP -= ceil(amount / 2);
    }
    else
    {
        this->HP -= amount;
    }
    if (this->HP < 0)
    {
        this->HP = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x48(%rdi)
jne 0xb5fe
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
subl %eax, 0x10(%rdi)
jmp 0xb601
subl %esi, 0x10(%rdi)
cmpl $0x0, 0x10(%rdi)
jns 0xb60e
movl $0x0, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/human.cc
// Function: Human::Human(int, int, Posn)
Human::Human(int HP, int gold, Posn position)
{
    this->Atk = 20;
    this->Def = 20;
    this->HP = HP;
    this->gold = gold;
    this->race = "Human";
    this->symbol = '@';
    this->position = position;
    this->MaxHP = 140;
    this->hasBarrier = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, -0x20(%rbp)
leaq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %r15
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x173dc(%rip), %rax     # 0x23538
movq %rax, (%rbx)
movabsq $0x1400000014, %rax     # imm = 0x1400000014
movq %rax, 0x8(%rbx)
movl %esi, 0x10(%rbx)
movl %edx, 0x14(%rbx)
leaq 0x11836(%rip), %rcx     # 0x1d9b0
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4200
movb $0x40, 0x38(%rbx)
leaq 0x3c(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51e2
movl $0x8c, 0x44(%rbx)
movb $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x171ae(%rip), %rax     # 0x23368
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xc1d5
movq (%r15), %rsi
incq %rsi
callq 0x4170
movq %r14, %rdi
callq 0x4250
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/human.cc
// Function: Human::Human(int, int, Posn, int, int, bool)
Human::Human(int HP, int gold, Posn position, int Atk, int Def, bool hasBarrier)
{
    this->Atk = Atk;
    this->Def = Def;
    this->HP = HP;
    this->gold = gold;
    this->race = "Human";
    this->symbol = '@';
    this->position = position;
    this->MaxHP = 140;
    this->hasBarrier = hasBarrier;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, -0x20(%rbp)
leaq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %r15
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x1732a(%rip), %rax     # 0x23538
movq %rax, (%rbx)
movl %r8d, 0x8(%rbx)
movl %r9d, 0xc(%rbx)
movl %esi, 0x10(%rbx)
movl %edx, 0x14(%rbx)
leaq 0x1178a(%rip), %rcx     # 0x1d9b0
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4200
movb $0x40, 0x38(%rbx)
leaq 0x3c(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51e2
movb 0x10(%rbp), %al
movl $0x8c, 0x44(%rbx)
movb %al, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x17100(%rip), %rax     # 0x23368
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xc283
movq (%r15), %rsi
incq %rsi
callq 0x4170
movq %r14, %rdi
callq 0x4250
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/orc.cc
// Function: Orc::Orc(int, int, Posn)
Orc::Orc(int HP, int gold, Posn position)
{
    this->Atk = 30;
    this->Def = 25;
    this->HP = HP;
    this->gold = gold;
    this->race = "Orc";
    this->symbol = '@';
    this->position = position;
    this->MaxHP = 1800;
    this->hasBarrier = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, -0x20(%rbp)
leaq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %r15
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x172a0(%rip), %rax     # 0x235d0
movq %rax, (%rbx)
movabsq $0x190000001e, %rax     # imm = 0x190000001E
movq %rax, 0x8(%rbx)
movl %esi, 0x10(%rbx)
movl %edx, 0x14(%rbx)
leaq 0x11682(%rip), %rcx     # 0x1d9d0
movl $0x3, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4200
movb $0x40, 0x38(%rbx)
leaq 0x3c(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51e2
movl $0x708, 0x44(%rbx)      # imm = 0x708
movb $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x16fda(%rip), %rax     # 0x23368
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xc3a9
movq (%r15), %rsi
incq %rsi
callq 0x4170
movq %r14, %rdi
callq 0x4250
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/orc.cc
// Function: Orc::Orc(int, int, Posn, int, int, bool)
Orc::Orc(int HP, int gold, Posn position, int Atk, int Def, bool hasBarrier)
{
    this->Atk = Atk;
    this->Def = Def;
    this->HP = HP;
    this->gold = gold;
    this->race = "Orc";
    this->symbol = '@';
    this->position = position;
    this->MaxHP = 1800;
    this->hasBarrier = hasBarrier;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, -0x20(%rbp)
leaq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %r15
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x171ee(%rip), %rax     # 0x235d0
movq %rax, (%rbx)
movl %r8d, 0x8(%rbx)
movl %r9d, 0xc(%rbx)
movl %esi, 0x10(%rbx)
movl %edx, 0x14(%rbx)
leaq 0x115d6(%rip), %rcx     # 0x1d9d0
movl $0x3, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4200
movb $0x40, 0x38(%rbx)
leaq 0x3c(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51e2
movb 0x10(%rbp), %al
movl $0x708, 0x44(%rbx)      # imm = 0x708
movb %al, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x16f2c(%rip), %rax     # 0x23368
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xc457
movq (%r15), %rsi
incq %rsi
callq 0x4170
movq %r14, %rdi
callq 0x4250
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/elf.cc
// Function: Elf::Elf(int, int, Posn)
Elf::Elf(int HP, int gold, Posn position)
{
    this->Atk = 30;
    this->Def = 10;
    this->HP = HP;
    this->gold = gold;
    this->race = "Elf";
    this->symbol = '@';
    this->position = position;
    this->MaxHP = 140;
    this->hasBarrier = false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, -0x20(%rbp)
leaq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %r15
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x15084(%rip), %rax     # 0x23668
movq %rax, (%rbx)
movabsq $0xa0000001e, %rax      # imm = 0xA0000001E
movq %rax, 0x8(%rbx)
movl %esi, 0x10(%rbx)
movl %edx, 0x14(%rbx)
leaq 0xf064(%rip), %rcx      # 0x1d666
movl $0x3, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4200
movb $0x40, 0x38(%rbx)
leaq 0x3c(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51e2
movl $0x8c, 0x44(%rbx)
movb $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x14d26(%rip), %rax     # 0x23368
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xe65d
movq (%r15), %rsi
incq %rsi
callq 0x4170
movq %r14, %rdi
callq 0x4250
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/elf.cc
// Function: Elf::Elf(int, int, Posn, int, int, bool)
Elf::Elf(int HP, int gold, Posn position, int Atk, int Def, bool hasBarrier){
    this->Atk = Atk;
    this->Def = Def;
    this->HP = HP;
    this->gold = gold;
    this->race = "Elf";
    this->symbol = '@';
    this->position = position;
    this->MaxHP = 140;
    this->hasBarrier = hasBarrier;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, -0x20(%rbp)
leaq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %r15
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x14fd2(%rip), %rax     # 0x23668
movq %rax, (%rbx)
movl %r8d, 0x8(%rbx)
movl %r9d, 0xc(%rbx)
movl %esi, 0x10(%rbx)
movl %edx, 0x14(%rbx)
leaq 0xefb8(%rip), %rcx      # 0x1d666
movl $0x3, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4200
movb $0x40, 0x38(%rbx)
leaq 0x3c(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51e2
movb 0x10(%rbp), %al
movl $0x8c, 0x44(%rbx)
movb %al, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x14c78(%rip), %rax     # 0x23368
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xe70b
movq (%r15), %rsi
incq %rsi
callq 0x4170
movq %r14, %rdi
callq 0x4250
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/dwarf.cc
// Function: Dwarf::Dwarf(int, int, Posn)
Dwarf::Dwarf(int HP, int gold, Posn position)
{
    this->Atk = 20;
    this->Def = 30;
    this->HP = HP;
    this->gold = gold;
    this->race = "Dwarf";
    this->symbol = '@';
    this->position = position;
    this->MaxHP = 1000;
    this->hasBarrier = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, -0x20(%rbp)
leaq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %r15
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x13ec4(%rip), %rax     # 0x23700
movq %rax, (%rbx)
movabsq $0x1e00000014, %rax     # imm = 0x1E00000014
movq %rax, 0x8(%rbx)
movl %esi, 0x10(%rbx)
movl %edx, 0x14(%rbx)
leaq 0xe203(%rip), %rcx      # 0x1da5d
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4200
movb $0x40, 0x38(%rbx)
leaq 0x3c(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51e2
movl $0x3e8, 0x44(%rbx)      # imm = 0x3E8
movb $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x13ace(%rip), %rax     # 0x23368
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xf8b5
movq (%r15), %rsi
incq %rsi
callq 0x4170
movq %r14, %rdi
callq 0x4250
nop
// File: /workspace/github_cpp_makefile_star2_O1/malcolmyeh[P]CC3K/dwarf.cc
// Function: Dwarf::Dwarf(int, int, Posn, int, int, bool)
Dwarf::Dwarf(int HP, int gold, Posn position, int Atk, int Def, bool hasBarrier)
{
    this->Atk = Atk;
    this->Def = Def;
    this->HP = HP;
    this->gold = gold;
    this->race = "Dwarf";
    this->symbol = '@';
    this->position = position;
    this->MaxHP = 1000;
    this->hasBarrier = hasBarrier;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rcx, -0x20(%rbp)
leaq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %r15
movq %r15, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x13e12(%rip), %rax     # 0x23700
movq %rax, (%rbx)
movl %r8d, 0x8(%rbx)
movl %r9d, 0xc(%rbx)
movl %esi, 0x10(%rbx)
movl %edx, 0x14(%rbx)
leaq 0xe157(%rip), %rcx      # 0x1da5d
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4200
movb $0x40, 0x38(%rbx)
leaq 0x3c(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51e2
movb 0x10(%rbp), %al
movl $0x3e8, 0x44(%rbx)      # imm = 0x3E8
movb %al, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x13a20(%rip), %rax     # 0x23368
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xf963
movq (%r15), %rsi
incq %rsi
callq 0x4170
movq %r14, %rdi
callq 0x4250
nop