LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kaiming[P]Chamber-Crawler-3k/Enemy/elf.cc
// Function: Elf::attack(Goblin&)
bool Elf::attack(Goblin & g) {
    // SPECIAL EFFECT: gets two attacks 
    for (int i = 0; i < 2; i++) {
        // Determine attack success/fail
        if (std::rand() % 2 == 0) {
            // Attack failed
            continue;
        } // Else, attack proceeds
        
        // Calculate damage dealt
        double damage = std::ceil(100/(100 + g.getDef()) * this->getAtk());

        // Set new defender HP
        g.setHP(g.getHP() - damage);
    }

    // Check if defender died
    if (g.getHP() <= 0) {
        g.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x357ef
callq 0x60c0
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3577d
jmp 0x357e1
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x30(%rbp), %rdi
movsd 0x88ae(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x88a2(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x38(%rbp), %rdi
subsd -0x28(%rbp), %xmm0
callq 0x347c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3575f
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x35816
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x3581a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kaiming[P]Chamber-Crawler-3k/Enemy/orc.cc
// Function: Orc::attack(Goblin&)
bool Orc::attack(Goblin & g) {
    // SPECIAL EFFECT: does 50% more damage
    // Determine attack success/fail
    if (std::rand() % 2 == 0) {
        // Attack failed
        return false;
    } // Else, attack proceeds
    
    // Calculate damage dealt
    double damage = std::ceil(100/(100 + g.getDef()) * this->getAtk()) * 1.5;

    // Set new defender HP
    g.setHP(g.getHP() - damage);

    // Check if defender died
    if (g.getHP() <= 0) {
        g.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x60c0
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x36be3
movb $0x0, -0x1(%rbp)
jmp 0x36c7e
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x7448(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x743c(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd 0x74b5(%rip), %xmm1     # 0x3e0e0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x36c7a
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x36c7e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
nopl (%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/drow.cc
// Function: Drow::attack(Human&)
bool Drow::attack(Human& h) {    
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + h.getDef()) * this->getAtk());

    // Set new defender HP
    h.setHP(h.getHP() - damage);

    // Check if defender died
    if (h.getHP() <= 0) {
        h.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x56a3(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x5697(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x38a13
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x38a17
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/drow.cc
// Function: Drow::attack(Dwarf&)
bool Drow::attack(Dwarf& d) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + d.getDef()) * this->getAtk());

    // Set new defender HP
    d.setHP(d.getHP() - damage);

    // Check if defender died
    if (d.getHP() <= 0) {
        d.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x55e3(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x55d7(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x38ad3
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x38ad7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/drow.cc
// Function: Drow::attack(Elf&)
bool Drow::attack(Elf& e) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + e.getDef()) * this->getAtk());

    // Set new defender HP
    e.setHP(e.getHP() - damage);

    // Check if defender died
    if (e.getHP() <= 0) {
        e.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x5523(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x5517(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x38b93
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x38b97
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/drow.cc
// Function: Drow::attack(Orc&)
bool Drow::attack(Orc& o) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + o.getDef()) * this->getAtk());

    // Set new defender HP
    o.setHP(o.getHP() - damage);

    // Check if defender died
    if (o.getHP() <= 0) {
        o.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x5463(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x5457(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x38c53
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x38c57
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/drow.cc
// Function: Drow::attack(Dragon&)
bool Drow::attack(Dragon& drag) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + drag.getDef()) * this->getAtk());

    // Set new defender HP
    drag.setHP(drag.getHP() - damage);

    // Check if defender died
    if (drag.getHP() <= 0) {
        drag.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x52e3(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x52d7(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x38dd3
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x38dd7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/drow.cc
// Function: Drow::attack(Halfling&)
bool Drow::attack(Halfling& half) {
    // Determine attack success/fail
    if (std::rand() % 2 == 0) {
        // Attack failed
        return false;
    } // Else, attack proceeds

    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + half.getDef()) * this->getAtk());

    // Set new defender HP
    half.setHP(half.getHP() - damage);

    // Check if defender died
    if (half.getHP() <= 0) {
        half.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x60c0
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x38e23
movb $0x0, -0x1(%rbp)
jmp 0x38eb2
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x5208(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x51fc(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x38eae
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x38eb2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/goblin.cc
// Function: Goblin::attack(Human&)
bool Goblin::attack(Human& h) {    
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + h.getDef()) * this->getAtk());

    // Set new defender HP
    h.setHP(h.getHP() - damage);

    // Check if defender died
    if (h.getHP() <= 0) {
        h.setHP(0);
        // add 5 gold to inventory
        this->setGold(this->getGold() + 5);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x5013(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x5007(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x390ba
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movq -0x38(%rbp), %rdi
callq 0x396b0
movq -0x38(%rbp), %rdi
movl %eax, %esi
addl $0x5, %esi
callq 0x396d0
movb $0x1, -0x1(%rbp)
jmp 0x390be
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/goblin.cc
// Function: Goblin::attack(Dwarf&)
bool Goblin::attack(Dwarf& d) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + d.getDef()) * this->getAtk());

    // Set new defender HP
    d.setHP(d.getHP() - damage);

    // Check if defender died
    if (d.getHP() <= 0) {
        d.setHP(0);
        // add 5 gold to inventory
        this->setGold(this->getGold() + 5);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x4f43(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x4f37(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3918a
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movq -0x38(%rbp), %rdi
callq 0x396b0
movq -0x38(%rbp), %rdi
movl %eax, %esi
addl $0x5, %esi
callq 0x396d0
movb $0x1, -0x1(%rbp)
jmp 0x3918e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/goblin.cc
// Function: Goblin::attack(Orc&)
bool Goblin::attack(Orc& o) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + o.getDef()) * this->getAtk());

    // Set new defender HP
    o.setHP(o.getHP() - damage);

    // Check if defender died
    if (o.getHP() <= 0) {
        o.setHP(0);
        // add 5 gold to inventory
        this->setGold(this->getGold() + 5);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x4da3(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x4d97(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3932a
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movq -0x38(%rbp), %rdi
callq 0x396b0
movq -0x38(%rbp), %rdi
movl %eax, %esi
addl $0x5, %esi
callq 0x396d0
movb $0x1, -0x1(%rbp)
jmp 0x3932e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/goblin.cc
// Function: Goblin::attack(Merchant&)
bool Goblin::attack(Merchant& m) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + m.getDef()) * this->getAtk());

    // Set new defender HP
    m.setHP(m.getHP() - damage);

    // Check if defender died
    if (m.getHP() <= 0) {
        m.setHP(0);
        // add 5 gold to inventory
        this->setGold(this->getGold() + 5);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x38(%rbp), %rdi
movsd 0x4cd3(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x4cc7(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x393fa
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movq -0x38(%rbp), %rdi
callq 0x396b0
movq -0x38(%rbp), %rdi
movl %eax, %esi
addl $0x5, %esi
callq 0x396d0
movb $0x1, -0x1(%rbp)
jmp 0x393fe
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/goblin.cc
// Function: Goblin::attack(Halfling&)
bool Goblin::attack(Halfling& half) {
    // Determine attack success/fail
    if (std::rand() % 2 == 0) {
        // Attack failed
        return false;
    } // Else, attack proceeds
    
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + half.getDef()) * this->getAtk());

    // Set new defender HP
    half.setHP(half.getHP() - damage);

    // Check if defender died
    if (half.getHP() <= 0) {
        half.setHP(0);
        // add 5 gold to inventory
        this->setGold(this->getGold() + 5);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x60c0
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x39513
movb $0x0, -0x1(%rbp)
jmp 0x395b9
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x4b18(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x4b0c(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x395b5
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movq -0x28(%rbp), %rdi
callq 0x396b0
movq -0x28(%rbp), %rdi
movl %eax, %esi
addl $0x5, %esi
callq 0x396d0
movb $0x1, -0x1(%rbp)
jmp 0x395b9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Player/vampire.cc
// Function: Vampire::attack(Human&)
bool Vampire::attack(Human& h) {    
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + h.getDef()) * this->getAtk());

    // Set new defender HP
    h.setHP(h.getHP() - damage);

    // gains 5 health every successful attack
    this->setHP(this->getHP() + 5);

    // Check if defender died
    if (h.getHP() <= 0) {
        h.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x3ba3(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x3b97(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x28(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
movsd 0x3bb7(%rip), %xmm1     # 0x3e0b8
addsd %xmm1, %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3a531
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x3a535
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: kaiming[P]Chamber-Crawler-3k/Player/vampire.cc
// Function: Vampire::attack(Dwarf&)
bool Vampire::attack(Dwarf& d) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + d.getDef()) * this->getAtk());

    // Set new defender HP
    d.setHP(d.getHP() - damage);

    // alergic to Dwarfs so lose 5 health every successful attack
    this->setHP(this->getHP() - 5);

    // Check if defender died
    if (d.getHP() <= 0) {
        d.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x3ad3(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x3ac7(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x28(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
movsd 0x3ae7(%rip), %xmm1     # 0x3e0b8
subsd %xmm1, %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3a601
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x3a605
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: kaiming[P]Chamber-Crawler-3k/Player/vampire.cc
// Function: Vampire::attack(Elf&)
bool Vampire::attack(Elf& e) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + e.getDef()) * this->getAtk());

    // Set new defender HP
    e.setHP(e.getHP() - damage);

    // gains 5 health every successful attack
    this->setHP(this->getHP() + 5);

    // Check if defender died
    if (e.getHP() <= 0) {
        e.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x3a03(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x39f7(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x28(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
movsd 0x3a17(%rip), %xmm1     # 0x3e0b8
addsd %xmm1, %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3a6d1
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x3a6d5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: kaiming[P]Chamber-Crawler-3k/Player/vampire.cc
// Function: Vampire::attack(Merchant&)
bool Vampire::attack(Merchant& m) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + m.getDef()) * this->getAtk());

    // Set new defender HP
    m.setHP(m.getHP() - damage);

    // gains 5 health every successful attack
    this->setHP(this->getHP() + 5);

    // Check if defender died
    if (m.getHP() <= 0) {
        m.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x3873(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x3867(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x28(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
movsd 0x3887(%rip), %xmm1     # 0x3e0b8
addsd %xmm1, %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3a861
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x3a865
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: kaiming[P]Chamber-Crawler-3k/Player/vampire.cc
// Function: Vampire::attack(Dragon&)
bool Vampire::attack(Dragon& drag) {
    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + drag.getDef()) * this->getAtk());

    // Set new defender HP
    drag.setHP(drag.getHP() - damage);

    // gains 5 health every successful attack
    this->setHP(this->getHP() + 5);

    // Check if defender died
    if (drag.getHP() <= 0) {
        drag.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x37a3(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x3797(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x28(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
movsd 0x37b7(%rip), %xmm1     # 0x3e0b8
addsd %xmm1, %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3a931
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x3a935
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: kaiming[P]Chamber-Crawler-3k/Player/vampire.cc
// Function: Vampire::attack(Halfling&)
bool Vampire::attack(Halfling& half) {
    // Determine attack success/fail
    if (std::rand() % 2 == 0) {
        // Attack failed
        return false;
    } // Else, attack proceeds

    // Calculate damage dealt
    double damage = std::ceil(100 / (100 + half.getDef()) * this->getAtk());

    // Set new defender HP
    half.setHP(half.getHP() - damage);

    // gains 5 health every successful attack
    this->setHP(this->getHP() + 5);

    // Check if defender died
    if (half.getHP() <= 0) {
        half.setHP(0);
        return true;
    }

    // Defender alive otherwise
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x60c0
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3a973
movb $0x0, -0x1(%rbp)
jmp 0x3aa20
movq -0x18(%rbp), %rdi
callq 0x347a0
movq -0x28(%rbp), %rdi
movsd 0x36b8(%rip), %xmm1     # 0x3e040
addsd %xmm0, %xmm1
movsd 0x36ac(%rip), %xmm0     # 0x3e040
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6060
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34760
movq -0x30(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
callq 0x347c0
movq -0x28(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
movsd 0x36cc(%rip), %xmm1     # 0x3e0b8
addsd %xmm1, %xmm0
callq 0x347c0
movq -0x18(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3aa1c
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
movb $0x1, -0x1(%rbp)
jmp 0x3aa20
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Potion/ph.cc
// Function: PH::applyEffects(Player&, double)
void PH::applyEffects(Player& player, double multiplier) {
    // if players HP is at least 10 HP
    if (player.getHP() >= (10 * multiplier)) {
        player.setHP(player.getHP() - (10 * multiplier));
    } else {
        player.setHP(0);
    } // else set HP to 0
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34760
movsd 0x32fa(%rip), %xmm1     # 0x3e070
mulsd -0x18(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x3adb5
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34760
movq -0x20(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x34aa(%rip), %xmm2     # 0x3e250
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x347c0
jmp 0x3adc1
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Potion/rh.cc
// Function: RH::applyEffects(Player&, double)
void RH::applyEffects(Player& player, double multiplier) {
    // if player is a vampire or player health is at least 10 HP away from max
    if ((player.getMaxHP() < 0) || (player.getHP() + (10 * multiplier) <= player.getMaxHP())) {
        player.setHP(player.getHP() + (10 * multiplier));
    } else {
        player.setHP(player.getMaxHP());
    } // else add health to full
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39700
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x3af54
movq -0x10(%rbp), %rdi
callq 0x34760
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x313d(%rip), %xmm2     # 0x3e070
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39700
movsd -0x20(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x3af88
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34760
movq -0x28(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x30f7(%rip), %xmm2     # 0x3e070
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x347c0
jmp 0x3afa2
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39700
movq -0x30(%rbp), %rdi
callq 0x347c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kaiming[P]Chamber-Crawler-3k/Potion/wa.cc
// Function: WA::applyEffects(Player&, double)
void WA::applyEffects(Player& player, double multiplier) {
    if (player.getAtk() - (5 * multiplier) >= 0) {
        player.setAtk(player.getAtk() - (5 * multiplier));
    } else {
        player.setAtk(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34780
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x31da(%rip), %xmm2     # 0x3e268
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3b0d3
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34780
movq -0x20(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x31a4(%rip), %xmm2     # 0x3e268
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x347e0
jmp 0x3b0df
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x347e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kaiming[P]Chamber-Crawler-3k/Potion/wd.cc
// Function: WD::applyEffects(Player&, double)
void WD::applyEffects(Player& player, double multiplier) {
    // player def can never drop below 0
    if (player.getDef() - (5 * multiplier) >= 0) {
        player.setDef(player.getDef() - (5 * multiplier));
    } else {
        player.setDef(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x347a0
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x309a(%rip), %xmm2     # 0x3e268
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3b213
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x347a0
movq -0x20(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x3064(%rip), %xmm2     # 0x3e268
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x34820
jmp 0x3b21f
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x34820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kaiming[P]Chamber-Crawler-3k/Tile/walkabletile.cc
// Function: WalkableTile::WalkableTile(char, int, int, std::shared_ptr<Character>, std::shared_ptr<Potion>, std::shared_ptr<Gold>, bool)
WalkableTile::WalkableTile(char type, int x, int y, std::shared_ptr<Character> occupant, std::shared_ptr<Potion> potion, std::shared_ptr<Gold> gold, bool exit) :
    Tile {type, x, y},
    occupant {occupant},
    potion {potion},
    gold {gold},
    exit {exit},
    roomNum {-1}
{}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r9, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %r10, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb -0x9(%rbp), %al
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movsbl %al, %esi
callq 0x3bd90
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdi
leaq 0x1de6a(%rip), %rax     # 0x59d78
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
callq 0x38340
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x2f0f0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x125e0
movq -0x38(%rbp), %rax
movb -0x29(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x48(%rax)
movl $0xffffffff, 0x4c(%rax) # imm = 0xFFFFFFFF
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sagardesd[P]CoolString/include/stringops.hpp
// Function: cool::stringops::replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void replace_all(std::string& sourceString, std::string subString, std::string newSubstring)
	{
		std::string tempString;
		int startPos = 0;
		int pos = sourceString.find(subString, startPos);
		while(pos != std::string::npos)
		{
			tempString += sourceString.substr(startPos, pos - startPos);
			tempString += newSubstring;
			startPos = pos + subString.size();
			pos = sourceString.find(subString, startPos);
		}
		if(startPos <  sourceString.size())
		{
			tempString += sourceString.substr(startPos);
		}
		sourceString = tempString;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x21b0
movq -0x98(%rbp), %rsi
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
callq 0x2250
movl %eax, -0x40(%rbp)
movslq -0x40(%rbp), %rax
cmpq $-0x1, %rax
je 0x24af
movq -0x8(%rbp), %rsi
movslq -0x3c(%rbp), %rdx
movl %edx, %ecx
movl -0x40(%rbp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq -0x60(%rbp), %rdi
callq 0x2140
jmp 0x2417
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2180
jmp 0x2426
leaq -0x60(%rbp), %rdi
callq 0x20c0
movq -0xa0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2180
jmp 0x2441
movq -0x98(%rbp), %rdi
movslq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x20d0
movq -0x98(%rbp), %rsi
movq %rax, %rcx
movq -0xa8(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
callq 0x2250
movl %eax, -0x40(%rbp)
jmp 0x23ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x254a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x20c0
jmp 0x254a
movslq -0x3c(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x2529
movq -0x8(%rbp), %rsi
movslq -0x3c(%rbp), %rdx
leaq -0x90(%rbp), %rdi
movq $-0x1, %rcx
callq 0x2140
jmp 0x24ef
leaq -0x38(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2180
jmp 0x2501
leaq -0x90(%rbp), %rdi
callq 0x20c0
jmp 0x2529
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x20c0
jmp 0x254a
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2030
jmp 0x2538
leaq -0x38(%rbp), %rdi
callq 0x20c0
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq -0x68(%rbp), %rdi
callq 0x2220
nopl (%rax)
// File: sagardesd[P]CoolString/include/stringops.hpp
// Function: cool::stringops::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
StringVector split(std::string sourceString, std::string delemeter)
	{
		StringVector result;
		if(delemeter.empty())
		{
			delemeter = " ";
		}
		int delemeterSize = delemeter.size();
		std::string token;
		int startPos = 0;
		int pos = sourceString.find(delemeter);
		while(pos != std::string::npos)
		{
			token = sourceString.substr(startPos, pos - startPos);
			result.push_back(token);
			startPos = pos + delemeterSize;
			pos = sourceString.find(delemeter, startPos);
		}
		if(startPos < sourceString.size())
		{
			result.push_back(sourceString.substr(startPos));
		}	
		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xa0(%rbp)
movq %rsi, -0xb8(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x36e0
movq -0xa0(%rbp), %rdi
callq 0x2200
testb $0x1, %al
jne 0x25b1
jmp 0x25d9
movq -0xa0(%rbp), %rdi
leaq 0x3c76(%rip), %rsi      # 0x6235
callq 0x2190
jmp 0x25c6
jmp 0x25d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2774
movq -0xa0(%rbp), %rdi
callq 0x20d0
movl %eax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x21b0
movq -0xb8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movl $0x0, -0x54(%rbp)
xorl %eax, %eax
movl %eax, %edx
callq 0x2250
movl %eax, -0x58(%rbp)
movslq -0x58(%rbp), %rax
cmpq $-0x1, %rax
je 0x26b5
movq -0xb8(%rbp), %rsi
movslq -0x54(%rbp), %rdx
movl %edx, %ecx
movl -0x58(%rbp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq -0x78(%rbp), %rdi
callq 0x2140
jmp 0x2640
leaq -0x50(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x78(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
callq 0x2170
movq -0xc8(%rbp), %rdi
callq 0x20c0
movq -0xb0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x3700
jmp 0x267c
movq -0xa0(%rbp), %rsi
movq -0xb8(%rbp), %rdi
movl -0x58(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rdx
callq 0x2250
movl %eax, -0x58(%rbp)
jmp 0x2612
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x274d
movq -0xb8(%rbp), %rdi
movslq -0x54(%rbp), %rax
movq %rax, -0xd0(%rbp)
callq 0x20d0
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0x2738
movq -0xb8(%rbp), %rsi
movslq -0x54(%rbp), %rdx
leaq -0x98(%rbp), %rdi
movq $-0x1, %rcx
callq 0x2140
jmp 0x26fb
movq -0xb0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3770
jmp 0x2710
leaq -0x98(%rbp), %rdi
callq 0x20c0
jmp 0x2738
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x20c0
jmp 0x274d
movb $0x1, -0x19(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20c0
testb $0x1, -0x19(%rbp)
jne 0x2764
jmp 0x2758
leaq -0x50(%rbp), %rdi
callq 0x20c0
jmp 0x2774
movq -0xb0(%rbp), %rdi
callq 0x37a0
movq -0xa8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x37a0
movq -0x28(%rbp), %rdi
callq 0x2220
nopl (%rax)
// File: sagardesd[P]CoolString/include/stringops.hpp
// Function: cool::stringops::find_all_occourance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
IntVector find_all_occourance(std::string sourceString, std::string subString)
	{
		IntVector result;
		if(subString.empty() || (subString.size() > sourceString.size()))
		{
			return result;
		}
		int substringSize = subString.size();
		int pos = sourceString.find(subString);
		while(pos != std::string::npos)
		{
			result.push_back(pos);
			pos = sourceString.find(subString, pos + substringSize);
		}
		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3800
movq -0x40(%rbp), %rdi
callq 0x2200
testb $0x1, %al
jne 0x27ef
movq -0x40(%rbp), %rdi
callq 0x20d0
movq -0x58(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x20d0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jbe 0x27fc
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
jmp 0x2872
movq -0x40(%rbp), %rdi
callq 0x20d0
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, -0x24(%rbp)
xorl %eax, %eax
movl %eax, %edx
callq 0x2250
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rax
cmpq $-0x1, %rax
je 0x2867
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3820
jmp 0x2835
movq -0x40(%rbp), %rsi
movq -0x58(%rbp), %rdi
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rdx
callq 0x2250
movl %eax, -0x28(%rbp)
jmp 0x281c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3890
jmp 0x288b
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2881
movq -0x50(%rbp), %rdi
callq 0x3890
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: sagardesd[P]CoolString/include/stringops.hpp
// Function: cool::stringops::remove_all_occourance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void remove_all_occourance(std::string& sourceString, std::string subString)
	{
		if(subString.empty() || (subString.size() > sourceString.size()))
		{
			return;
		}	
		int startPos = 0;
		int substrPos = 0;
		int substrSize = subString.size();
		while((substrPos = sourceString.find(subString, startPos)) != std::string::npos)
		{
			sourceString.erase(substrPos, substrSize);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2200
testb $0x1, %al
jne 0x28ea
movq -0x28(%rbp), %rdi
callq 0x20d0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jbe 0x28ec
jmp 0x2935
movq -0x28(%rbp), %rdi
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x20d0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rdx
callq 0x2250
movl %eax, -0x18(%rbp)
cltq
cmpq $-0x1, %rax
je 0x2935
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2040
jmp 0x2906
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sagardesd[P]CoolString/include/stringops.hpp
// Function: cool::stringops::remove_first_occourance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void remove_first_occourance(std::string& sourceString, std::string subString)
	{
		if(subString.empty() || (subString.size() > sourceString.size()))
		{
			return;
		}
		int pos = sourceString.find(subString);
		if(pos != std::string::npos)
		{
			sourceString.erase(pos, subString.size());
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2200
testb $0x1, %al
jne 0x298a
movq -0x20(%rbp), %rdi
callq 0x20d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jbe 0x298c
jmp 0x29d3
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x2250
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $-0x1, %rax
je 0x29d3
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x20d0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x2040
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sagardesd[P]CoolString/include/stringops.hpp
// Function: cool::stringops::remove_last_occourance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void remove_last_occourance(std::string& sourceString, std::string subString)
	{
		if(subString.empty() || (subString.size() > sourceString.size()))
		{
			return;
		}
		int startPos = 0;
		int oldPos = 0;
		int pos = 0;
		while((pos = sourceString.find(subString, startPos)) != std::string::npos)
		{
			oldPos = pos;
			startPos = pos + subString.size();
		}	
		if(oldPos < sourceString.size())
		{
			sourceString.erase(oldPos, subString.size());
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2200
testb $0x1, %al
jne 0x2a2a
movq -0x28(%rbp), %rdi
callq 0x20d0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jbe 0x2a2f
jmp 0x2acc
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rdx
callq 0x2250
movl %eax, -0x1c(%rbp)
cltq
cmpq $-0x1, %rax
je 0x2a86
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x20d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x2a44
movslq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2acc
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x20d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x2040
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)