LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x4449
movq 0x4c78(%rip), %rdi      # 0x8fc8
leaq 0x1fcd(%rip), %rsi      # 0x6324
callq 0x21b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
callq 0x2310
movq %rax, %rdi
leaq 0x1fb8(%rip), %rsi      # 0x6331
callq 0x21b0
movq %rax, %rdi
movq 0x4c28(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x4c34(%rip), %rdi      # 0x8fc8
leaq 0x1f9c(%rip), %rsi      # 0x6337
callq 0x21b0
movq %rax, %rdi
movq 0x4c06(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq -0x20(%rbp), %rdi
callq 0x4100
movq 0x4c09(%rip), %rdi      # 0x8fc8
leaq 0x1f79(%rip), %rsi      # 0x633f
callq 0x21b0
movq %rax, %rdi
movq 0x4bdb(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x4100
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x24(%rcx), %eax
jge 0x4411
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x44a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x43ee
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x443b
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4690
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4418
movq -0x20(%rbp), %rdi
callq 0x4940
jmp 0x433b
movq -0x20(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x4477
movq 0x4b6e(%rip), %rdi      # 0x8fc8
leaq 0x1ee8(%rip), %rsi      # 0x6349
callq 0x21b0
movq %rax, %rdi
movq 0x4b40(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x4499
movq 0x4b4a(%rip), %rdi      # 0x8fc8
leaq 0x1eea(%rip), %rsi      # 0x636f
callq 0x21b0
movq %rax, %rdi
movq 0x4b1c(%rip), %rsi      # 0x8fb0
callq 0x21f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x4999
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movl -0x10(%rbp), %esi
callq 0x4020
movq %rax, %rdi
callq 0x4bc0
cmpl $0x1, %eax
je 0x498c
movb $0x1, -0x9(%rbp)
jmp 0x498e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x495f
testb $0x1, -0x9(%rbp)
jne 0x49ac
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
jmp 0x49fe
movb $0x0, -0x9(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x24(%rcx), %eax
jge 0x49ed
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4020
movq %rax, %rdi
callq 0x4bc0
cmpl $0x1, %eax
je 0x49e0
movb $0x1, -0x9(%rbp)
jmp 0x49e2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x49b7
testb $0x1, -0x9(%rbp)
jne 0x49fe
movq -0x20(%rbp), %rax
movl $0x2, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x18(%rbp)
movb $0x1, %al
cmpl $0x1, -0xc(%rbp)
movb %al, -0x59(%rbp)
jl 0x4a51
movq -0x58(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x4a5d
jmp 0x4b5a
movq 0x4564(%rip), %rdi      # 0x8fc8
leaq 0x1a36(%rip), %rsi      # 0x64a1
callq 0x21b0
movl $0x0, -0x1c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x4b32
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
movl -0x1c(%rbp), %esi
callq 0x4020
movq %rax, -0x18(%rbp)
movq 0x4526(%rip), %rdi      # 0x8fc8
leaq 0x17ea(%rip), %rsi      # 0x6293
callq 0x21b0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
incl %esi
callq 0x2310
movq %rax, %rdi
leaq 0x17d0(%rip), %rsi      # 0x6295
callq 0x21b0
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3e70
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x2180
movq %rax, -0x68(%rbp)
jmp 0x4af2
movq -0x68(%rbp), %rdi
movq 0x44b3(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x4b04
leaq -0x40(%rbp), %rdi
callq 0x2100
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4a77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2100
jmp 0x4b69
movq 0x448f(%rip), %rdi      # 0x8fc8
leaq 0x1976(%rip), %rsi      # 0x64b6
callq 0x21b0
movq 0x448c(%rip), %rdi      # 0x8fd8
leaq -0xc(%rbp), %rsi
callq 0x20f0
jmp 0x4a36
movl -0xc(%rbp), %eax
subl $0x1, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x3c3d(%rip), %rdi      # 0x8fc8
leaq 0x12a3(%rip), %rsi      # 0x6635
callq 0x21b0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x53f9
movq 0x3c18(%rip), %rdi      # 0x8fc8
leaq 0x128b(%rip), %rsi      # 0x6642
callq 0x21b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2310
movq %rax, %rdi
movq 0x3bdf(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rax
imulq $0x60, %rax, %rax
addq %rax, %rdi
callq 0x3900
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x539e
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x3bad(%rip), %rdi      # 0x8fc8
leaq 0x1228(%rip), %rsi      # 0x664a
callq 0x21b0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x548d
movq 0x3b87(%rip), %rdi      # 0x8fc8
leaq 0x11fa(%rip), %rsi      # 0x6642
callq 0x21b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2310
movq %rax, %rdi
movq 0x3b4e(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq -0x18(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movslq -0xc(%rbp), %rax
imulq $0x68, %rax, %rax
addq %rax, %rdi
callq 0x3dc0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x542e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5677
movq 0x399a(%rip), %rdi      # 0x8fc8
leaq 0x1025(%rip), %rsi      # 0x665a
callq 0x21b0
movq 0x3997(%rip), %rdi      # 0x8fd8
leaq -0xc(%rbp), %rsi
callq 0x20f0
movq -0x18(%rbp), %rdx
movq 0x2d8(%rdx), %rdi
movl -0x10(%rbp), %esi
addq $0x10, %rdx
movslq -0xc(%rbp), %rax
imulq $0x60, %rax, %rax
addq %rax, %rdx
callq 0x40c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x561b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x5732
movq 0x3916(%rip), %rdi      # 0x8fc8
leaq 0xfcb(%rip), %rsi       # 0x6684
callq 0x21b0
movq 0x3913(%rip), %rdi      # 0x8fd8
leaq -0xc(%rbp), %rsi
callq 0x20f0
movq -0x18(%rbp), %rax
movq 0x2e0(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x68, %edi
callq 0x21d0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
addq $0x130, %rsi            # imm = 0x130
movslq -0xc(%rbp), %rax
imulq $0x68, %rax, %rax
addq %rax, %rsi
movl $0x68, %edx
callq 0x2150
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x40c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x569b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x20b0
movq %rax, %rdi
leaq 0xe87(%rip), %rsi       # 0x66b5
callq 0x2250
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5869
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x60, %esi
callq 0x22c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x21c0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39f0
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x20c0
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2330
movq -0x78(%rbp), %rdx
leaq 0xcdb(%rip), %rsi       # 0x66b8
leaq -0x58(%rbp), %rdi
callq 0x34b0
jmp 0x59e8
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5b90
movq %rax, -0x88(%rbp)
jmp 0x59fe
movq -0x88(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2100
leaq -0x59(%rbp), %rdi
callq 0x2210
leaq -0x38(%rbp), %rdi
callq 0x2100
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x60, %esi
movl $0x1, %edx
callq 0x2350
movq -0x18(%rbp), %rdi
callq 0x21c0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5a70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2100
leaq -0x59(%rbp), %rdi
callq 0x2210
leaq -0x38(%rbp), %rdi
callq 0x2100
movq -0x68(%rbp), %rdi
callq 0x2320
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x20b0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x20b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x2250
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5c11
movq 0x33e8(%rip), %rdi      # 0x8fc8
leaq 0xad4(%rip), %rsi       # 0x66bb
callq 0x21b0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
leaq 0xad6(%rip), %rsi       # 0x66d8
callq 0x21b0
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movl $0x0, -0x4(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x4c50
movq 0x32f3(%rip), %rdi      # 0x8fc8
leaq 0xa00(%rip), %rsi       # 0x66dc
callq 0x21b0
movq %rax, -0x308(%rbp)
jmp 0x5cea
movq -0x308(%rbp), %rdi
movq 0x32b8(%rip), %rsi      # 0x8fb0
callq 0x21f0
jmp 0x5cff
leaq -0x2f0(%rbp), %rdi
callq 0x5040
jmp 0x5d0d
movl $0x0, -0x4(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x4fa0
movl -0x4(%rbp), %eax
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f8(%rbp)
movl %eax, -0x2fc(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x4fa0
movq -0x2f8(%rbp), %rdi
callq 0x2320
// File: 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 %rbp
movq %rsp, %rbp
movq 0x1391d(%rip), %rdi     # 0x16fc8
leaq 0xba5a(%rip), %rsi      # 0xf10c
callq 0x3240
movq 0x1390a(%rip), %rdi     # 0x16fc8
leaq 0xba51(%rip), %rsi      # 0xf116
callq 0x3240
movq 0x138f7(%rip), %rdi     # 0x16fc8
leaq 0xbadc(%rip), %rsi      # 0xf1b4
callq 0x3240
movq 0x138e4(%rip), %rdi     # 0x16fc8
leaq 0xbafb(%rip), %rsi      # 0xf1e6
callq 0x3240
movq 0x138d1(%rip), %rdi     # 0x16fc8
leaq 0xbb6f(%rip), %rsi      # 0xf26d
callq 0x3240
movq 0x138be(%rip), %rdi     # 0x16fc8
leaq 0xbb9a(%rip), %rsi      # 0xf2ab
callq 0x3240
movq 0x138ab(%rip), %rdi     # 0x16fc8
leaq 0xbbd5(%rip), %rsi      # 0xf2f9
callq 0x3240
movq 0x13898(%rip), %rdi     # 0x16fc8
leaq 0xbc10(%rip), %rsi      # 0xf347
callq 0x3240
movq 0x13885(%rip), %rdi     # 0x16fc8
leaq 0xbc4b(%rip), %rsi      # 0xf395
callq 0x3240
movq 0x13872(%rip), %rdi     # 0x16fc8
leaq 0xbc85(%rip), %rsi      # 0xf3e2
callq 0x3240
movq 0x1385f(%rip), %rdi     # 0x16fc8
leaq 0xbcb9(%rip), %rsi      # 0xf429
callq 0x3240
movq 0x1384c(%rip), %rdi     # 0x16fc8
leaq 0xbce1(%rip), %rsi      # 0xf464
callq 0x3240
movq 0x13839(%rip), %rdi     # 0x16fc8
leaq 0xbd08(%rip), %rsi      # 0xf49e
callq 0x3240
movq 0x13826(%rip), %rdi     # 0x16fc8
leaq 0xbd36(%rip), %rsi      # 0xf4df
callq 0x3240
movl $0x1, %edi
callq 0x32f0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x13b21(%rip), %rax     # 0x172f0
movq 0x13b0a(%rip), %rcx     # 0x172e0
subq %rcx, %rax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
movq 0x13b11(%rip), %rcx     # 0x172f8
movq 0x13afa(%rip), %rdx     # 0x172e8
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xbd36(%rip), %rdi      # 0xf539
xorl %eax, %eax
callq 0x3050
movaps 0xb7ff(%rip), %xmm1     # 0xf010
movq -0x8(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xb7fe(%rip), %xmm1     # 0xf020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xb7cf(%rip), %xmm1     # 0xf008
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
leaq 0xbcff(%rip), %rdi      # 0xf54d
movb $0x1, %al
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x3895
leaq 0x13a7f(%rip), %rdi     # 0x17300
leaq -0x8(%rbp), %rsi
callq 0x5570
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3872
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x13a54(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x38ea
movq -0x10(%rbp), %rsi
leaq 0x13a38(%rip), %rdi     # 0x17300
callq 0x5600
movq %rax, %rsi
leaq 0x13a41(%rip), %rdi     # 0x17318
callq 0x5570
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x389d
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x139ff(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x393f
movq -0x18(%rbp), %rsi
leaq 0x139e3(%rip), %rdi     # 0x17300
callq 0x5600
movq %rax, %rsi
leaq 0x13a04(%rip), %rdi     # 0x17330
callq 0x5570
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x38f2
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x138ce(%rip), %rax     # 0x17220
jae 0x39b3
callq 0x3080
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x3080
movl -0x4(%rbp), %ecx
subl -0x24(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl -0x44(%rbp), %eax
addl %edx, %eax
movl %eax, -0x28(%rbp)
leaq -0x24(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5650
movq %rax, -0x30(%rbp)
leaq 0x139ac(%rip), %rdi     # 0x17348
leaq -0x30(%rbp), %rsi
callq 0x5620
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3947
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x1391e(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jb 0x3a03
leaq 0x13906(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x3a82
movq -0x8(%rbp), %rsi
leaq 0x138e8(%rip), %rdi     # 0x17300
movq %rdi, -0x88(%rbp)
callq 0x5600
movq -0x88(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x7c(%rbp)
movq -0x8(%rbp), %rsi
callq 0x5600
movl (%rax), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5680
movl -0x7c(%rbp), %esi
movq -0x78(%rbp), %rdx
leaq 0x1387a(%rip), %rdi     # 0x172d0
callq 0xb110
jmp 0x3a5d
leaq -0x30(%rbp), %rdi
callq 0x3170
jmp 0x3a82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3170
jmp 0x3b2e
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x3b25
movq -0x48(%rbp), %rsi
leaq 0x1385d(%rip), %rdi     # 0x17300
movq %rdi, -0xa0(%rbp)
callq 0x5600
movq -0xa0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x94(%rbp)
movq -0x48(%rbp), %rsi
callq 0x5600
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5680
movl -0x94(%rbp), %esi
movq -0x90(%rbp), %rdx
leaq 0x137e3(%rip), %rdi     # 0x172d0
callq 0xb110
jmp 0x3af4
leaq -0x68(%rbp), %rdi
callq 0x3170
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x3a8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3170
jmp 0x3b2e
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33b0
nopw (%rax,%rax)
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: skiplist_remove(unsigned long, unsigned long)
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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x137b9(%rip), %rdi     # 0x17318
callq 0x55e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0x3b80
leaq 0x137a1(%rip), %rdi     # 0x17318
callq 0x55e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x3ba8
movq -0x8(%rbp), %rsi
leaq 0x13783(%rip), %rdi     # 0x17318
callq 0x5600
movl (%rax), %esi
leaq 0x1372d(%rip), %rdi     # 0x172d0
callq 0xbd80
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x3be6
movq -0x18(%rbp), %rsi
leaq 0x13753(%rip), %rdi     # 0x17318
callq 0x5600
movl (%rax), %esi
leaq 0x136fd(%rip), %rdi     # 0x172d0
callq 0xbd80
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3bb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x13721(%rip), %rdi     # 0x17330
callq 0x55e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x3c30
leaq 0x13709(%rip), %rdi     # 0x17330
callq 0x55e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x3c46
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x3c91
movq -0x18(%rbp), %rsi
leaq 0x136cd(%rip), %rdi     # 0x17330
callq 0x5600
movl (%rax), %edx
leaq -0x38(%rbp), %rdi
leaq 0x1365b(%rip), %rsi     # 0x172d0
callq 0xb970
leaq -0x38(%rbp), %rdi
callq 0x3170
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3c4e
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: insert_benchmark()
void insert_benchmark(){
    vector<thread> threads;

    // insert
    int chunk_size = ceil(float(numbers_insert.size()) / num_threads);
    for(size_t i = 0; i < numbers_insert.size(); i = i + chunk_size){
        threads.push_back(thread(skiplist_add, i, i+chunk_size));
    }
    for (auto &th : threads) {
        th.join();
    }

    threads.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x18(%rbp), %rdi
callq 0x57c0
leaq 0x13605(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x70(%rbp)
testq %rax, %rax
movss %xmm0, -0x6c(%rbp)
js 0x3d35
movss -0x70(%rbp), %xmm0
movss %xmm0, -0x6c(%rbp)
movss -0x6c(%rbp), %xmm0
movss %xmm0, -0x7c(%rbp)
movq 0x134da(%rip), %rax     # 0x17220
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x78(%rbp)
testq %rax, %rax
movss %xmm0, -0x74(%rbp)
js 0x3d7b
movss -0x78(%rbp), %xmm0
movss %xmm0, -0x74(%rbp)
movss -0x7c(%rbp), %xmm0
movss -0x74(%rbp), %xmm1
divss %xmm1, %xmm0
callq 0x57e0
movss %xmm0, -0x80(%rbp)
jmp 0x3d95
movss -0x80(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq 0x13545(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x3e49
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x425(%rip), %rsi      # 0x39c0
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x5830
jmp 0x3df8
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5800
jmp 0x3e07
leaq -0x40(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x3da9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3ebe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5900
jmp 0x3ebe
leaq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5930
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5960
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5990
testb $0x1, %al
jne 0x3e7e
jmp 0x3ea3
leaq -0x58(%rbp), %rdi
callq 0x59d0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x33a0
jmp 0x3e96
jmp 0x3e98
leaq -0x58(%rbp), %rdi
callq 0x59f0
jmp 0x3e6b
leaq -0x18(%rbp), %rdi
callq 0x5a10
leaq -0x18(%rbp), %rdi
callq 0x5a30
addq $0x90, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x5a30
movq -0x28(%rbp), %rdi
callq 0x33b0
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: delete_benchmark()
void delete_benchmark(){
    vector<thread> threads;

    // delete
    int chunk_size = ceil(float(numbers_delete.size()) / num_threads);
    for(size_t i = 0; i < numbers_delete.size(); i = i + chunk_size){
        threads.push_back(thread(skiplist_remove, i, i+chunk_size));
    }
    for (auto &th : threads) {
        th.join();
    }

    threads.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x18(%rbp), %rdi
callq 0x57c0
leaq 0x1342d(%rip), %rdi     # 0x17318
callq 0x55e0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x70(%rbp)
testq %rax, %rax
movss %xmm0, -0x6c(%rbp)
js 0x3f25
movss -0x70(%rbp), %xmm0
movss %xmm0, -0x6c(%rbp)
movss -0x6c(%rbp), %xmm0
movss %xmm0, -0x7c(%rbp)
movq 0x132ea(%rip), %rax     # 0x17220
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x78(%rbp)
testq %rax, %rax
movss %xmm0, -0x74(%rbp)
js 0x3f6b
movss -0x78(%rbp), %xmm0
movss %xmm0, -0x74(%rbp)
movss -0x7c(%rbp), %xmm0
movss -0x74(%rbp), %xmm1
divss %xmm1, %xmm0
callq 0x57e0
movss %xmm0, -0x80(%rbp)
jmp 0x3f85
movss -0x80(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq 0x1336d(%rip), %rdi     # 0x17318
callq 0x55e0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x4039
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x495(%rip), %rsi      # 0x3b40
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x5830
jmp 0x3fe8
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5800
jmp 0x3ff7
leaq -0x40(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x3f99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x40ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5900
jmp 0x40ae
leaq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5930
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5960
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5990
testb $0x1, %al
jne 0x406e
jmp 0x4093
leaq -0x58(%rbp), %rdi
callq 0x59d0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x33a0
jmp 0x4086
jmp 0x4088
leaq -0x58(%rbp), %rdi
callq 0x59f0
jmp 0x405b
leaq -0x18(%rbp), %rdi
callq 0x5a10
leaq -0x18(%rbp), %rdi
callq 0x5a30
addq $0x90, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x5a30
movq -0x28(%rbp), %rdi
callq 0x33b0
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: search_benchmark()
void search_benchmark(){
    vector<thread> threads;

    // search
    int chunk_size = ceil(float(numbers_get.size()) / num_threads);
    for(size_t i = 0; i < numbers_get.size(); i = i + chunk_size){
        threads.push_back(thread(skiplist_search, i, i+chunk_size));
    }
    for (auto &th : threads) {
        th.join();
    }

    threads.clear();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x18(%rbp), %rdi
callq 0x57c0
leaq 0x13255(%rip), %rdi     # 0x17330
callq 0x55e0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x70(%rbp)
testq %rax, %rax
movss %xmm0, -0x6c(%rbp)
js 0x4115
movss -0x70(%rbp), %xmm0
movss %xmm0, -0x6c(%rbp)
movss -0x6c(%rbp), %xmm0
movss %xmm0, -0x7c(%rbp)
movq 0x130fa(%rip), %rax     # 0x17220
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x78(%rbp)
testq %rax, %rax
movss %xmm0, -0x74(%rbp)
js 0x415b
movss -0x78(%rbp), %xmm0
movss %xmm0, -0x74(%rbp)
movss -0x7c(%rbp), %xmm0
movss -0x74(%rbp), %xmm1
divss %xmm1, %xmm0
callq 0x57e0
movss %xmm0, -0x80(%rbp)
jmp 0x4175
movss -0x80(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq 0x13195(%rip), %rdi     # 0x17330
callq 0x55e0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x4229
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x5d5(%rip), %rsi      # 0x3bf0
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x5830
jmp 0x41d8
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5800
jmp 0x41e7
leaq -0x40(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x4189
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x429e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5900
jmp 0x429e
leaq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5930
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5960
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5990
testb $0x1, %al
jne 0x425e
jmp 0x4283
leaq -0x58(%rbp), %rdi
callq 0x59d0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x33a0
jmp 0x4276
jmp 0x4278
leaq -0x58(%rbp), %rdi
callq 0x59f0
jmp 0x424b
leaq -0x18(%rbp), %rdi
callq 0x5a10
leaq -0x18(%rbp), %rdi
callq 0x5a30
addq $0x90, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x5a30
movq -0x28(%rbp), %rdi
callq 0x33b0
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: range_benchmark()
void range_benchmark(){
    vector<thread> threads;

    // range
    for(size_t i = 0; i < num_threads; i++){
        threads.push_back(thread(skiplist_range, numbers_range[i].first, numbers_range[i].second));
    }
    for (auto &th : threads) {
        th.join();
    }

    threads.clear();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq -0x18(%rbp), %rdi
callq 0x57c0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x12f4c(%rip), %rax     # 0x17220
jae 0x436a
movq -0x20(%rbp), %rsi
leaq 0x13063(%rip), %rdi     # 0x17348
movq %rdi, -0x68(%rbp)
callq 0x5a90
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
callq 0x5a90
movq -0x60(%rbp), %rdx
movq %rax, %rcx
addq $0x4, %rcx
leaq -0x671(%rip), %rsi      # 0x3ca0
leaq -0x28(%rbp), %rdi
callq 0x5ab0
jmp 0x431c
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5800
jmp 0x432b
leaq -0x28(%rbp), %rdi
callq 0x5900
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x42c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x43dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5900
jmp 0x43dc
leaq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5930
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5960
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5990
testb $0x1, %al
jne 0x439f
jmp 0x43c4
leaq -0x48(%rbp), %rdi
callq 0x59d0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x33a0
jmp 0x43b7
jmp 0x43b9
leaq -0x48(%rbp), %rdi
callq 0x59f0
jmp 0x438c
leaq -0x18(%rbp), %rdi
callq 0x5a10
leaq -0x18(%rbp), %rdi
callq 0x5a30
addq $0x70, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x5a30
movq -0x30(%rbp), %rdi
callq 0x33b0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x3080
movl %eax, -0x38(%rbp)
leaq 0x12ef9(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rcx
movl -0x38(%rbp), %eax
addq $0x1, %rcx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x3080
movl %eax, -0x34(%rbp)
leaq 0x12ecf(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rcx
movl -0x34(%rbp), %eax
movslq -0x4(%rbp), %rdx
subq %rdx, %rcx
addq $0x1, %rcx
cltd
idivl %ecx
movl -0x30(%rbp), %eax
addl %edx, %eax
movl %eax, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
movslq -0x8(%rbp), %rsi
callq 0x39c0
callq 0x3080
movl %eax, -0x2c(%rbp)
leaq 0x12eaa(%rip), %rdi     # 0x17318
callq 0x55e0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
addq $0x1, %rcx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x3080
movl %eax, -0x28(%rbp)
leaq 0x12e80(%rip), %rdi     # 0x17318
callq 0x55e0
movq %rax, %rcx
movl -0x28(%rbp), %eax
movslq -0x4(%rbp), %rdx
subq %rdx, %rcx
addq $0x1, %rcx
cltd
idivl %ecx
movl -0x24(%rbp), %eax
addl %edx, %eax
movl %eax, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
movslq -0x8(%rbp), %rsi
callq 0x3b40
callq 0x3080
movl %eax, -0x20(%rbp)
leaq 0x12e5b(%rip), %rdi     # 0x17330
callq 0x55e0
movq %rax, %rcx
movl -0x20(%rbp), %eax
addq $0x1, %rcx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x3080
movl %eax, -0x1c(%rbp)
leaq 0x12e31(%rip), %rdi     # 0x17330
callq 0x55e0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
movslq -0x4(%rbp), %rdx
subq %rdx, %rcx
addq $0x1, %rcx
cltd
idivl %ecx
movl -0x18(%rbp), %eax
addl %edx, %eax
movl %eax, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
movslq -0x8(%rbp), %rsi
callq 0x3bf0
callq 0x3080
movl %eax, -0x14(%rbp)
leaq 0x12dc4(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rcx
movl -0x14(%rbp), %eax
addq $0x1, %rcx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
callq 0x3080
movl %eax, -0x10(%rbp)
leaq 0x12d9a(%rip), %rdi     # 0x17300
callq 0x55e0
movq %rax, %rcx
movl -0x10(%rbp), %eax
movslq -0x4(%rbp), %rdx
subq %rdx, %rcx
addq $0x1, %rcx
cltd
idivl %ecx
movl -0xc(%rbp), %eax
addl %edx, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x3ca0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/benchmark.cpp
// Function: concurrent_skiplist_combined()
void concurrent_skiplist_combined(){
    vector<thread> threads;

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
callq 0x57c0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x12c5c(%rip), %rax     # 0x17220
jae 0x4626
leaq -0x1dd(%rip), %rsi      # 0x43f0
leaq -0x28(%rbp), %rdi
callq 0x5b80
jmp 0x45d8
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5800
jmp 0x45e7
leaq -0x28(%rbp), %rdi
callq 0x5900
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x45b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x468f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5900
jmp 0x468f
leaq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5930
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5960
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5990
testb $0x1, %al
jne 0x465b
jmp 0x4680
leaq -0x48(%rbp), %rdi
callq 0x59d0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x33a0
jmp 0x4673
jmp 0x4675
leaq -0x48(%rbp), %rdi
callq 0x59f0
jmp 0x4648
leaq -0x18(%rbp), %rdi
callq 0x5a30
addq $0x60, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x5a30
movq -0x30(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0x10(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x3, %esi
movss 0xa87d(%rip), %xmm0     # 0xf030
callq 0xae20
movq -0xc8(%rbp), %rdi
movups -0x10(%rbp), %xmm0
movups %xmm0, 0x12b06(%rip)    # 0x172d0
callq 0xca30
leaq -0x31(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x33c0
movq -0xc0(%rbp), %rdx
leaq 0xad74(%rip), %rsi      # 0xf561
leaq -0x30(%rbp), %rdi
callq 0x5c40
jmp 0x47f8
leaq 0x12ad1(%rip), %rdi     # 0x172d0
movl $0x1, %esi
leaq -0x30(%rbp), %rdx
callq 0xb110
jmp 0x480f
leaq -0x30(%rbp), %rdi
callq 0x3170
leaq -0x31(%rbp), %rdi
callq 0x32a0
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x33c0
movq -0xd0(%rbp), %rdx
leaq 0xad24(%rip), %rsi      # 0xf563
leaq -0x68(%rbp), %rdi
callq 0x5c40
jmp 0x484a
leaq 0x12a7f(%rip), %rdi     # 0x172d0
movl $0x2, %esi
leaq -0x68(%rbp), %rdx
callq 0xb110
jmp 0x4861
leaq -0x68(%rbp), %rdi
callq 0x3170
leaq -0x69(%rbp), %rdi
callq 0x32a0
leaq -0x88(%rbp), %rdi
callq 0x57c0
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq 0x12988(%rip), %rax     # 0x17220
jae 0x4978
leaq -0x1e5(%rip), %rsi      # 0x46c0
leaq -0x98(%rbp), %rdi
callq 0x5b80
jmp 0x48b3
leaq -0x88(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x5800
jmp 0x48c8
leaq -0x98(%rbp), %rdi
callq 0x5900
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0x488a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x490b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3170
leaq -0x31(%rbp), %rdi
callq 0x32a0
jmp 0x4a17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x493c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3170
leaq -0x69(%rbp), %rdi
callq 0x32a0
jmp 0x4a17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4a0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x5900
jmp 0x4a0b
leaq -0x88(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x5930
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x5960
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x5990
testb $0x1, %al
jne 0x49c5
jmp 0x49f6
leaq -0xa8(%rbp), %rdi
callq 0x59d0
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x33a0
jmp 0x49e6
jmp 0x49e8
leaq -0xa8(%rbp), %rdi
callq 0x59f0
jmp 0x49ac
leaq -0x88(%rbp), %rdi
callq 0x5a30
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x88(%rbp), %rdi
callq 0x5a30
movq -0x40(%rbp), %rdi
callq 0x33b0
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
callq 0x99e0
movq -0x90(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x98(%rbp)
callq 0xa050
movq -0x90(%rbp), %rdi
addq $0x40, %rdi
callq 0xa070
movq -0x90(%rbp), %rdi
addq $0x68, %rdi
xorl %esi, %esi
movl %esi, -0x88(%rbp)
callq 0xa090
movq -0x90(%rbp), %rdi
movl -0x88(%rbp), %esi
addq $0x69, %rdi
callq 0xa090
movl -0xc(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x33c0
movq -0x80(%rbp), %rdx
leaq 0x5540(%rip), %rsi      # 0xf115
leaq -0x58(%rbp), %rdi
callq 0x5c40
jmp 0x9be0
movl -0x84(%rbp), %esi
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x9a00
jmp 0x9bf5
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa0c0
jmp 0x9c07
leaq -0x38(%rbp), %rdi
callq 0x9ab0
leaq -0x58(%rbp), %rdi
callq 0x3170
leaq -0x59(%rbp), %rdi
callq 0x32a0
movq -0xa0(%rbp), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0xa100
jmp 0x9c3c
movq $0x0, -0x78(%rbp)
movq -0xa0(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0xa8(%rbp)
addq $0x28, %rdi
callq 0xa190
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x9cea
movq -0xa0(%rbp), %rdi
addq $0x28, %rdi
movq -0x78(%rbp), %rsi
callq 0xa1b0
movq $0x0, (%rax)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x9c44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x9cd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x9cc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9ab0
leaq -0x58(%rbp), %rdi
callq 0x3170
leaq -0x59(%rbp), %rdi
callq 0x32a0
jmp 0x9d00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x9d00
movq -0xa0(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, 0x6c(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0xa1d0
movq -0x90(%rbp), %rdi
callq 0x9ab0
movq -0x68(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)