LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Hero.cpp
// Function: Hero::print(int)
void Hero::print(int line)
{
    if (line == 0)
        std::cout << "== " << std::setw(NAME_LENGTH) << name << " ==";
    else
        Character::print(line);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x2ce7
movq %rbx, %rdi
popq %rbx
jmp 0x2a50
movq 0x52da(%rip), %rdi      # 0x7fc8
leaq 0x244e(%rip), %rsi      # 0x5143
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x9, 0x10(%rax,%rcx)
addq $0x54, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
leaq 0x2427(%rip), %rsi      # 0x5147
movq %rax, %rdi
popq %rbx
jmp 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Hero.cpp
// Function: Hero::inputData()
void Hero::inputData()
{
    std::cout << "== Hero creation module ==\n";

    std::cout << "Enter the name: ";
    std::cin >> name;

    Character::inputData();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5290(%rip), %r14      # 0x7fc8
leaq 0x240c(%rip), %rsi      # 0x514b
movq %r14, %rdi
callq 0x2130
leaq 0x2419(%rip), %rsi      # 0x5167
movq %r14, %rdi
callq 0x2130
leaq 0x54(%rbx), %rsi
movq 0x5277(%rip), %rdi      # 0x7fd8
callq 0x2d75
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2592
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Monster.cpp
// Function: Monster::Monster(monster_t)
Monster::Monster(monster_t _type)
{
    // Set the type of the monster
    type = _type;

    action_percent[ATTACK] = 50;
    action_percent[DEFEND] = 40;
    action_percent[HEAL] = 10;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x64
popq %rsi
pushq $0x14
popq %rdx
pushq $0x5
popq %rcx
pushq $0x1
popq %r9
movsd 0x23be(%rip), %xmm0     # 0x5178
movsd 0x23be(%rip), %xmm1     # 0x5180
movsd 0x23be(%rip), %xmm3     # 0x5188
xorl %r8d, %r8d
movaps %xmm1, %xmm2
callq 0x254c
movl %ebx, 0x4c(%r14)
movsd 0x23af(%rip), %xmm0     # 0x5190
movsd %xmm0, 0x50(%r14)
movl $0x41200000, 0x58(%r14) # imm = 0x41200000
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Monster.cpp
// Function: Monster::selectAction()
action_t Monster::selectAction()
{
    int selection = Randomizer::randomRange(1, 100);
    int accum = 0;

    // Loop over the possible actions
    for (int i=0; i<NUM_ACTIONS; i++)
    {
        // Compute the accumulated percentages
        accum += action_percent[i];
        if (selection <= accum)
        {
            // Cast the integer into an action_t variable
            return (action_t)i;
        }
    }
    // A default action
    // if the percents are correctly filled this should never happen
    return ATTACK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x64
popq %rsi
callq 0x38c0
movl %eax, %ecx
xorl %eax, %eax
xorl %edx, %edx
xorl %esi, %esi
cmpq $0x3, %rdx
je 0x2e2e
cvtsi2ss %esi, %xmm0
addss 0x50(%rbx,%rdx,4), %xmm0
cvttss2si %xmm0, %esi
cmpl %esi, %ecx
jle 0x2e2c
incq %rdx
jmp 0x2e0f
movl %edx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Monster.cpp
// Function: Monster::inputData()
void Monster::inputData()
{
    std::cout << "== Monster creation module ==\n";

    // Ask for a correct monster type
    type = (monster_t)validateMonsterType();

    // Ask for the behaviour percents of the monster
    std::cout << "Enter the following percentages as integers between 0 and 100\n";
    std::cout << "It is up to you to make the percentages add up to 100\n";
    std::cout << "Attack percent: ";
    std::cin >> action_percent[ATTACK];
    std::cout << "Defend percent: ";
    std::cin >> action_percent[DEFEND];
    std::cout << "Heal percent: ";
    std::cin >> action_percent[HEAL];

    // Call the input data method from the parent class
    Character::inputData();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x5189(%rip), %r14      # 0x7fc8
leaq 0x2374(%rip), %rsi      # 0x51ba
movq %r14, %rdi
callq 0x2130
callq 0x2eda
movl %eax, 0x4c(%rbx)
leaq 0x237c(%rip), %rsi      # 0x51d9
movq %r14, %rdi
callq 0x2130
leaq 0x23ac(%rip), %rsi      # 0x5218
movq %r14, %rdi
callq 0x2130
leaq 0x23d4(%rip), %rsi      # 0x524f
movq %r14, %rdi
callq 0x2130
leaq 0x50(%rbx), %rsi
movq 0x514a(%rip), %r15      # 0x7fd8
movq %r15, %rdi
callq 0x2250
leaq 0x23c3(%rip), %rsi      # 0x5260
movq %r14, %rdi
callq 0x2130
leaq 0x54(%rbx), %rsi
movq %r15, %rdi
callq 0x2250
leaq 0x23b9(%rip), %rsi      # 0x5271
movq %r14, %rdi
callq 0x2130
leaq 0x58(%rbx), %rsi
movq %r15, %rdi
callq 0x2250
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2592
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Monster.cpp
// Function: Monster::validateMonsterType()
int Monster::validateMonsterType()
{
    int the_type;
    bool valid = false;

    while (!valid)
    {
        std::cout << "Monster types:\n";
        for (int i=0; i<NUM_TYPES; i++)
        {
            std::cout << "\t" << i << ". " << text_names[i] << "\n";
        }
        std::cout << "Select type: ";
        std::cin >> the_type;

        // Check that the type entered is valid
        if (the_type >= 0 and the_type < NUM_TYPES)
            valid = true;
        else
            std::cout << "Incorrect type. Try again ...\n";
    }
    return the_type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50dc(%rip), %rbx      # 0x7fc8
leaq 0x23a8(%rip), %r14      # 0x529b
leaq 0x23a3(%rip), %rbp      # 0x529d
leaq 0x2472(%rip), %r15      # 0x5373
movq %rbx, %rdi
leaq 0x2380(%rip), %rsi      # 0x528b
callq 0x2130
leaq 0x5259(%rip), %r12      # 0x8170
xorl %r13d, %r13d
movq %rbx, %rdi
cmpq $0x4, %r13
je 0x2f60
movq %r14, %rsi
callq 0x2130
movq %rax, %rdi
movl %r13d, %esi
callq 0x2210
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2130
movq %rax, %rdi
movq %r12, %rsi
callq 0x2100
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
incq %r13
addq $0x20, %r12
jmp 0x2f1a
leaq 0x2339(%rip), %rsi      # 0x52a0
callq 0x2130
movq 0x5065(%rip), %rdi      # 0x7fd8
leaq 0x4(%rsp), %rsi
callq 0x20b0
cmpl $0x4, 0x4(%rsp)
jb 0x2f98
movq %rbx, %rdi
leaq 0x2320(%rip), %rsi      # 0x52ae
callq 0x2130
jmp 0x2f01
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Monster.cpp
// Function: Monster::print(int)
void Monster::print(int line)
{
    if (line == 0)
        std::cout << "== " << std::setw(9) << getName() << " ==";
    else
        Character::print(line);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x306d
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2a50
movq 0x4f54(%rip), %rdi      # 0x7fc8
leaq 0x20c8(%rip), %rsi      # 0x5143
callq 0x2130
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x9, 0x10(%r14,%rax)
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x302c
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
leaq 0x2094(%rip), %rsi      # 0x5147
movq %rax, %rdi
callq 0x2130
movq %rsp, %rdi
callq 0x2080
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Party.cpp
// Function: Party::Party(int, party_t)
Party::Party(int _size, party_t _type)
{
    size = _size;
    type = _type;
    // Using 'new' calls malloc and calls the constructor for the class
    members = new Character*[size];
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %esi, %eax
shlq $0x3, %rax
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Party.cpp
// Function: Party::getMember(int)
Character * Party::getMember(int index)
{
    if (index >= 0 && index < size)
        return members[index];
    else
        // Do something
        throw std::runtime_error("Invalid index!");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x3134
cmpl %esi, (%rdi)
jle 0x3134
movq 0x8(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x2187(%rip), %rsi      # 0x52cd
movq %rax, %rdi
callq 0x2060
movq 0x4e9b(%rip), %rsi      # 0x7ff0
movq 0x4e64(%rip), %rdx      # 0x7fc0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Party.cpp
// Function: Party::print()
void Party::print()
{
    // Print all the members of a party horizontally
    for (int line=0; line<PRINT_LINES; line++)
    {
        for (int i=0; i<size; i++)
        {
            std::cout << " | ";
            // The first line is the name of the character
            if (line == 0)
            {
                // Cast the type of character to be able to call the correct methods
                if (type == HERO)
                {
                    static_cast<Hero*>(members[i])->print(line);
                }
                if (type == MONSTER)
                {
                    static_cast<Monster*>(members[i])->print(line);
                }
            }
            // All other lines are generic Character data
            else
            {
                members[i]->print(line);
            }
        }
        std::cout << " |" << std::endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x4e24(%rip), %r15      # 0x7fc8
leaq 0x2131(%rip), %r12      # 0x52dc
leaq 0x212e(%rip), %r13      # 0x52e0
cmpl $0x4, %r14d
je 0x322b
xorl %ebp, %ebp
movslq (%rbx), %rax
movq %r15, %rdi
cmpq %rax, %rbp
jge 0x3216
movq %r12, %rsi
callq 0x2130
testl %r14d, %r14d
je 0x31e4
movq 0x8(%rbx), %rax
movq (%rax,%rbp,8), %rdi
movl %r14d, %esi
callq 0x2a50
jmp 0x3211
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x31fd
movq 0x8(%rbx), %rax
movq (%rax,%rbp,8), %rdi
xorl %esi, %esi
callq 0x2cd6
movl 0x4(%rbx), %eax
cmpl $0x1, %eax
jne 0x3211
movq 0x8(%rbx), %rax
movq (%rax,%rbp,8), %rdi
xorl %esi, %esi
callq 0x304c
incq %rbp
jmp 0x31ba
movq %r13, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x2090
incl %r14d
jmp 0x31b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Battle.cpp
// Function: Battle::Battle(Party&, Party&)
Battle::Battle(Party & _hero_party, Party & _enemy_party)
{
    // Start the random seed
    Randomizer::init();
    // Call the method to set the battle parameters
    initialize(_hero_party, _enemy_party);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x2
popq %rbp
pushq $0x1
popq %r13
movl %ebp, %esi
movl %r13d, %edx
callq 0x30e0
leaq 0x10(%rbx), %r12
movq %r12, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x30e0
callq 0x38b0
movups (%r15), %xmm0
movups %xmm0, (%rbx)
movups (%r14), %xmm0
movups %xmm0, (%r12)
movl (%rbx), %eax
movl 0x10(%rbx), %ecx
movl %eax, 0x24(%rbx)
movl %ecx, 0x28(%rbx)
andl $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x3108
jmp 0x32b5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3108
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Battle.cpp
// Function: Battle::initialize(Party&, Party&)
void Battle::initialize(Party & _hero_party, Party & _enemy_party)
{
    hero_party = _hero_party;
    enemy_party = _enemy_party;

    num_heroes = hero_party.getSize();
    num_enemies = enemy_party.getSize();

    state = FIGHTING;
}

// Assembly:
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%rdi)
movl (%rdi), %eax
movl %eax, 0x24(%rdi)
movl 0x10(%rdi), %eax
movl %eax, 0x28(%rdi)
andl $0x0, 0x20(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Battle.cpp
// Function: Battle::battleLoop()
void Battle::battleLoop()
{
    int turn = 1;

    while (state == FIGHTING)
    {
        std::cout << "---- TURN # " << turn++ << " ----" << std::endl;
        // Print the current values for the parties
        std::cout << "HEROES:" << std::endl;
        hero_party.print();
        std::cout << "MONSTERS:" << std::endl;
        enemy_party.print();

        // Select the actions for the heroes
        for (int i=0; i<num_heroes; i++)
        {
            playerAction(i);
        }
        // Select the actions for the enemies
        for (int i=0; i<num_enemies; i++)
        {
            enemyAction(i);
        }

        // Check if any of the parties has been defeated
        updateBattleState();
    }

    if (state == HERO_WON)
    {
        std::cout << "The heros have won!! Congratulations!" << std::endl;
    }
    else
    {
        std::cout << "Your heroes have been defeated. Game over!" << std::endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
pushq $0x1
popq %rbp
movq 0x4cc8(%rip), %r15      # 0x7fc8
leaq 0x1ff7(%rip), %r13      # 0x52fe
movl 0x20(%rbx), %eax
testl %eax, %eax
jne 0x33bd
movq %r15, %rdi
leaq 0x1fc7(%rip), %rsi      # 0x52e3
callq 0x2130
movq %rax, %rdi
movl %ebp, %esi
callq 0x2210
movq %rax, %rdi
leaq 0x1fbb(%rip), %rsi      # 0x52f0
callq 0x2130
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
leaq 0x1faa(%rip), %rsi      # 0x52f6
callq 0x2130
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x318c
movq %r15, %rdi
movq %r13, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x318c
xorl %r12d, %r12d
cmpl 0x24(%rbx), %r12d
jge 0x3395
movq %rbx, %rdi
movl %r12d, %esi
callq 0x33f4
incl %r12d
jmp 0x337f
xorl %r12d, %r12d
cmpl 0x28(%rbx), %r12d
jge 0x33ae
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3596
incl %r12d
jmp 0x3398
incl %ebp
movq %rbx, %rdi
callq 0x3722
jmp 0x3307
cmpl $0x1, %eax
jne 0x33cb
leaq 0x1f3f(%rip), %rsi      # 0x5308
jmp 0x33d2
leaq 0x1f5c(%rip), %rsi      # 0x532e
movq 0x4bef(%rip), %rdi      # 0x7fc8
callq 0x2130
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Battle.cpp
// Function: Battle::enemyAction(int)
void Battle::enemyAction(int index)
{
    action_t action;
    int damage;
    int target;
    // Get a pointer to the monster that will act
    // Cast it to the correct Class pointer
    Monster * the_enemy = static_cast<Monster*> (enemy_party.getMember(index));

    // Dead characters take no actions
    if (the_enemy->getStatus() == DEAD)
        return;

    // Get the action taken by the monster using its percentages
    action = the_enemy->selectAction();

    switch (action)
    {
        case ATTACK:
            // Get the damage dealt by the hero
            damage = the_enemy->performAttack();
            // Select the enemy to attack
            target = selectHeroTarget();
            // Apply the damate
            hero_party.getMember(target)->receiveDamage(damage);
            std::cout << the_enemy->getName() << " attacks hero " << target << " dealing " << damage << " damage\n";
            break;
        case DEFEND:
            the_enemy->defend();
            std::cout << the_enemy->getName() << " defends\n";
            break;
        case HEAL:
            the_enemy->healDamage(30);
            std::cout << the_enemy->getName() << " heals\n";
            break;
        default:
            std::cout << "The enemy does not know what to do and stands still\n";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
addq $0x10, %rdi
callq 0x3116
cmpl $0x1, 0x48(%rax)
je 0x36e0
movq %rax, %r14
movq %rax, %rdi
callq 0x2df8
cmpl $0x2, %eax
je 0x369d
cmpl $0x1, %eax
je 0x3665
testl %eax, %eax
jne 0x36eb
movq %r14, %rdi
callq 0x2b48
movl %eax, %ebx
movq %r15, %rdi
callq 0x389c
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
callq 0x3116
movq %rax, %rdi
movl %ebx, %esi
callq 0x2b5a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x302c
movq 0x49ae(%rip), %rdi      # 0x7fc8
movq %r15, %rsi
callq 0x2100
leaq 0x1dce(%rip), %rsi      # 0x53f7
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
movl %ebp, %esi
callq 0x2210
leaq 0x1dc4(%rip), %rsi      # 0x5406
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x1db5(%rip), %rsi      # 0x5410
movq %rax, %rdi
callq 0x2130
jmp 0x36d6
movq %r14, %rdi
callq 0x2b8a
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x302c
movq 0x4944(%rip), %rdi      # 0x7fc8
movq %rbx, %rsi
callq 0x2100
leaq 0x1d86(%rip), %rsi      # 0x5419
movq %rax, %rdi
callq 0x2130
jmp 0x36d6
pushq $0x1e
popq %rsi
movq %r14, %rdi
callq 0x2b76
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x302c
movq 0x4909(%rip), %rdi      # 0x7fc8
movq %rbx, %rsi
callq 0x2100
leaq 0x1d55(%rip), %rsi      # 0x5423
movq %rax, %rdi
callq 0x2130
leaq 0x8(%rsp), %rdi
callq 0x2080
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x48d6(%rip), %rdi      # 0x7fc8
leaq 0x1d32(%rip), %rsi      # 0x542b
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2130
jmp 0x370c
jmp 0x370c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Battle.cpp
// Function: Battle::updateBattleState()
void Battle::updateBattleState()
{
    bool alive = false;

    // Check if there are enemies alive
    for (int i=0; i<num_enemies; i++)
    {
        if (enemy_party.getMember(i)->getStatus() != DEAD)
            alive = true;
    }
    // If all enemies have been defeated, the heroes won
    if (!alive)
    {
        state = HERO_WON;
        return;
    }

    alive = false;
    // Check if there are heroes alive
    for (int i=0; i<num_heroes; i++)
    {
        if (hero_party.getMember(i)->getStatus() != DEAD)
            alive = true;
    }
    // If all heroes have been defeated, the monsters won
    if (!alive)
    {
        state = ENEMY_WON;
        return;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpl 0x28(%rbx), %ebp
jge 0x3752
movq %r14, %rdi
movl %ebp, %esi
callq 0x3116
cmpl $0x1, 0x48(%rax)
setne %al
orb %al, %r15b
incl %ebp
jmp 0x3735
testb $0x1, %r15b
je 0x377a
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpl 0x24(%rbx), %ebp
jge 0x377e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3116
cmpl $0x1, 0x48(%rax)
setne %al
orb %al, %r14b
incl %ebp
jmp 0x375d
pushq $0x1
jmp 0x3786
testb $0x1, %r14b
jne 0x378a
pushq $0x2
popq %rax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Battle.cpp
// Function: Battle::selectEnemyTarget()
int Battle::selectEnemyTarget()
{
    int choice = -1;
    Monster * the_enemy = nullptr;

    while (choice < 1 || choice > num_enemies)
    {
        std::cout << "Your opponents are:\n";
        for (int i=0; i<num_enemies; i++)
        {
            // Get the current monster
            the_enemy = static_cast<Monster*> (enemy_party.getMember(i));
            // Print it's identifier name
            std::cout << "\t" << i+1 << ". " << the_enemy->getName() << std::endl;
        }
        std::cout << "Select one: ";
        std::cin >> choice;
    }
    return choice-1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
orl $-0x1, (%rax)
leaq 0x10(%rdi), %r15
pushq $-0x1
popq %rax
leaq 0x8(%rsp), %r13
testl %eax, %eax
jle 0x37c8
cmpl 0x28(%rbx), %eax
jle 0x3875
movq 0x47f9(%rip), %rdi      # 0x7fc8
leaq 0x1c8a(%rip), %rsi      # 0x5460
callq 0x2130
xorl %ebp, %ebp
cmpl 0x28(%rbx), %ebp
jge 0x3848
movq %r15, %rdi
movl %ebp, %esi
callq 0x3116
movq %rax, %r14
movq 0x47d2(%rip), %rdi      # 0x7fc8
leaq 0x1a9e(%rip), %rsi      # 0x529b
callq 0x2130
incl %ebp
movq %rax, %rdi
movl %ebp, %esi
callq 0x2210
movq %rax, %rdi
leaq 0x1a85(%rip), %rsi      # 0x529d
callq 0x2130
movq %rax, %r12
movq %r13, %rdi
movq %r14, %rsi
callq 0x302c
movq %r12, %rdi
movq %r13, %rsi
callq 0x2100
movq %rax, %rdi
callq 0x2090
movq %r13, %rdi
callq 0x2080
jmp 0x37dd
movq 0x4779(%rip), %rdi      # 0x7fc8
leaq 0x1c1f(%rip), %rsi      # 0x5475
callq 0x2130
movq 0x4776(%rip), %rdi      # 0x7fd8
leaq 0x4(%rsp), %rsi
callq 0x20b0
movl 0x4(%rsp), %eax
jmp 0x37bb
decl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Game.cpp
// Function: Game::Game()
Game::Game()
{
    // Create the Party objects for the opposing teams
    the_heros = new Party(hero_party_size, HERO);
    the_monsters = new Party(monster_party_size);
    // Create the Battle object
    the_battle = new Battle(*the_heros, *the_monsters);

    // Load the data in the files
    num_heroes = FileIOTemplate<Hero>::readData(hero_database, MAX_HEROS, "heros.bin");
    num_monsters = FileIOTemplate<Monster>::readData(monster_database, MAX_MONSTERS, "monsters.bin");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movaps 0x1b9b(%rip), %xmm0     # 0x5490
movups %xmm0, (%rdi)
pushq $0x10
popq %r14
leaq (%rbx,%r14), %rdi
callq 0x3f9e
addq $0x60, %r14
cmpq $0x130, %r14            # imm = 0x130
jne 0x38fc
leaq 0x10(%rbx), %r14
movl $0x130, %r15d           # imm = 0x130
leaq (%rbx,%r15), %rdi
callq 0x3fe0
addq $0x68, %r15
cmpq $0x2d0, %r15            # imm = 0x2D0
jne 0x391c
xorps %xmm0, %xmm0
movups %xmm0, 0x2d8(%rbx)
pushq $0x10
popq %rdi
callq 0x2150
movq %rax, %r15
movl 0x8(%rbx), %esi
movq %rax, %rdi
xorl %edx, %edx
callq 0x30e0
movq %r15, 0x2d8(%rbx)
pushq $0x10
popq %rdi
callq 0x2150
movq %rax, %r15
movl 0xc(%rbx), %esi
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x30e0
movq %r15, 0x2e0(%rbx)
pushq $0x30
popq %rdi
callq 0x2150
movq %rax, %r12
movq 0x2d8(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x323c
movq %r12, 0x2d0(%rbx)
leaq 0x1afa(%rip), %rsi      # 0x54a0
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2b8c
pushq $0x3
popq %rsi
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x4022
movl %eax, (%rbx)
leaq 0x28(%rsp), %rdi
callq 0x2080
leaq 0x1ad2(%rip), %rsi      # 0x54aa
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2b8c
leaq 0x130(%rbx), %rdi
pushq $0x4
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x406c
movl %eax, 0x4(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x2080
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x3a28
jmp 0x3a2f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2080
jmp 0x3a4f
movq %rax, %rbx
jmp 0x3a4f
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r12, %rdi
jmp 0x3a4a
jmp 0x3a41
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Game.cpp
// Function: Game::printHeroArray()
void Game::printHeroArray()
{
    std::cout << "\nThe heros:\n";
    for (int i=0; i<num_heroes; i++)
    {
        std::cout << "INDEX #" << i << std::endl;
        hero_database[i].print();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x42db(%rip), %r14      # 0x7fc8
leaq 0x191e(%rip), %rsi      # 0x5612
movq %r14, %rdi
callq 0x2130
leaq 0x10(%rbx), %r15
xorl %r12d, %r12d
leaq 0x1915(%rip), %r13      # 0x561f
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x3d41
movq %r14, %rdi
movq %r13, %rsi
callq 0x2130
movq %rax, %rdi
movl %r12d, %esi
callq 0x2210
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x2c92
incq %r12
addq $0x60, %r15
jmp 0x3d0a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Game.cpp
// Function: Game::printMonsterArray()
void Game::printMonsterArray()
{
    std::cout << "\nThe monsters:\n";
    for (int i=0; i<num_monsters; i++)
    {
        std::cout << "INDEX #" << i << std::endl;
        monster_database[i].print();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x4269(%rip), %r14      # 0x7fc8
leaq 0x18c1(%rip), %rsi      # 0x5627
movq %r14, %rdi
callq 0x2130
leaq 0x130(%rbx), %r15
xorl %r12d, %r12d
leaq 0x18a0(%rip), %r13      # 0x561f
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0x3db7
movq %r14, %rdi
movq %r13, %rsi
callq 0x2130
movq %rax, %rdi
movl %r12d, %esi
callq 0x2210
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x2fac
incq %r12
addq $0x68, %r15
jmp 0x3d7f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Game.cpp
// Function: Game::createHeroParty()
void Game::createHeroParty()
{
    int index;

    for (int i=0; i<hero_party_size; i++)
    {
        std::cout << "Enter index of hero (from the database): ";
        std::cin >> index;

        the_heros->setMember(i, &hero_database[index]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %ebp, %ebp
leaq 0x177e(%rip), %r15      # 0x5637
movq 0x4118(%rip), %r12      # 0x7fd8
leaq 0x4(%rsp), %r13
cmpl 0x8(%rbx), %ebp
jge 0x3f02
movq 0x40f7(%rip), %rdi      # 0x7fc8
movq %r15, %rsi
callq 0x2130
movq %r12, %rdi
movq %r13, %rsi
callq 0x20b0
movq 0x2d8(%rbx), %rdi
movslq 0x4(%rsp), %rax
imulq $0x60, %rax, %rdx
addq %r14, %rdx
movl %ebp, %esi
callq 0x3178
incl %ebp
jmp 0x3ec5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/Game.cpp
// Function: Game::createMonsterParty()
void Game::createMonsterParty()
{
    int index;

    for (int i=0; i<monster_party_size; i++)
    {
        std::cout << "Enter index of the monster (from the database): ";
        std::cin >> index;

        //the_monsters->setMember(i, &monster_database[index]);
        the_monsters->setMember(i, new Monster(monster_database[index]));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x130(%rdi), %r13
xorl %ebp, %ebp
pushq $0x68
popq %r14
pushq $0xd
popq %r15
cmpl 0xc(%rbx), %ebp
jge 0x3f8f
movq 0x408b(%rip), %rdi      # 0x7fc8
leaq 0x171d(%rip), %rsi      # 0x5661
callq 0x2130
movq 0x4088(%rip), %rdi      # 0x7fd8
leaq 0x4(%rsp), %rsi
callq 0x20b0
movq 0x2e0(%rbx), %r12
movq %r14, %rdi
callq 0x2150
movslq 0x4(%rsp), %rcx
imulq $0x68, %rcx, %rsi
addq %r13, %rsi
movq %r15, %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x3178
incl %ebp
jmp 0x3f31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/./FileIOTemplate.hpp
// Function: FileIOTemplate<Hero>::readData(Hero*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileIOTemplate<T>::readData(T data_array[], size_t items, std::string file_name)
{
    FILE * file_ptr = fopen(file_name.c_str(), "rb");
    size_t items_read = 0;

    if (file_ptr)
    {
        // Read up to the maximum size of the array of elements
        items_read = fread(data_array, sizeof (T), items, file_ptr);
        fclose(file_ptr);
    }
    return items_read;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rdi
leaq 0x165b(%rip), %rsi      # 0x5692
callq 0x2170
testq %rax, %rax
je 0x4062
movq %rax, %r15
pushq $0x60
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x21d0
movq %rax, %rbx
movq %r15, %rdi
callq 0x2140
jmp 0x4064
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/./FileIOTemplate.hpp
// Function: FileIOTemplate<Hero>::writeNewData(Hero&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileIOTemplate<T>::writeNewData(T & data_object, std::string file_name)
{
    FILE * file_ptr = nullptr;

    data_object.inputData();
    file_ptr = openAndCheck(file_name, "ab");
    fwrite(&data_object, sizeof (T), 1, file_ptr);
    fclose(file_ptr);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2d2a
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x158b(%rip), %rsi      # 0x5695
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2b8c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4224
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2080
leaq 0x28(%rsp), %rdi
callq 0x2080
pushq $0x60
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2240
movq %r14, %rdi
callq 0x2140
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
jmp 0x4172
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/./FileIOTemplate.hpp
// Function: FileIOTemplate<Hero>::openAndCheck(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FILE * FileIOTemplate<T>::openAndCheck(std::string file_name, std::string mode)
{
    FILE * file_ptr = nullptr;

    // Open the file. Convert C++ strings to C arrays of characters for the parameters
    file_ptr = fopen(file_name.c_str(), mode.c_str());
    if (file_ptr == nullptr)
    {
        std::cout << "Error: Unable to open file '" << file_name << "'!\n";
        exit(1);
    }
    return file_ptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x2170
testq %rax, %rax
je 0x423a
popq %rbx
retq
movq 0x3d87(%rip), %rdi      # 0x7fc8
leaq 0x1450(%rip), %rsi      # 0x5698
callq 0x2130
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2100
leaq 0x1456(%rip), %rsi      # 0x56b5
movq %rax, %rdi
callq 0x2130
pushq $0x1
popq %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/gilecheverria[P]UP_Battle_Project/battle_game.cpp
// Function: main
int main()
{
    Game test_game;

    std::cout << "=== RPG BATTLE GAME PROGRAM ===" << std::endl;
    test_game.gameMenu();

    return 0;
}

// Assembly:
pushq %rbx
subq $0x2f0, %rsp            # imm = 0x2F0
leaq 0x8(%rsp), %rdi
callq 0x38e0
movq 0x3cf3(%rip), %rdi      # 0x7fc8
leaq 0x13dd(%rip), %rsi      # 0x56b9
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x3ac4
leaq 0x8(%rsp), %rdi
callq 0x3a58
xorl %eax, %eax
addq $0x2f0, %rsp            # imm = 0x2F0
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3a58
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: show_usage()
void show_usage(){
	cout << "Usage: \n\n" ;
	cout << "./benchmark [--name] -i <max_number> -t <num_threads> --benchmark=<insert, delete, search, range, all_operations, high_contention, low_contention> [--help] \n" ;
	cout << "--name                         Prints full name \n" ;
	cout << "-i <max_number>                Numbers from 0 to max_number are inserted into skip list, subset is chosen for get, delete, and range \n" ;
	cout << "-t <num_threads>               Max number of threads to use \n" ;
	cout << "--benchmark=<insert>           Performs multithreaded insert based on input \n" ;
	cout << "--benchmark=<delete>           Performs multithreaded delete based on input \n" ;
	cout << "--benchmark=<search>           Performs multithreaded search based on input \n" ;
	cout << "--benchmark=<range>            Performs multithreaded range based on input \n" ;
	cout << "--benchmark=<all_operations>   Performs multithreaded all operations \n" ;
	cout << "--benchmark=<high_contention>  Simulates high contention \n" ;
	cout << "--benchmark=<low_contention>   Simulates low contention \n" ;
    cout << "--help                         Prints the usage of the program \n"; 
    cout << "\n[ max_number must be between INT_MIN and INT_MAX and exclusive of INT_MIN and INT_MAX ]\n";
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbx
movq 0x7a64(%rip), %rbx      # 0x9fc8
leaq 0x3ae1(%rip), %rsi      # 0x604c
movq %rbx, %rdi
callq 0x21e0
leaq 0x3adc(%rip), %rsi      # 0x6056
movq %rbx, %rdi
callq 0x21e0
leaq 0x3b6b(%rip), %rsi      # 0x60f4
movq %rbx, %rdi
callq 0x21e0
leaq 0x3b8e(%rip), %rsi      # 0x6126
movq %rbx, %rdi
callq 0x21e0
leaq 0x3c06(%rip), %rsi      # 0x61ad
movq %rbx, %rdi
callq 0x21e0
leaq 0x3c35(%rip), %rsi      # 0x61eb
movq %rbx, %rdi
callq 0x21e0
leaq 0x3c74(%rip), %rsi      # 0x6239
movq %rbx, %rdi
callq 0x21e0
leaq 0x3cb3(%rip), %rsi      # 0x6287
movq %rbx, %rdi
callq 0x21e0
leaq 0x3cf2(%rip), %rsi      # 0x62d5
movq %rbx, %rdi
callq 0x21e0
leaq 0x3d30(%rip), %rsi      # 0x6322
movq %rbx, %rdi
callq 0x21e0
leaq 0x3d68(%rip), %rsi      # 0x6369
movq %rbx, %rdi
callq 0x21e0
leaq 0x3d94(%rip), %rsi      # 0x63a4
movq %rbx, %rdi
callq 0x21e0
leaq 0x3dbf(%rip), %rsi      # 0x63de
movq %rbx, %rdi
callq 0x21e0
leaq 0x3df1(%rip), %rsi      # 0x641f
movq %rbx, %rdi
callq 0x21e0
pushq $0x1
popq %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: show_elapsed_time()
void show_elapsed_time(){
    unsigned long long elapsed_ns;
	elapsed_ns = (end_time.tv_sec-start_time.tv_sec)*1000000000 + (end_time.tv_nsec-start_time.tv_nsec);
	printf("Elapsed (ns): %llu\n",elapsed_ns);
	double elapsed_s = ((double)elapsed_ns)/1000000000.0;
	printf("Elapsed (s): %lf\n",elapsed_s);
}

// Assembly:
pushq %rbx
movq 0x7c3a(%rip), %rax      # 0xa280
subq 0x7c23(%rip), %rax      # 0xa270
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
movq 0x7c2d(%rip), %rbx      # 0xa288
subq 0x7c16(%rip), %rbx      # 0xa278
addq %rax, %rbx
leaq 0x3e0d(%rip), %rdi      # 0x6479
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
movq %rbx, %xmm1
punpckldq 0x398d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3995(%rip), %xmm1     # 0x6020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd 0x39a1(%rip), %xmm0     # 0x6040
leaq 0x3de7(%rip), %rdi      # 0x648d
movb $0x1, %al
popq %rbx
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: generate_input(int)
void generate_input(int max_number){
    // generating insert data
    for(int i = 1; i <= max_number; i++){
        numbers_insert.push_back(i);
    }

    // generating delete data
    for(size_t i = 0; i < numbers_insert.size(); i++){
        numbers_delete.push_back(numbers_insert[i]);
    }

    // generating search data
    for(size_t i = 0; i < numbers_insert.size(); i++){
        numbers_get.push_back(numbers_insert[i]);
    }

    // generating range data
    for(size_t i = 0; i < num_threads; i++){
        int a = (rand() % static_cast<int>(max_number + 1));
        int b = a + (rand() % static_cast<int>(max_number - a + 1));
        numbers_range.push_back(make_pair(a,b));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
pushq $0x1
popq %rax
leaq 0x7bc9(%rip), %r14      # 0xa290
leaq 0x4(%rsp), %r15
movl %eax, 0x4(%rsp)
cmpl %ebx, %eax
jg 0x26e7
movq %r14, %rdi
movq %r15, %rsi
callq 0x38a0
movl 0x4(%rsp), %eax
incl %eax
jmp 0x26cc
xorl %r15d, %r15d
leaq 0x7bb7(%rip), %r14      # 0xa2a8
xorl %r12d, %r12d
movq 0x7b9d(%rip), %rax      # 0xa298
movq 0x7b8e(%rip), %rsi      # 0xa290
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jae 0x2725
addq %r15, %rsi
movq %r14, %rdi
callq 0x38a0
incq %r12
addq $0x4, %r15
jmp 0x26f4
xorl %r15d, %r15d
leaq 0x7b91(%rip), %r14      # 0xa2c0
xorl %r12d, %r12d
subq %rsi, %rax
sarq $0x2, %rax
cmpq %rax, %r12
jae 0x2760
addq %r15, %rsi
movq %r14, %rdi
callq 0x38a0
incq %r12
movq 0x7b45(%rip), %rax      # 0xa298
movq 0x7b36(%rip), %rsi      # 0xa290
addq $0x4, %r15
jmp 0x2732
incl %ebx
xorl %r13d, %r13d
leaq 0x7b6c(%rip), %r14      # 0xa2d8
leaq 0x8(%rsp), %r15
cmpq 0x7a38(%rip), %r13      # 0xa1b0
jae 0x27b1
callq 0x2060
cltd
idivl %ebx
movl %edx, %r12d
callq 0x2060
movl %ebx, %ecx
subl %r12d, %ecx
cltd
idivl %ecx
addl %r12d, %edx
shlq $0x20, %rdx
orq %rdx, %r12
movq %r12, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e90
incq %r13
jmp 0x2771
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: skiplist_add(unsigned long, unsigned long)
void skiplist_add(size_t start, size_t end){
    if(end >= numbers_insert.size()) end = numbers_insert.size();
    if(start == end) skiplist.add(numbers_insert[start], to_string(numbers_insert[start]));
    for(size_t i = start; i < end; i++){
        skiplist.add(numbers_insert[i], to_string(numbers_insert[i]));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x7ac5(%rip), %r15      # 0xa298
movq 0x7ab6(%rip), %rax      # 0xa290
subq %rax, %r15
sarq $0x2, %r15
cmpq %rsi, %r15
cmovaeq %rsi, %r15
cmpq %rdi, %r15
jne 0x2853
movl (%rax,%rbx,4), %ebp
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x38be
leaq 0x7a5a(%rip), %rdi      # 0xa260
movl %ebp, %esi
movq %r14, %rdx
callq 0x4afc
leaq 0x28(%rsp), %rdi
callq 0x20d0
jmp 0x2853
movq 0x7a6d(%rip), %rax      # 0xa290
movl (%rax,%rbx,4), %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x38be
leaq 0x7a24(%rip), %rdi      # 0xa260
movl %ebp, %esi
movq %r14, %rdx
callq 0x4afc
leaq 0x8(%rsp), %rdi
callq 0x20d0
incq %rbx
cmpq %r15, %rbx
jb 0x281c
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2865
movq %rax, %rbx
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: low_contention_benchmark()
void skiplist_remove(size_t start, size_t end){
    if(end >= numbers_delete.size()) end = numbers_delete.size();
    if(start == end) skiplist.remove(numbers_delete[start]);
    for(size_t i = start; i < end; i++){
        skiplist.remove(numbers_delete[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
pushq $0x1
popq %r15
leaq 0x704f(%rip), %rbx      # 0xa290
movq %rsp, %r14
cmpq 0x6f6d(%rip), %r15      # 0xa1b8
ja 0x3261
movl %r15d, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4364
incq %r15
jmp 0x3244
movq 0x7030(%rip), %rsi      # 0xa298
subq 0x7021(%rip), %rsi      # 0xa290
shrq $0x2, %rsi
movq %rsp, %rdi
movss 0x2dca(%rip), %xmm0     # 0x6048
callq 0x4968
movq %rsp, %rdi
movups (%rdi), %xmm0
movups %xmm0, 0x6fd0(%rip)     # 0xa260
callq 0x5674
movq 0x6ffc(%rip), %rbp      # 0xa298
movq 0x6fed(%rip), %rbx      # 0xa290
movq %rbp, %rax
subq %rbx, %rax
sarq $0x2, %rax
js 0x32b6
cvtsi2ss %rax, %xmm0
jmp 0x32cb
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movq 0x6ede(%rip), %rax      # 0xa1b0
testq %rax, %rax
js 0x32de
cvtsi2ss %rax, %xmm1
jmp 0x32f3
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
callq 0x2120
cvttss2si %xmm0, %eax
movslq %eax, %r15
xorl %eax, %eax
leaq 0x30(%rsp), %r14
leaq 0x28(%rsp), %r12
leaq 0x10(%rsp), %r13
subq %rbx, %rbp
movq %rax, (%rsp)
sarq $0x2, %rbp
cmpq %rbp, %rax
jae 0x336b
addq %r15, %rax
movq %rax, 0x28(%rsp)
movq %r14, %rdi
leaq -0xb77(%rip), %rsi      # 0x27bf
movq %rsp, %rdx
movq %r12, %rcx
callq 0x3918
movq %r13, %rdi
movq %r14, %rsi
callq 0x408c
movq %r14, %rdi
callq 0x399a
movq (%rsp), %rax
addq %r15, %rax
movq 0x6f36(%rip), %rbp      # 0xa298
movq 0x6f27(%rip), %rbx      # 0xa290
jmp 0x3314
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x3388
movq %rbx, %rdi
callq 0x2300
addq $0x8, %rbx
jmp 0x3375
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x39a8
movq %rbx, %rdi
callq 0x39b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33c1
jmp 0x33c1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x399a
jmp 0x33c4
jmp 0x33c1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x39b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: skiplist_search(unsigned long, unsigned long)
void skiplist_search(size_t start, size_t end){
    if(end >= numbers_get.size()) end = numbers_get.size();
    if(start == end) end++;
    for(size_t i = start; i < end; i++){
        string s = skiplist.search(numbers_get[i]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x79da(%rip), %rax      # 0xa2c8
subq 0x79cb(%rip), %rax      # 0xa2c0
sarq $0x2, %rax
cmpq %rsi, %rax
cmovaeq %rsi, %rax
xorl %r12d, %r12d
cmpq %rdi, %rax
sete %r12b
addq %rax, %r12
leaq 0x794c(%rip), %r14      # 0xa260
leaq 0x8(%rsp), %r15
cmpq %r12, %rbx
jae 0x2940
movq 0x799b(%rip), %rax      # 0xa2c0
movl (%rax,%rbx,4), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4eb4
movq %r15, %rdi
callq 0x20d0
incq %rbx
jmp 0x2919
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: skiplist_combined_operations()
void skiplist_combined_operations(){

    int start = (rand() % static_cast<int>(numbers_insert.size() + 1));
    int end = start + (rand() % static_cast<int>(numbers_insert.size() - start + 1));
    skiplist_add(start, end);

    start = (rand() % static_cast<int>(numbers_delete.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_delete.size() - start + 1));
    skiplist_remove(start, end);

    start = (rand() % static_cast<int>(numbers_get.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_get.size() - start + 1));
    skiplist_search(start, end);

    start = (rand() % static_cast<int>(numbers_insert.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_insert.size() - start + 1));
    skiplist_range(start, end);
}

// Assembly:
pushq %rbx
callq 0x2060
movq 0x7427(%rip), %rcx      # 0xa298
subq 0x7418(%rip), %rcx      # 0xa290
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x7409(%rip), %rcx      # 0xa298
subq 0x73fa(%rip), %rcx      # 0xa290
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x27bf
callq 0x2060
movq 0x73f6(%rip), %rcx      # 0xa2b0
subq 0x73e7(%rip), %rcx      # 0xa2a8
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x73d8(%rip), %rcx      # 0xa2b0
subq 0x73c9(%rip), %rcx      # 0xa2a8
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x2878
callq 0x2060
movq 0x73c5(%rip), %rcx      # 0xa2c8
subq 0x73b6(%rip), %rcx      # 0xa2c0
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x73a7(%rip), %rcx      # 0xa2c8
subq 0x7398(%rip), %rcx      # 0xa2c0
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x28d9
callq 0x2060
movq 0x734c(%rip), %rcx      # 0xa298
subq 0x733d(%rip), %rcx      # 0xa290
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x732e(%rip), %rcx      # 0xa298
subq 0x731f(%rip), %rcx      # 0xa290
shrq $0x2, %rcx
subl %ebx, %ecx
incl %ecx
cltd
idivl %ecx
leal (%rdx,%rbx), %esi
movl %ebx, %edi
popq %rbx
jmp 0x294c
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: high_contention_benchmark()
void high_contention_benchmark(){   
    skiplist = SkipList(3, 0.5);

    skiplist.add(1, "1");
    skiplist.add(2, "2");

    vector<thread> threads;

    for(size_t i = 0; i < num_threads; i++){
        threads.push_back(thread(high_contention_benchmark_thread));
    }
    for (auto &th : threads) {
        th.join();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsp, %rbx
pushq $0x3
popq %rsi
movss 0x2f69(%rip), %xmm0     # 0x6048
movq %rbx, %rdi
callq 0x4968
movups (%rbx), %xmm0
movups %xmm0, 0x716f(%rip)     # 0xa260
movq %rbx, %rdi
callq 0x5674
leaq 0x33a1(%rip), %rsi      # 0x64a1
leaq 0x48(%rsp), %rdi
movq %rsp, %rdx
callq 0x3ab6
leaq 0x714c(%rip), %rdi      # 0xa260
pushq $0x1
popq %rsi
leaq 0x48(%rsp), %rdx
callq 0x4afc
leaq 0x48(%rsp), %rdi
callq 0x20d0
leaq 0x3371(%rip), %rsi      # 0x64a3
leaq 0x28(%rsp), %rdi
movq %rsp, %rdx
callq 0x3ab6
leaq 0x711a(%rip), %rdi      # 0xa260
pushq $0x2
popq %rsi
leaq 0x28(%rsp), %rdx
callq 0x4afc
leaq 0x28(%rsp), %rdi
callq 0x20d0
xorps %xmm0, %xmm0
movq %rsp, %rbx
andq $0x0, 0x10(%rbx)
movaps %xmm0, (%rbx)
xorl %r12d, %r12d
leaq -0x13a(%rip), %r14      # 0x303b
leaq 0x20(%rsp), %r15
cmpq 0x702f(%rip), %r12      # 0xa1b0
jae 0x31a6
movq %r15, %rdi
movq %r14, %rsi
callq 0x3a50
movq %rbx, %rdi
movq %r15, %rsi
callq 0x408c
movq %r15, %rdi
callq 0x399a
incq %r12
jmp 0x317a
movq (%rsp), %rbx
movq 0x8(%rsp), %r14
cmpq %r14, %rbx
je 0x31c2
movq %rbx, %rdi
callq 0x2300
addq $0x8, %rbx
jmp 0x31af
movq %rsp, %rdi
callq 0x39b0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x31ea
jmp 0x31f1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20d0
jmp 0x3212
movq %rax, %rbx
jmp 0x3212
jmp 0x3207
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x399a
jmp 0x320a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x39b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/node.cpp
// Function: Node::Node(int, int)
Node::Node(int key, int level){
    key_value_pair = KeyValuePair(key, "");
    next.resize(level + 1);
    for (size_t i = 0; i < next.size(); i++){
        next[i] = NULL;
    }
    top_level = level;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x445c
leaq 0x28(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
andw $0x0, 0x68(%rbx)
leaq 0x1b27(%rip), %rsi      # 0x6055
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3ab6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl %ebp, %esi
callq 0x446e
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x4718
leaq 0x30(%rsp), %rdi
callq 0x44c6
leaq 0x10(%rsp), %rdi
callq 0x20d0
leal 0x1(%r15), %eax
movslq %eax, %rsi
movq %r14, %rdi
callq 0x4732
xorl %eax, %eax
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x459e
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x4580
movl %r15d, 0x6c(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x45cd
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x44c6
jmp 0x45c1
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x20d0
jmp 0x45d0
movq %rax, %r15
movq %r14, %rdi
callq 0x4778
movq %rbx, %rdi
callq 0x44c6
movq %r15, %rdi
callq 0x2310