LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::buy_Spell(Spell*)
void Hero::buy_Spell(Spell * s){
    if(Money < s->get_price()){
        cout << "Not enough money!" << endl;
        return;
    }

    Money -= s->get_price();
    Spells.push_front(s);
    cout << "You succesfully bought a new SPELL: " << s->get_name() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x48(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12670
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x54b4
movq 0x19b39(%rip), %rdi     # 0x1efd0
leaq 0xfddd(%rip), %rsi      # 0x1527b
callq 0x31e0
movq %rax, %rdi
movq 0x19b13(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x552e
movq -0x10(%rbp), %rdi
callq 0x12670
movq -0x48(%rbp), %rdi
movl %eax, %ecx
movl 0x48(%rdi), %eax
subl %ecx, %eax
movl %eax, 0x48(%rdi)
subq $-0x80, %rdi
leaq -0x10(%rbp), %rsi
callq 0x7710
movq 0x19af1(%rip), %rdi     # 0x1efd0
leaq 0xfe18(%rip), %rsi      # 0x152fe
callq 0x31e0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x12640
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x31b0
movq %rax, -0x50(%rbp)
jmp 0x5513
movq -0x50(%rbp), %rdi
movq 0x19aa2(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x5525
leaq -0x30(%rbp), %rdi
callq 0x3120
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::display_stats()
void Hero::display_stats(){
    cout << name << "   Level: " << Level << endl;
    cout << "XP: " << exp << "/" << NextLvlExp << endl;
    cout << "HP: " << HealthPower << endl;
    cout << "Coins: " << Money << endl; 
    cout << "Strength: " << Strength << endl;
    cout << "Agility: " << Agility << endl;
    cout << "Dexterity: " << Dexterity << endl;
    cout << "Defense: " << Defense << endl;
    cout << "MAgic Power: " << MagicPower << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
addq $0x8, %rsi
movq 0x19151(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, %rdi
leaq 0xf4d5(%rip), %rsi      # 0x15363
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x19114(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x19118(%rip), %rdi     # 0x1efd0
leaq 0xf4af(%rip), %rsi      # 0x1536e
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %esi
callq 0x3320
movq %rax, %rdi
leaq 0xf496(%rip), %rsi      # 0x15373
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x190c5(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x190c9(%rip), %rdi     # 0x1efd0
leaq 0xf467(%rip), %rsi      # 0x15375
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x19094(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x19098(%rip), %rdi     # 0x1efd0
leaq 0xf43b(%rip), %rsi      # 0x1537a
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x19063(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x19067(%rip), %rdi     # 0x1efd0
leaq 0xf412(%rip), %rsi      # 0x15382
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x19032(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x19036(%rip), %rdi     # 0x1efd0
leaq 0xf3ec(%rip), %rsi      # 0x1538d
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x19001(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x19005(%rip), %rdi     # 0x1efd0
leaq 0xf3c5(%rip), %rsi      # 0x15397
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x18fd0(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x18fd4(%rip), %rdi     # 0x1efd0
leaq 0xf3a0(%rip), %rsi      # 0x153a3
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x18f9f(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x18fa3(%rip), %rdi     # 0x1efd0
leaq 0xf379(%rip), %rsi      # 0x153ad
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x18f6e(%rip), %rsi     # 0x1efc0
callq 0x3210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::display_Weapons()
void Hero::display_Weapons(){
    list<Weapon*>::iterator it;

    for(it = Weapons.begin(); it != Weapons.end(); ++it){
        cout << (*it)->get_name() << endl;
        cout << "Damage: " << (*it)->get_damage() << endl;
        cout << "Hands needed: " << (*it)->get_handsNeeded() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7ad0
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
callq 0x7b50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
callq 0x7bb0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7b80
testb $0x1, %al
jne 0x60c0
jmp 0x61b4
leaq -0x10(%rbp), %rdi
callq 0x7be0
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x12640
movq -0x68(%rbp), %rsi
movq 0x18eec(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, -0x60(%rbp)
jmp 0x60ef
movq -0x60(%rbp), %rdi
movq 0x18ec6(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x6101
leaq -0x40(%rbp), %rdi
callq 0x3120
movq 0x18ebf(%rip), %rdi     # 0x1efd0
leaq 0xf066(%rip), %rsi      # 0x1517e
callq 0x31e0
movq %rax, -0x78(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7be0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rdi
movl %eax, %esi
callq 0x3320
movq %rax, %rdi
movq 0x18e78(%rip), %rsi     # 0x1efc0
callq 0x3210
movq 0x18e7c(%rip), %rdi     # 0x1efd0
leaq 0xf260(%rip), %rsi      # 0x153bb
callq 0x31e0
movq %rax, -0x70(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7be0
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x70(%rbp), %rdi
movl %eax, %esi
callq 0x3320
movq %rax, %rdi
movq 0x18e36(%rip), %rsi     # 0x1efc0
callq 0x3210
leaq -0x10(%rbp), %rdi
callq 0x7c00
jmp 0x6099
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3120
jmp 0x61bd
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::display_Armors()
void Hero::display_Armors(){
    list<Armor*>::iterator it;

    for(it = Armors.begin(); it != Armors.end(); ++it){
        cout << (*it)->get_name() << endl;
        cout << "Defense: " << (*it)->get_protection() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7af0
movq -0x58(%rbp), %rdi
addq $0x98, %rdi
callq 0x7c20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x58(%rbp), %rdi
addq $0x98, %rdi
callq 0x7c80
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7c50
testb $0x1, %al
jne 0x6233
jmp 0x62e5
leaq -0x10(%rbp), %rdi
callq 0x7cb0
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x12640
movq -0x68(%rbp), %rsi
movq 0x18d79(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, -0x60(%rbp)
jmp 0x6262
movq -0x60(%rbp), %rdi
movq 0x18d53(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x6274
leaq -0x40(%rbp), %rdi
callq 0x3120
movq 0x18d4c(%rip), %rdi     # 0x1efd0
leaq 0xf118(%rip), %rsi      # 0x153a3
callq 0x31e0
movq %rax, -0x70(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7cb0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x70(%rbp), %rdi
movl %eax, %esi
callq 0x3320
movq %rax, %rdi
movq 0x18d05(%rip), %rsi     # 0x1efc0
callq 0x3210
leaq -0x10(%rbp), %rdi
callq 0x7cd0
jmp 0x6209
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3120
jmp 0x62eb
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::display_Potions()
void Hero::display_Potions(){
    list<Potion*>::iterator it;

    if(Potions.empty()){
        cout << "You don't have any Potions" << endl;
        return;
    }

    for(it = Potions.begin(); it != Potions.end(); ++it){
        cout << (*it)->get_name() << endl;
        cout << "Stat: " << (*it)->get_statname();
        cout << "% " << (*it)->get_buff() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7b10
movq -0x78(%rbp), %rdi
addq $0xb0, %rdi
callq 0x7e90
testb $0x1, %al
jne 0x6336
jmp 0x635d
movq 0x18c93(%rip), %rdi     # 0x1efd0
leaq 0xf086(%rip), %rsi      # 0x153ca
callq 0x31e0
movq %rax, %rdi
movq 0x18c6d(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x64cc
movq -0x78(%rbp), %rdi
addq $0xb0, %rdi
callq 0x7cf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rdi
addq $0xb0, %rdi
callq 0x7d50
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7d20
testb $0x1, %al
jne 0x63a3
jmp 0x64cc
leaq -0x10(%rbp), %rdi
callq 0x7d80
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x12640
movq -0x88(%rbp), %rsi
movq 0x18c03(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, -0x80(%rbp)
jmp 0x63d8
movq -0x80(%rbp), %rdi
movq 0x18bdd(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x63ea
leaq -0x40(%rbp), %rdi
callq 0x3120
movq 0x18bd6(%rip), %rdi     # 0x1efd0
leaq 0xefe4(%rip), %rsi      # 0x153e5
callq 0x31e0
movq %rax, -0x98(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7d80
movq (%rax), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x12cd0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x31b0
jmp 0x643e
leaq -0x70(%rbp), %rdi
callq 0x3120
movq 0x18b82(%rip), %rdi     # 0x1efd0
leaq 0xef97(%rip), %rsi      # 0x153ec
callq 0x31e0
movq %rax, -0xa0(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7d80
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0xa0(%rbp), %rdi
movl %eax, %esi
callq 0x3320
movq %rax, %rdi
movq 0x18b35(%rip), %rsi     # 0x1efc0
callq 0x3210
leaq -0x10(%rbp), %rdi
callq 0x7da0
jmp 0x6379
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3120
jmp 0x64d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3120
jmp 0x64d5
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3330
nop
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::equip_weapon(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Hero::equip_weapon(string weapon_name){

    int flag = 0;
    list<Weapon*> :: iterator wp;
    cout << GetWeaponsListSize() << endl;
    for(wp = Weapons.begin(); wp != Weapons.end(); ++wp){

        if( (*wp)->get_name() == weapon_name){
            flag = 1;
            break;
        }
    }

    if(flag == 1){
        Strength += (*wp)->get_damage();
        Weapon_Equiped = (*wp);
    }else{
        cout << "You dont have that weapon in your inventory" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7ad0
movq -0x58(%rbp), %rdi
callq 0x66a0
movl %eax, %esi
movq 0x18a42(%rip), %rdi     # 0x1efd0
callq 0x3320
movq %rax, %rdi
movq 0x18a23(%rip), %rsi     # 0x1efc0
callq 0x3210
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
callq 0x7b50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
callq 0x7bb0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7b80
testb $0x1, %al
jne 0x65df
jmp 0x662c
leaq -0x20(%rbp), %rdi
callq 0x7be0
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x12640
movq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7eb0
movb %al, -0x61(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3120
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x6616
jmp 0x661f
movl $0x1, -0x14(%rbp)
jmp 0x662c
jmp 0x6621
leaq -0x20(%rbp), %rdi
callq 0x7c00
jmp 0x65bb
cmpl $0x1, -0x14(%rbp)
jne 0x6669
leaq -0x20(%rbp), %rdi
callq 0x7be0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ecx
movq -0x58(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
leaq -0x20(%rbp), %rdi
callq 0x7be0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x58(%rax)
jmp 0x668b
movq 0x18960(%rip), %rdi     # 0x1efd0
leaq 0xed78(%rip), %rsi      # 0x153ef
callq 0x31e0
movq %rax, %rdi
movq 0x1893a(%rip), %rsi     # 0x1efc0
callq 0x3210
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::equip_armor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Hero::equip_armor(string armor_name){

    int flag = 0;
    list<Armor*> :: iterator ar;
    for(ar = Armors.begin(); ar != Armors.end(); ++ar){

        if( (*ar)->get_name() == armor_name){
            flag =1;
            break;
        }
    }

    if(flag == 1){
        Defense += (*ar)->get_protection();
        Armor_Equiped = (*ar);
    }else{

        cout << "You dont have that armor in your inventory" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7af0
movq -0x58(%rbp), %rdi
addq $0x98, %rdi
callq 0x7c20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
addq $0x98, %rdi
callq 0x7c80
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7c50
testb $0x1, %al
jne 0x672f
jmp 0x677c
leaq -0x20(%rbp), %rdi
callq 0x7cb0
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x12640
movq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7eb0
movb %al, -0x61(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3120
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x6766
jmp 0x676f
movl $0x1, -0x14(%rbp)
jmp 0x677c
jmp 0x6771
leaq -0x20(%rbp), %rdi
callq 0x7cd0
jmp 0x6708
cmpl $0x1, -0x14(%rbp)
jne 0x67b9
leaq -0x20(%rbp), %rdi
callq 0x7cb0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x58(%rbp), %rax
addl 0x44(%rax), %ecx
movl %ecx, 0x44(%rax)
leaq -0x20(%rbp), %rdi
callq 0x7cb0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x60(%rax)
jmp 0x67db
movq 0x18810(%rip), %rdi     # 0x1efd0
leaq 0xec54(%rip), %rsi      # 0x1541b
callq 0x31e0
movq %rax, %rdi
movq 0x187ea(%rip), %rsi     # 0x1efc0
callq 0x3210
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::castSpell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Spell * Hero::castSpell(string spell_name){
    int flag = 0;
    list<Spell*> :: iterator is;

    for(is = Spells.begin(); is!= Spells.end(); ++is){
          
        if((*is)->get_name() == spell_name){
            flag = 1;
            break;
        }

    }


    if(flag == 1){

         if(MagicPower >= (*is)->get_MagicPower()){

            MagicPower -= (*is)->get_MagicPower();

         }
         return *is;

    }else{

        cout << "You dont have that spell in your inventory" << endl;
    }



}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7b30
movq -0x58(%rbp), %rdi
addq $0x80, %rdi
callq 0x7dc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
addq $0x80, %rdi
callq 0x7e20
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7df0
testb $0x1, %al
jne 0x685f
jmp 0x68ac
leaq -0x20(%rbp), %rdi
callq 0x7e50
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x12640
movq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7eb0
movb %al, -0x61(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3120
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x6896
jmp 0x689f
movl $0x1, -0x14(%rbp)
jmp 0x68ac
jmp 0x68a1
leaq -0x20(%rbp), %rdi
callq 0x7e70
jmp 0x6838
cmpl $0x1, -0x14(%rbp)
jne 0x6907
movq -0x58(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7e50
movq (%rax), %rdi
callq 0x12220
movl %eax, %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
jl 0x68f5
leaq -0x20(%rbp), %rdi
callq 0x7e50
movq (%rax), %rdi
callq 0x12220
movl %eax, %edx
movq -0x58(%rbp), %rax
movl 0x34(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x34(%rax)
leaq -0x20(%rbp), %rdi
callq 0x7e50
movq (%rax), %rax
addq $0x70, %rsp
popq %rbp
retq
movq 0x186c2(%rip), %rdi     # 0x1efd0
leaq 0xeb31(%rip), %rsi      # 0x15446
callq 0x31e0
movq %rax, %rdi
movq 0x1869c(%rip), %rsi     # 0x1efc0
callq 0x3210
ud2
nopl (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::get_attacked(int)
void Hero::get_attacked(int dmg){
    int p = rand()%100;

    if(p <= Agility){
        cout << name << " dodged the Monster's attack!" << endl;
    }else{
        dec_hp(dmg);
        HealthPower += Defense;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x3070
movq -0x18(%rbp), %rcx
movl $0x64, %esi
cltd
idivl %esi
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jg 0x6e97
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq 0x1815e(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, %rdi
leaq 0xe64e(%rip), %rsi      # 0x154cf
callq 0x31e0
movq %rax, %rdi
movq 0x18130(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x6eb0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rax
movl 0x44(%rax), %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::round_won()
void Hero::round_won(){
    Money += Level*25;
    exp += Level*20;
    if(exp >= NextLvlExp){
        Level++;
        exp = 0;
        set_NextLvlExp();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
imull $0x19, 0x28(%rcx), %eax
addl 0x48(%rcx), %eax
movl %eax, 0x48(%rcx)
imull $0x14, 0x28(%rcx), %eax
addl 0x4c(%rcx), %eax
movl %eax, 0x4c(%rcx)
movl 0x4c(%rcx), %eax
cmpl 0x50(%rcx), %eax
jl 0x6f39
movq -0x10(%rbp), %rdi
movl 0x28(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x28(%rdi)
movl $0x0, 0x4c(%rdi)
callq 0x5120
addq $0x10, %rsp
popq %rbp
retq
nop
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Warrior::level_up()
void Warrior::level_up(){
    Strength += Strength*0.3;
    Agility += Agility*0.3;
    Dexterity += Dexterity*0.2;
    Level++;
    set_NextLvlExp();

    cout << "The WARRIOR " << name << " just LEVELED UP. New LEVEL: " << Level << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
cvtsi2sdl 0x38(%rdi), %xmm0
cvtsi2sdl 0x38(%rdi), %xmm1
movsd 0xe18a(%rip), %xmm2     # 0x15240
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x38(%rdi)
cvtsi2sdl 0x3c(%rdi), %xmm0
cvtsi2sdl 0x3c(%rdi), %xmm1
movsd 0xe169(%rip), %xmm2     # 0x15240
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x3c(%rdi)
cvtsi2sdl 0x40(%rdi), %xmm0
cvtsi2sdl 0x40(%rdi), %xmm1
movsd 0xe140(%rip), %xmm2     # 0x15238
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x40(%rdi)
movl 0x28(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x28(%rdi)
callq 0x5120
movq 0x17eb4(%rip), %rdi     # 0x1efd0
leaq 0xe3ed(%rip), %rsi      # 0x15510
callq 0x31e0
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x31b0
movq %rax, %rdi
leaq 0xe3db(%rip), %rsi      # 0x1551d
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x17e60(%rip), %rsi     # 0x1efc0
callq 0x3210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Sorcerer::level_up()
void Sorcerer::level_up(){
    Strength += Strength*0.2;
    Agility += Agility*0.3;
    Dexterity += Dexterity*0.3;
    Level++;
    set_NextLvlExp();

    cout << "The SORCERER " << name << " just LEVELED UP. New LEVEL: " << Level << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
cvtsi2sdl 0x38(%rdi), %xmm0
cvtsi2sdl 0x38(%rdi), %xmm1
movsd 0xdf52(%rip), %xmm2     # 0x15238
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x38(%rdi)
cvtsi2sdl 0x3c(%rdi), %xmm0
cvtsi2sdl 0x3c(%rdi), %xmm1
movsd 0xdf39(%rip), %xmm2     # 0x15240
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x3c(%rdi)
cvtsi2sdl 0x40(%rdi), %xmm0
cvtsi2sdl 0x40(%rdi), %xmm1
movsd 0xdf18(%rip), %xmm2     # 0x15240
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x40(%rdi)
movl 0x28(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x28(%rdi)
callq 0x5120
movq 0x17c84(%rip), %rdi     # 0x1efd0
leaq 0xe20d(%rip), %rsi      # 0x15560
callq 0x31e0
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x31b0
movq %rax, %rdi
leaq 0xe1ab(%rip), %rsi      # 0x1551d
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x17c30(%rip), %rsi     # 0x1efc0
callq 0x3210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Paladin::level_up()
void Paladin::level_up(){
    Strength += Strength*0.3;
    Agility += Agility*0.2;
    Dexterity += Dexterity*0.3;
    Level++;
    set_NextLvlExp();

    cout << "The PALADIN " << name << " just LEVELED UP. New LEVEL: " << Level << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
cvtsi2sdl 0x38(%rdi), %xmm0
cvtsi2sdl 0x38(%rdi), %xmm1
movsd 0xdd2a(%rip), %xmm2     # 0x15240
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x38(%rdi)
cvtsi2sdl 0x3c(%rdi), %xmm0
cvtsi2sdl 0x3c(%rdi), %xmm1
movsd 0xdd01(%rip), %xmm2     # 0x15238
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x3c(%rdi)
cvtsi2sdl 0x40(%rdi), %xmm0
cvtsi2sdl 0x40(%rdi), %xmm1
movsd 0xdce8(%rip), %xmm2     # 0x15240
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x40(%rdi)
movl 0x28(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x28(%rdi)
callq 0x5120
movq 0x17a54(%rip), %rdi     # 0x1efd0
leaq 0xe00e(%rip), %rsi      # 0x15591
callq 0x31e0
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x31b0
movq %rax, %rdi
leaq 0xdf7b(%rip), %rsi      # 0x1551d
callq 0x31e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x3320
movq %rax, %rdi
movq 0x17a00(%rip), %rsi     # 0x1efc0
callq 0x3210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Monsters.cpp
// Function: Monster::get_attacked(Spell*)
void Monster::get_attacked(Spell* sp){
    string spell;
    spell = sp->get_class();

    int red;
    red = sp->get_Reduction();

    if(spell == "IceSpell"){
        red = Damage*red/100;
        decrease_damage(red);
    }else if(spell == "FireSpell"){
        red = Defence*red/100;
        decreade_def(red);
    }else{
        red = Agility*red/100;
        decrease_Agility(red);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x32c0
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x50(%rbp), %rdi
callq *%rax
jmp 0xaf67
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %rsi, -0x78(%rbp)
callq 0x3270
movq -0x78(%rbp), %rdi
callq 0x3120
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movl %eax, -0x6c(%rbp)
jmp 0xaf93
movl -0x6c(%rbp), %eax
movl %eax, -0x60(%rbp)
leaq 0xa652(%rip), %rsi      # 0x155f2
leaq -0x30(%rbp), %rdi
callq 0x7f70
movb %al, -0x79(%rbp)
jmp 0xafae
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xafb7
jmp 0xafee
movq -0x68(%rbp), %rdi
movl 0x34(%rdi), %eax
imull -0x60(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %esi
callq 0xaed0
jmp 0xb04c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3120
jmp 0xb05e
leaq 0xa606(%rip), %rsi      # 0x155fb
leaq -0x30(%rbp), %rdi
callq 0x7f70
movb %al, -0x7a(%rbp)
jmp 0xb003
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0xb00c
jmp 0xb02c
movq -0x68(%rbp), %rdi
movl 0x38(%rdi), %eax
imull -0x60(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %esi
callq 0xaef0
jmp 0xb04a
movq -0x68(%rbp), %rdi
movl 0x3c(%rdi), %eax
imull -0x60(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %esi
callq 0xaf10
jmp 0xb04c
leaq -0x30(%rbp), %rdi
callq 0x3120
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3330
nopw (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Monsters.cpp
// Function: Monster::get_attacked(int)
void Monster::get_attacked(int dmg){
    int p = rand()%100;

    if(p <= Agility){
        cout << name << " dodged the attack!" << endl;
    }else{
        HealthPower -= dmg + Defence;
        cout << name << " was hit for " << dmg << " points of damage" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x3070
movq -0x18(%rbp), %rcx
movl $0x64, %esi
cltd
idivl %esi
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jg 0xb1b7
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq 0x13e3e(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, %rdi
leaq 0xa464(%rip), %rsi      # 0x15605
callq 0x31e0
movq %rax, %rdi
movq 0x13e10(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xb211
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %ecx
addl 0x38(%rsi), %ecx
movl 0x2c(%rsi), %eax
subl %ecx, %eax
movl %eax, 0x2c(%rsi)
addq $0x8, %rsi
movq 0x13dfc(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, %rdi
leaq 0xa065(%rip), %rsi      # 0x15248
callq 0x31e0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3320
movq %rax, %rdi
leaq 0xa41c(%rip), %rsi      # 0x15619
callq 0x31e0
movq %rax, %rdi
movq 0x13db4(%rip), %rsi     # 0x1efc0
callq 0x3210
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Market.cpp
// Function: Market::~Market()
Market::~Market() {

	Weapons.clear();
	Armors.clear();
	Potions.clear();
	Spells.clear();
	ItemsToSell.clear();	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xdd00
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xdd30
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0xdd60
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0xdd90
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xddc0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xddf0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x8340
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x8300
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x8320
movq -0x10(%rbp), %rdi
callq 0x8360
addq $0x10, %rsp
popq %rbp
retq
// File: kongrigoriou[P]Text-Based-RPG/src/Market.cpp
// Function: Market::EnterMarket()
void Market::EnterMarket(){

	cout << "Welcome to the Market" << endl << "Press 1 to buy,2 to sell and any button to leave" << endl;
	string flag;
	cin >> flag;
	if(flag == "1"){
		buy();
	}else if(flag == "2"){
		sell();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x12b85(%rip), %rdi     # 0x1efd0
leaq 0x9226(%rip), %rsi      # 0x15678
callq 0x31e0
movq %rax, %rdi
movq 0x12b5f(%rip), %rsi     # 0x1efc0
movq %rsi, -0x48(%rbp)
callq 0x3210
movq %rax, %rdi
leaq 0x921a(%rip), %rsi      # 0x1568e
callq 0x31e0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x3210
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x32c0
movq -0x40(%rbp), %rsi
movq 0x12b43(%rip), %rdi     # 0x1efe0
callq 0x32a0
jmp 0xc4a4
leaq 0x9214(%rip), %rsi      # 0x156bf
leaq -0x28(%rbp), %rdi
callq 0x7f70
movb %al, -0x51(%rbp)
jmp 0xc4b9
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xc4c2
jmp 0xc4e6
movq -0x50(%rbp), %rdi
callq 0xc530
jmp 0xc4cd
jmp 0xc513
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3120
jmp 0xc522
leaq 0x91d4(%rip), %rsi      # 0x156c1
leaq -0x28(%rbp), %rdi
callq 0x7f70
movb %al, -0x52(%rbp)
jmp 0xc4fb
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0xc504
jmp 0xc511
movq -0x50(%rbp), %rdi
callq 0xd130
jmp 0xc50f
jmp 0xc511
jmp 0xc513
leaq -0x28(%rbp), %rdi
callq 0x3120
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3330
nopl (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::move_up()
void Grid::move_up(){

    if(y -1 < 0){
        cout << "You can not move upwards" << endl;
    }else{
        if(Map[y-1][x] == 0){
            cout << "This is a non accessible square" << endl;
            return;            
        }
        py = y;
        px = x;
        Map[py][px] = pt;
        y--;
        pt = Map[y][x];
        Map[y][x] = 3;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x7c(%rax), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0xeb66
movq 0x1048a(%rip), %rdi     # 0x1efd0
leaq 0x6eb3(%rip), %rsi      # 0x15a00
callq 0x31e0
movq %rax, %rdi
movq 0x10464(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xec17
movq -0x10(%rbp), %rcx
movq 0x60(%rcx), %rax
movl 0x7c(%rcx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xeba9
movq 0x10444(%rip), %rdi     # 0x1efd0
leaq 0x6e86(%rip), %rsi      # 0x15a19
callq 0x31e0
movq %rax, %rdi
movq 0x1041e(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xec17
movq -0x10(%rbp), %rcx
movl 0x7c(%rcx), %eax
movl %eax, 0x84(%rcx)
movl 0x78(%rcx), %eax
movl %eax, 0x80(%rcx)
movl 0x88(%rcx), %esi
movq 0x60(%rcx), %rax
movslq 0x84(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x80(%rcx), %rdx
movl %esi, (%rax,%rdx,4)
movl 0x7c(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x7c(%rcx)
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rdx
movl (%rax,%rdx,4), %eax
movl %eax, 0x88(%rcx)
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rcx
movl $0x3, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::move_down()
void Grid::move_down(){
    cout << y << endl;
    if(y + 1 > HEIGHT-1){
        cout << "You can not move down" << endl;
    }else{
        if(Map[y+1][x] == 0){
            cout << "This is a non accessible square" << endl;
            return;            
        }
        py = y;
        px = x;
        Map[py][px] = pt;
        y++;
        pt = Map[y][x];
        Map[y][x] = 3;
        
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x7c(%rax), %esi
movq 0x10392(%rip), %rdi     # 0x1efd0
callq 0x3320
movq %rax, %rdi
movq 0x10373(%rip), %rsi     # 0x1efc0
callq 0x3210
movq -0x10(%rbp), %rax
movl 0x7c(%rax), %eax
addl $0x1, %eax
cmpl $0x4, %eax
jle 0xec88
movq 0x10368(%rip), %rdi     # 0x1efd0
leaq 0x6dca(%rip), %rsi      # 0x15a39
callq 0x31e0
movq %rax, %rdi
movq 0x10342(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xed39
movq -0x10(%rbp), %rcx
movq 0x60(%rcx), %rax
movl 0x7c(%rcx), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xeccb
movq 0x10322(%rip), %rdi     # 0x1efd0
leaq 0x6d64(%rip), %rsi      # 0x15a19
callq 0x31e0
movq %rax, %rdi
movq 0x102fc(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xed39
movq -0x10(%rbp), %rcx
movl 0x7c(%rcx), %eax
movl %eax, 0x84(%rcx)
movl 0x78(%rcx), %eax
movl %eax, 0x80(%rcx)
movl 0x88(%rcx), %esi
movq 0x60(%rcx), %rax
movslq 0x84(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x80(%rcx), %rdx
movl %esi, (%rax,%rdx,4)
movl 0x7c(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rcx)
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rdx
movl (%rax,%rdx,4), %eax
movl %eax, 0x88(%rcx)
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rcx
movl $0x3, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::move_left()
void Grid::move_left(){
    if(x - 1 < 0){
        cout << "You can not move to the left" << endl;
    }else{
        if(Map[y][x-1] == 0){
            cout << "This is a non accessible square" << endl;
            return;
        }
        py = y;
        px = x;
        Map[py][px] = pt;
        x--;
        pt = Map[y][x];
        Map[y][x] = 3;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x78(%rax), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0xed86
movq 0x1026a(%rip), %rdi     # 0x1efd0
leaq 0x6ce2(%rip), %rsi      # 0x15a4f
callq 0x31e0
movq %rax, %rdi
movq 0x10244(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xee37
movq -0x10(%rbp), %rcx
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movl 0x78(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xedc9
movq 0x10224(%rip), %rdi     # 0x1efd0
leaq 0x6c66(%rip), %rsi      # 0x15a19
callq 0x31e0
movq %rax, %rdi
movq 0x101fe(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xee37
movq -0x10(%rbp), %rcx
movl 0x7c(%rcx), %eax
movl %eax, 0x84(%rcx)
movl 0x78(%rcx), %eax
movl %eax, 0x80(%rcx)
movl 0x88(%rcx), %esi
movq 0x60(%rcx), %rax
movslq 0x84(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x80(%rcx), %rdx
movl %esi, (%rax,%rdx,4)
movl 0x78(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x78(%rcx)
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rdx
movl (%rax,%rdx,4), %eax
movl %eax, 0x88(%rcx)
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rcx
movl $0x3, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::move_right()
void Grid::move_right(){
    if(x + 1 > WIDTH){
        cout << "You can not move to the right" << endl;
    }else{
        if(Map[y][x+1] == 0){
            cout << "This is a non accessible square" << endl;
            return;            
        }
        py = y;
        px = x;
        Map[py][px] = pt;
        x++;
        pt = Map[y][x];
        Map[y][x] = 3;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x78(%rax), %eax
addl $0x1, %eax
cmpl $0x5, %eax
jle 0xee86
movq 0x1016a(%rip), %rdi     # 0x1efd0
leaq 0x6bff(%rip), %rsi      # 0x15a6c
callq 0x31e0
movq %rax, %rdi
movq 0x10144(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xef37
movq -0x10(%rbp), %rcx
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movl 0x78(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xeec9
movq 0x10124(%rip), %rdi     # 0x1efd0
leaq 0x6b66(%rip), %rsi      # 0x15a19
callq 0x31e0
movq %rax, %rdi
movq 0x100fe(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0xef37
movq -0x10(%rbp), %rcx
movl 0x7c(%rcx), %eax
movl %eax, 0x84(%rcx)
movl 0x78(%rcx), %eax
movl %eax, 0x80(%rcx)
movl 0x88(%rcx), %esi
movq 0x60(%rcx), %rax
movslq 0x84(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x80(%rcx), %rdx
movl %esi, (%rax,%rdx,4)
movl 0x78(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x78(%rcx)
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rdx
movl (%rax,%rdx,4), %eax
movl %eax, 0x88(%rcx)
movq 0x60(%rcx), %rax
movslq 0x7c(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x78(%rcx), %rcx
movl $0x3, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::monsters_fainted()
int Grid::monsters_fainted(){
    list<Monster*>::iterator it;
    int count = 0;
    for(it = Monsters.begin(); it != Monsters.end(); ++it){
        if((*it)->get_HealthPower() <= 0){
            count++;
        }
    }

    if(count == Monsters.size()){
        return 1;
    }else{
        return 0;
    }  
        
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x117a0
movq -0x38(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
addq $0x48, %rdi
callq 0x117c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
callq 0x11820
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x117f0
testb $0x1, %al
jne 0xf5c1
jmp 0xf5ed
leaq -0x18(%rbp), %rdi
callq 0x11850
movq (%rax), %rdi
callq 0x4e40
cmpl $0x0, %eax
jg 0xf5e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf5e2
leaq -0x18(%rbp), %rdi
callq 0x118b0
jmp 0xf59d
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x48, %rdi
callq 0x118d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0xf617
movl $0x1, -0x4(%rbp)
jmp 0xf61e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::display_Map()
void Grid::display_Map(){
    for(int k = 0; k < HEIGHT; k++){
        for(int l = 0; l < WIDTH; l++){
            cout << Map[k][l] << "  ";
        }

        cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0xf6d9
movl $0x0, -0x10(%rbp)
cmpl $0x5, -0x10(%rbp)
jge 0xf6bb
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq 0xf934(%rip), %rdi      # 0x1efd0
callq 0x3320
movq %rax, %rdi
leaq 0x645e(%rip), %rsi      # 0x15b09
callq 0x31e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xf678
movq 0xf90e(%rip), %rdi      # 0x1efd0
movq 0xf8f7(%rip), %rsi      # 0x1efc0
callq 0x3210
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf66b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::~Grid()
Grid::~Grid(){
    Dragons.clear();
    Exoskeletons.clear();
    Spirits.clear();
    Monsters.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x11940
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x11940
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x11940
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x11940
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x11700
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x11700
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x11700
movq -0x10(%rbp), %rdi
callq 0x11700
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::~Squad()
Squad::~Squad(){
    myHeroes.clear();
    Warriors.clear();
    Sorcerers.clear();
    Paladins.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xe7b0
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xe7b0
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0xe7b0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0xe7b0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0xdec0
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0xdec0
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xdec0
movq -0x10(%rbp), %rdi
callq 0xdec0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::display_myHeroes()
void Squad::display_myHeroes(){
    list<Hero*>::iterator it;
    for(it = myHeroes.begin(); it != myHeroes.end(); ++it){
        cout << (*it)->get_name() << "\t" << (*it)->get_HealthPower() << "\t" << (*it)->get_MagicPower() 
        << "\t" << (*it)->get_Strength() << "\t" << (*it)->get_Agility() << "\t" << (*it)->get_Dexterity() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xde50
movq -0x58(%rbp), %rdi
callq 0xdee0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x58(%rbp), %rdi
callq 0xdf40
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xdf10
testb $0x1, %al
jne 0x13a18
jmp 0x13c05
leaq -0x10(%rbp), %rdi
callq 0xdf70
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4df0
movq -0x68(%rbp), %rsi
movq 0xb594(%rip), %rdi      # 0x1efd0
callq 0x31b0
movq %rax, -0x60(%rbp)
jmp 0x13a47
movq -0x60(%rbp), %rdi
leaq 0x27e4(%rip), %rsi      # 0x16236
callq 0x31e0
movq %rax, -0x70(%rbp)
jmp 0x13a5d
leaq -0x10(%rbp), %rdi
callq 0xdf70
movq (%rax), %rdi
callq 0x4e40
movl %eax, -0x74(%rbp)
jmp 0x13a73
movl -0x74(%rbp), %esi
movq -0x70(%rbp), %rdi
callq 0x3320
movq %rax, -0x80(%rbp)
jmp 0x13a85
movq -0x80(%rbp), %rdi
leaq 0x27a6(%rip), %rsi      # 0x16236
callq 0x31e0
movq %rax, -0x88(%rbp)
jmp 0x13a9e
leaq -0x10(%rbp), %rdi
callq 0xdf70
movq (%rax), %rdi
callq 0x5020
movl %eax, -0x8c(%rbp)
jmp 0x13ab7
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdi
callq 0x3320
movq %rax, -0x98(%rbp)
jmp 0x13ad2
movq -0x98(%rbp), %rdi
leaq 0x2756(%rip), %rsi      # 0x16236
callq 0x31e0
movq %rax, -0xa0(%rbp)
jmp 0x13aee
leaq -0x10(%rbp), %rdi
callq 0xdf70
movq (%rax), %rdi
callq 0x5040
movl %eax, -0xa4(%rbp)
jmp 0x13b07
movl -0xa4(%rbp), %esi
movq -0xa0(%rbp), %rdi
callq 0x3320
movq %rax, -0xb0(%rbp)
jmp 0x13b22
movq -0xb0(%rbp), %rdi
leaq 0x2706(%rip), %rsi      # 0x16236
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x13b3e
leaq -0x10(%rbp), %rdi
callq 0xdf70
movq (%rax), %rdi
callq 0x5060
movl %eax, -0xbc(%rbp)
jmp 0x13b57
movl -0xbc(%rbp), %esi
movq -0xb8(%rbp), %rdi
callq 0x3320
movq %rax, -0xc8(%rbp)
jmp 0x13b72
movq -0xc8(%rbp), %rdi
leaq 0x26b6(%rip), %rsi      # 0x16236
callq 0x31e0
movq %rax, -0xd0(%rbp)
jmp 0x13b8e
leaq -0x10(%rbp), %rdi
callq 0xdf70
movq (%rax), %rdi
callq 0x5080
movl %eax, -0xd4(%rbp)
jmp 0x13ba7
movl -0xd4(%rbp), %esi
movq -0xd0(%rbp), %rdi
callq 0x3320
movq %rax, -0xe0(%rbp)
jmp 0x13bc2
movq -0xe0(%rbp), %rdi
movq 0xb3f0(%rip), %rsi      # 0x1efc0
callq 0x3210
jmp 0x13bd7
leaq -0x40(%rbp), %rdi
callq 0x3120
leaq -0x10(%rbp), %rdi
callq 0xdf90
jmp 0x139f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3120
jmp 0x13c0e
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3330
nopw (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::select_hero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Squad::select_hero(string name){
    if(myHeroes.size() == 3){
        cout << "Your Team is full!" << endl;
        return;
    }else{
        Hero* temp;
        string type;
        temp = search_Hero(name);
        if(temp != NULL){
            myHeroes.push_front(temp);
            cout << temp->get_name() << " is now part of your team!" << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x141e0
cmpq $0x3, %rax
jne 0x13c77
movq 0xb379(%rip), %rdi      # 0x1efd0
leaq 0x2603(%rip), %rsi      # 0x16261
callq 0x31e0
movq %rax, %rdi
movq 0xb353(%rip), %rsi      # 0x1efc0
callq 0x3210
jmp 0x13d9e
leaq -0x38(%rbp), %rdi
callq 0x32c0
movq -0x98(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x30c0
jmp 0x13c92
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x13db0
movq %rax, -0xa0(%rbp)
jmp 0x13cab
movq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3120
cmpq $0x0, -0x18(%rbp)
je 0x13d88
movq -0x90(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x14210
jmp 0x13cdc
movq -0x18(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x4df0
jmp 0x13cee
movq 0xb2db(%rip), %rdi      # 0x1efd0
leaq -0x88(%rbp), %rsi
callq 0x31b0
movq %rax, -0xa8(%rbp)
jmp 0x13d0a
movq -0xa8(%rbp), %rdi
leaq 0x255c(%rip), %rsi      # 0x16274
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x13d26
movq -0xb0(%rbp), %rdi
movq 0xb28c(%rip), %rsi      # 0x1efc0
callq 0x3210
jmp 0x13d3b
leaq -0x88(%rbp), %rdi
callq 0x3120
jmp 0x13d88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x13d93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3120
jmp 0x13d93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3120
jmp 0x13d93
leaq -0x38(%rbp), %rdi
callq 0x3120
jmp 0x13d9e
leaq -0x38(%rbp), %rdi
callq 0x3120
jmp 0x13da7
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3330
// File: kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::all_fainted()
int Squad::all_fainted(){
    int count = 0;
    list<Hero*>::iterator it;

    for(it = myHeroes.begin(); it != myHeroes.end(); ++it){
        if((*it)->get_HealthPower() <= 0)
            count++;
    }

    if(count == get_count())
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xde50
movq -0x38(%rbp), %rdi
callq 0xdee0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0xdf40
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdf10
testb $0x1, %al
jne 0x140f9
jmp 0x14125
leaq -0x20(%rbp), %rdi
callq 0xdf70
movq (%rax), %rdi
callq 0x4e40
cmpl $0x0, %eax
jg 0x14118
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1411a
leaq -0x20(%rbp), %rdi
callq 0xdf90
jmp 0x140d9
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x14080
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x14146
movl $0x1, -0x4(%rbp)
jmp 0x1414d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)