LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/battle/Battle.cpp
// Function: Battle::printMoves(std::shared_ptr<Player> const&, std::vector<std::shared_ptr<Skill>, std::allocator<std::shared_ptr<Skill>>> const&)
void Battle::printMoves(const std::shared_ptr<Player> &player, const std::vector<std::shared_ptr<Skill>> &skills)
{
    int n = 4;
    for(int i = 0; i < n; i++)
    {
        std::cout << "[" <<i+1<<"]: ("
                  << std::setw(2)
                  << player->uses[i]
                  << "/10) ";
        for(int j = 0; j < skills.size (); j++)
        {
            if (player->skills[ i ] == skills[ j ]->id)
            {
                std::cout << skills[ j ]->name << " ";
                if (! skills[ j ]->target)
                {
                    std::cout << "enemy (-";
                    std::cout << skills[j]->damage << "hp)\n";
                }
                else
                {
                    std::cout << "yourself (+";
                    std::cout << skills[j]->damage << "hp)\n";
                }
            }
        }
    }
    std::cout << "\n[>]: ";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq 0xbbbd(%rip), %r15      # 0x10fd0
movl $0x1, %edx
movq %r15, %rdi
leaq 0x6539(%rip), %rsi      # 0xb95b
callq 0x3140
leaq 0x1(%r12), %rsi
movq %r15, %rdi
movq %rsi, (%rsp)
callq 0x31b0
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
leaq 0x611d(%rip), %rsi      # 0xb567
callq 0x3140
movq (%r13), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r13,%rax)
movq (%r14), %rax
movl 0x2c(%rax,%r12,4), %esi
movq %r13, %rdi
callq 0x31b0
movl $0x5, %edx
movq %rax, %rdi
leaq 0x60ed(%rip), %rsi      # 0xb56c
callq 0x3140
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x5540
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14), %rcx
movl 0x1c(%rcx,%r12,4), %ecx
movq (%rax,%r13), %rax
cmpl (%rax), %ecx
jne 0x5522
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r15, %rdi
callq 0x3140
movl $0x1, %edx
movq %rax, %rdi
leaq 0x60f0(%rip), %rsi      # 0xb5b5
callq 0x3140
movq (%rbx), %rax
movq (%rax,%r13), %rax
cmpb $0x0, 0x2c(%rax)
je 0x54e8
movl $0xb, %edx
movq %r15, %rdi
leaq 0x609a(%rip), %rsi      # 0xb580
jmp 0x54f7
movl $0x8, %edx
movq %r15, %rdi
leaq 0x607b(%rip), %rsi      # 0xb572
callq 0x3140
movq (%rbx), %rax
movq (%rax,%r13), %rax
movl 0x28(%rax), %esi
movq %r15, %rdi
callq 0x31b0
movl $0x4, %edx
movq %rax, %rdi
leaq 0x605e(%rip), %rsi      # 0xb57b
callq 0x3140
incq %rbp
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x10, %r13
cmpq %rbp, %rcx
ja 0x5496
movq (%rsp), %r12
cmpq $0x4, %r12
jne 0x5413
movq 0xba7b(%rip), %rdi      # 0x10fd0
leaq 0x6030(%rip), %rsi      # 0xb58c
movl $0x6, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/create/Create.cpp
// Function: Create::createPlayer(std::vector<std::shared_ptr<Player>, std::allocator<std::shared_ptr<Player>>>&, int&)
std::vector<std::shared_ptr<Player>> Create::createPlayer(std::vector<std::shared_ptr<Player>> &players, int &status)
{
    if (players.size () < 5)
    {
        if( status ==1 || status ==2 || status ==3)
        {
            players.push_back (Factory::getInstance().createPlayer(status));
            return players;
        }
        else
            return players;
    }
    else
    {
        std::cout << "Characters limit" << "\n";
        return players;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
cmpq $0x40, %rax
ja 0x5f1b
movq %rcx, %r15
movl (%rcx), %eax
decl %eax
cmpl $0x2, %eax
ja 0x5f4a
callq 0x4808
movl (%r15), %esi
movq %rsp, %r15
movq %r15, %rdi
callq 0x4826
movq %r14, %rdi
movq %r15, %rsi
callq 0x601a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5f4a
callq 0x5c88
jmp 0x5f4a
movq 0xb0ae(%rip), %r15      # 0x10fd0
leaq 0x56a8(%rip), %rsi      # 0xb5d1
movl $0x10, %edx
movq %r15, %rdi
callq 0x3140
leaq 0x5739(%rip), %rsi      # 0xb676
movl $0x1, %edx
movq %r15, %rdi
callq 0x3140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f7c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5f74
callq 0x5c88
movq %rbx, %rdi
callq 0x31c0
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/stats/Stats.cpp
// Function: Stats::printMoves(std::shared_ptr<Player> const&, std::vector<std::shared_ptr<Skill>, std::allocator<std::shared_ptr<Skill>>> const&)
void Stats::printMoves(const std::shared_ptr<Player> &player, const std::vector<std::shared_ptr<Skill>> &skills)
{
    int n = 4;
    for(int i = 0; i < n; i++)
    {
        std::cout << "("
                  << std::setw(2)
                  << player->uses[i]
                  << "/10) ";
        for(int j = 0; j < skills.size (); j++)
        {
            if (player->skills[ i ] == skills[ j ]->id)
            {
                std::cout << skills[ j ]->name << "\n";
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
xorl %r12d, %r12d
movq 0x9d13(%rip), %r15      # 0x10fd0
movl $0x1, %edx
movq %r15, %rdi
leaq 0x429e(%rip), %rsi      # 0xb56a
callq 0x3140
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r15,%rax)
movq (%r14), %rax
movl 0x2c(%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x31b0
movl $0x5, %edx
movq %rax, %rdi
leaq 0x426c(%rip), %rsi      # 0xb56c
callq 0x3140
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x7361
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14), %rcx
movl 0x1c(%rcx,%r12,4), %ecx
movq (%rax,%r13), %rax
cmpl (%rax), %ecx
jne 0x7347
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r15, %rdi
callq 0x3140
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4334(%rip), %rsi      # 0xb676
callq 0x3140
incq %rbp
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x10, %r13
cmpq %rbp, %rcx
ja 0x7313
incq %r12
cmpq $0x4, %r12
jne 0x72bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/training/Training.cpp
// Function: Training::openTraining(std::shared_ptr<Player>&)
void Training::openTraining(std::shared_ptr<Player> &player)
{
    int z = 0;
    do
    {
        print();
        std::cout << player->name << "level points ( " << player->level_points << " )\n";
        z = choice();
        if(player->level_points > 0)
        {
            switch(z)
            {
                case e_training_health:
                {
                    player->hitpoints+=2;
                    player->max_hitpoints+=2;
                }
                    break;

                case e_training_strength:
                {
                    player->strength+=1;
                }
                    break;

                case e_training_agility:
                {
                    player->agility+=1;
                }
                    break;

                case e_training_intelligence:
                {
                    player->intelligence+=1;
                }
                    break;
            }
            player->level_points--;
        }
        else
            std::cout << "Not enough level points ;(\n";
    }while(z != 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x9c38(%rip), %r15      # 0x10fd0
leaq 0x4274(%rip), %r13      # 0xb613
leaq 0x44ca(%rip), %r12      # 0xb870
movq %r14, %rdi
callq 0x7470
movq (%rbx), %rax
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
movq %r15, %rdi
callq 0x3140
movq %rax, %rbp
movl $0xf, %edx
movq %rax, %rdi
leaq 0x44ad(%rip), %rsi      # 0xb880
callq 0x3140
movq (%rbx), %rax
movl 0x90(%rax), %esi
movq %rbp, %rdi
callq 0x31b0
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x3140
movq %r14, %rdi
callq 0x75ea
movl %eax, %ebp
movq (%rbx), %rax
movl 0x90(%rax), %ecx
testl %ecx, %ecx
jle 0x742b
leal -0x1(%rbp), %edx
cmpl $0x3, %edx
ja 0x744e
movslq (%r12,%rdx,4), %rdx
addq %r12, %rdx
jmpq *%rdx
addl $0x2, 0x8(%rax)
addl $0x2, 0xc(%rax)
jmp 0x744e
movl $0x1b, %edx
movq %r15, %rdi
leaq 0x4456(%rip), %rsi      # 0xb890
callq 0x3140
jmp 0x7456
incl 0x14(%rax)
jmp 0x744e
incl 0x18(%rax)
jmp 0x744e
incl 0x10(%rax)
decl %ecx
movl %ecx, 0x90(%rax)
testl %ebp, %ebp
jne 0x73a6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/Game.cpp
// Function: Game::print()
void Game::print()
{
    std::cout << "---\n"
              << name << "\n"
              << "---\n";
    for(int i = 1; i != this->map_Choices.size (); i++)
        std::cout << "[" << i << "] " << this->map_Choices[i] << '\n';
    std::cout << "---\n" << "[0] " << this->map_Choices[0] << '\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x9b48(%rip), %r15      # 0x10fd0
leaq 0x41e1(%rip), %r14      # 0xb670
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3140
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r15, %rdi
callq 0x3140
movq %rax, %r15
leaq 0x41bd(%rip), %rsi      # 0xb676
movl $0x1, %edx
movq %rax, %rdi
callq 0x3140
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3140
movl $0x1, 0xc(%rsp)
cmpq $0x1, 0x28(%rbx)
je 0x7575
movq 0x9ae0(%rip), %r14      # 0x10fd0
leaq 0x429e(%rip), %r12      # 0xb795
leaq 0xc(%rsp), %r13
leaq 0xb(%rsp), %rbp
movl $0x1, %edx
movq %r14, %rdi
leaq 0x444b(%rip), %rsi      # 0xb95b
callq 0x3140
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x31b0
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3140
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6e16
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x3140
movb $0xa, 0xb(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x3140
movslq 0xc(%rsp), %rax
incq %rax
movl %eax, 0xc(%rsp)
cmpq %rax, 0x28(%rbx)
jne 0x7501
movq 0x9a54(%rip), %r14      # 0x10fd0
leaq 0x40ed(%rip), %rsi      # 0xb670
movl $0x4, %edx
movq %r14, %rdi
callq 0x3140
leaq 0x41fc(%rip), %rsi      # 0xb793
movl $0x4, %edx
movq %r14, %rdi
callq 0x3140
leaq 0x14(%rsp), %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x3140
leaq 0x13(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/Game.cpp
// Function: Game::choice()
int Game::choice()
{
    int x = 0;
    do
    {
        std::cout << "[>] ";
        std::cin >> x;
    }while(isdigit(x)!=0);
    return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
movl $0x0, (%rbx)
movq 0x99cc(%rip), %r14      # 0x10fd0
leaq 0x42a1(%rip), %r15      # 0xb8ac
movq 0x99ce(%rip), %r12      # 0x10fe0
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3140
movq %r12, %rdi
movq %rbx, %rsi
callq 0x30a0
movl 0x4(%rsp), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x7612
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/skills/Skill.cpp
// Function: Skill::printType[abi:cxx11](e_MoveType)
std::string Skill::printType(e_MoveType type)
{
    switch(type)
    {
        case e_type_str:
            return "STRE";
        case e_type_agi:
            return "AGIL";
        case e_type_int:
            return "INTE";
        default:
            return "";
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x2, %esi
je 0x8037
cmpl $0x1, %esi
je 0x8027
testl %esi, %esi
jne 0x804a
leaq 0x3943(%rip), %rsi      # 0xb961
leaq 0x3940(%rip), %rdx      # 0xb965
jmp 0x8045
leaq 0x3938(%rip), %rsi      # 0xb966
leaq 0x3935(%rip), %rdx      # 0xb96a
jmp 0x8045
leaq 0x392d(%rip), %rsi      # 0xb96b
leaq 0x392a(%rip), %rdx      # 0xb96f
movq %rbx, %rdi
jmp 0x8057
leaq 0x390f(%rip), %rdx      # 0xb960
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3bd8
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/./data/game/menu/Menu.h
// Function: Menu::Menu()
Menu()
    {
        name                            = "[M] Main Menu";
        map_Choices[e_menu_cancel]      = "Cancel";
        map_Choices[e_menu_create]      = "Create";
        map_Choices[e_menu_select]      = "Select";
        map_Choices[e_menu_stats]       = "Stats";
        map_Choices[e_menu_battle]      = "Battle";
        map_Choices[e_menu_shop]        = "Shop";
        map_Choices[e_menu_training]    = "Training";
        map_Choices[e_menu_items]       = "Items";
        map_Choices[e_menu_moves]       = "Skills";
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
leaq 0x27c5(%rip), %rcx      # 0xbace
movl $0xd, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x27a6(%rip), %rcx      # 0xbadc
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x277f(%rip), %rcx      # 0xbae3
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x279b(%rip), %rcx      # 0xbb2d
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x3, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x272a(%rip), %rcx      # 0xbaea
movl $0x5, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x4, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x2702(%rip), %rcx      # 0xbaf0
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x5, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x2813(%rip), %rcx      # 0xbc2f
movl $0x4, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x6, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x26ad(%rip), %rcx      # 0xbaf7
movl $0x8, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x7, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x2688(%rip), %rcx      # 0xbb00
movl $0x5, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x8, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x2660(%rip), %rcx      # 0xbb06
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x94d0
jmp 0x94d0
jmp 0x94d0
jmp 0x94d0
jmp 0x94d0
jmp 0x94d0
jmp 0x94d0
jmp 0x94d0
jmp 0x94d0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa15a
movq %r14, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/./data/game/create/Create.h
// Function: Create::Create()
Create()
    {
        name                            = "[N] New Character";
        map_Choices[e_create_cancel]    = "Cancel";
        map_Choices[e_create_warrior]   = "Warrior";
        map_Choices[e_create_rogue]     = "Rogue";
        map_Choices[e_create_mage]      = "Mage";
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
leaq 0x24a2(%rip), %rcx      # 0xbb0d
movl $0x11, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x2444(%rip), %rcx      # 0xbadc
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1a44(%rip), %rcx      # 0xb10a
movl $0x7, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1b0f(%rip), %rcx      # 0xb203
movl $0x5, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x3, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1b2e(%rip), %rcx      # 0xb250
movl $0x4, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x9742
jmp 0x9742
jmp 0x9742
jmp 0x9742
movq %rax, %r14
movq %rbx, %rdi
callq 0xa15a
movq %r14, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/./data/game/shop/Shop.h
// Function: Shop::Shop()
Shop()
    {
        name                                    = "[S] Shop Atrributes";
        map_Choices[e_shop_cancel]              = "Cancel";
        map_Choices[e_shop_heal]                = " Heal yourself";
        map_Choices[e_shop_revive]              = "(100 gp) Revive character";
        map_Choices[e_shop_recover]             = " Recover all skills";
        map_Choices[e_shop_add_hitpoints]       = "( 75 gp) +10 hitpoints";
        map_Choices[e_shop_add_strength]        = "( 50 gp) + 2 strength";
        map_Choices[e_shop_add_agility]         = "( 50 gp) + 2 agility";
        map_Choices[e_shop_add_intelligence]    = "( 50 gp) + 2 intelligence";
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
leaq 0x2083(%rip), %rcx      # 0xbb34
movl $0x13, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1ffe(%rip), %rcx      # 0xbadc
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x203c(%rip), %rcx      # 0xbb48
movl $0xe, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x201d(%rip), %rcx      # 0xbb57
movl $0x19, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x3, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x2009(%rip), %rcx      # 0xbb71
movl $0x13, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x4, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1fef(%rip), %rcx      # 0xbb85
movl $0x16, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x5, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1fd8(%rip), %rcx      # 0xbb9c
movl $0x15, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x6, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1fc0(%rip), %rcx      # 0xbbb2
movl $0x14, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x7, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1fa7(%rip), %rcx      # 0xbbc7
movl $0x19, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x9c48
jmp 0x9c48
jmp 0x9c48
jmp 0x9c48
jmp 0x9c48
jmp 0x9c48
jmp 0x9c48
jmp 0x9c48
movq %rax, %r14
movq %rbx, %rdi
callq 0xa15a
movq %r14, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/./data/game/training/Training.h
// Function: Training::Training()
Training()
    {
        name = "[T] Training Center";
        map_Choices[ e_training_cancel ] = "Cancel";
        map_Choices[ e_training_health ] = "+2 Health";
        map_Choices[ e_training_strength ] = "+1 Strength";
        map_Choices[ e_training_agility ] = "+1 Agility";
        map_Choices[ e_training_intelligence ] = "+1 Intelligence";
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
leaq 0x1e4c(%rip), %rcx      # 0xbbe1
movl $0x13, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1d1a(%rip), %rcx      # 0xbadc
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1e05(%rip), %rcx      # 0xbbf5
movl $0x9, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1de1(%rip), %rcx      # 0xbbff
movl $0xb, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x3, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1dbf(%rip), %rcx      # 0xbc0b
movl $0xa, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x4, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1d9c(%rip), %rcx      # 0xbc16
movl $0xf, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x9e9c
jmp 0x9e9c
jmp 0x9e9c
jmp 0x9e9c
jmp 0x9e9c
movq %rax, %r14
movq %rbx, %rdi
callq 0xa15a
movq %r14, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/./data/game/items/Item.h
// Function: Item::Item()
Item()
    {
        name = "[I] Item Shop";
        map_Choices[ e_item_cancel ] = "Cancel";
        map_Choices[ e_item_dagger ] = "( 50 gp) + 5 dagger";
        map_Choices[ e_item_shortsword ] = "(120 gp) +10 short sword";
        map_Choices[ e_item_greataxe ] = "(299 gp) +19 great axe";
        map_Choices[ e_item_heavyhammer ] = "(420 gp) +35 heavy hammer";
        map_Choices[ e_item_devilscythe ] = "(666 gp) +666 Legendary Lucifer's Scythe ";
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
leaq 0x1c3d(%rip), %rcx      # 0xbc26
movl $0xd, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1ac6(%rip), %rcx      # 0xbadc
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1bf0(%rip), %rcx      # 0xbc34
movl $0x13, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1bd6(%rip), %rcx      # 0xbc48
movl $0x18, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x3, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1bc1(%rip), %rcx      # 0xbc61
movl $0x16, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x4, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1baa(%rip), %rcx      # 0xbc78
movl $0x19, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
leaq 0x4(%rsp), %rsi
movl $0x5, (%rsi)
movq %rbx, %rdi
callq 0x658a
movq 0x8(%rax), %rdx
leaq 0x1b96(%rip), %rcx      # 0xbc92
movl $0x29, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xa120
jmp 0xa120
jmp 0xa120
jmp 0xa120
jmp 0xa120
jmp 0xa120
movq %rax, %r14
movq %rbx, %rdi
callq 0xa15a
movq %r14, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ahmadsalim[P]qsort-inline/benchmark_cpp.cpp
// Function: main
int main() {
    int ary[LARGE_SIZE];
    // generate random data
    std::generate( ary, ary + LARGE_SIZE, rnd() );
    std::sort( ary, ary + LARGE_SIZE );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x61a88, %rsp          # imm = 0x61A88
xorl %ebx, %ebx
movabsq $0xa7c5ac471b47843, %r14 # imm = 0xA7C5AC471B47843
callq 0x1030
movslq %eax, %rcx
movq %rcx, %rax
shrq $0x5, %rax
mulq %r14
shrq $0x7, %rdx
imull $0x186a0, %edx, %eax    # imm = 0x186A0
subl %eax, %ecx
movl %ecx, (%rsp,%rbx)
addq $0x4, %rbx
cmpq $0x61a80, %rbx          # imm = 0x61A80
jne 0x1172
leaq 0x61a80(%rsp), %rbx
movq %rsp, %r14
movl $0x20, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11d3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12ae
xorl %eax, %eax
addq $0x61a88, %rsp          # imm = 0x61A88
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/parser.cpp
// Function: splitStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string> splitStr(std::string s, const std::string& delimiter) {
    std::vector<std::string> tokens;
    size_t pos = 0;
    std::string token;
    while ((pos = s.find(delimiter)) != std::string::npos) {
        token = s.substr(0, pos);
        tokens.push_back(token);
        s.erase(0, pos + delimiter.length());
    }
    tokens.push_back(s);
    return tokens;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x22d0
cmpq $-0x1, %rax
je 0x27d0
movq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2200
movq %r13, %rdi
movq %r12, %rsi
callq 0x2230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x27b2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x420a
addq 0x8(%r15), %rbp
movq %r14, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2080
jmp 0x2761
movq %rbx, %rdi
movq %r14, %rsi
callq 0x420a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x27f7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x280d
jmp 0x280d
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x282c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x4248
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/commands.cpp
// Function: scanRelation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void scanRelation(const string& relationName) {
    if (!isRelationExist(relationName)) {
        cout << "Error: Relation " << relationName << " doesn't exist.\n";
        return;
    }

    if (isRelationInRelationInt(relationName)) {
        relationNameToRelationInt[relationName]->scanIndex();
    }
    else if (isRelationInRelationStr(relationName)) {
        relationNameToRelationStr[relationName]->scanIndex();
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4893
testb %al, %al
je 0x4f03
leaq 0xb2e7(%rip), %rdi      # 0x101b8
movq %rbx, %rsi
callq 0x5ff2
leaq 0xb2e0(%rip), %rcx      # 0x101c0
cmpq %rcx, %rax
je 0x4f48
leaq 0xb2cc(%rip), %rdi      # 0x101b8
movq %rbx, %rsi
callq 0x575e
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6432
movq 0xb0c6(%rip), %r14      # 0xffd0
leaq 0x63fc(%rip), %rsi      # 0xb30d
movl $0x10, %edx
movq %r14, %rdi
callq 0x2220
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2220
leaq 0x6542(%rip), %rsi      # 0xb476
movl $0x10, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
leaq 0xb299(%rip), %rdi      # 0x101e8
movq %rbx, %rsi
callq 0x6038
leaq 0xb292(%rip), %rcx      # 0x101f0
cmpq %rcx, %rax
je 0x4f81
leaq 0xb27e(%rip), %rdi      # 0x101e8
movq %rbx, %rsi
callq 0x57da
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6dc8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/commands.cpp
// Function: displayPage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void displayPage(const string& relationName, const string& pageId) {
    if (!isRelationExist(relationName)) {
        cout << "Error: Relation " << relationName << " doesn't exist.\n";
        return;
    }

    if (!is_number(pageId)) {
        cout << "Error: page id should be 0 or a positive integer\n";
        return;
    }

    int pageIdInt = stoi(pageId);

    if (pageIdInt < 0) {
        cout << "Error: page id should be 0 or a positive integer\n";
        return;
    }

    if (isRelationInRelationInt(relationName)) {
        relationNameToRelationInt[relationName]->printPage(pageIdInt);
    }
    else if (isRelationInRelationStr(relationName)) {
        relationNameToRelationStr[relationName]->printPage(pageIdInt);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4893
testb %al, %al
je 0x55a7
movq %r14, %rdi
callq 0x4bbb
testb %al, %al
je 0x55e2
movq (%r14), %r12
callq 0x2060
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x2240
cmpq %r12, (%r13)
je 0x565a
movq %rax, %r14
movslq %r14d, %rax
cmpq %r14, %rax
jne 0x5666
movl (%r15), %eax
cmpl $0x22, %eax
je 0x5666
testl %eax, %eax
jne 0x5557
movl %ebp, (%r15)
testl %r14d, %r14d
js 0x55e2
leaq 0xac51(%rip), %rdi      # 0x101b8
movq %rbx, %rsi
callq 0x5ff2
leaq 0xac4a(%rip), %rcx      # 0x101c0
cmpq %rcx, %rax
je 0x5608
leaq 0xac32(%rip), %rdi      # 0x101b8
movq %rbx, %rsi
callq 0x575e
movq (%rax), %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x680c
movq 0xaa22(%rip), %r14      # 0xffd0
leaq 0x5d58(%rip), %rsi      # 0xb30d
movl $0x10, %edx
movq %r14, %rdi
callq 0x2220
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2220
leaq 0x5e9e(%rip), %rsi      # 0xb476
movl $0x10, %edx
movq %rax, %rdi
jmp 0x55f5
movq 0xa9e7(%rip), %rdi      # 0xffd0
leaq 0x5de4(%rip), %rsi      # 0xb3d4
movl $0x31, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
leaq 0xabd9(%rip), %rdi      # 0x101e8
movq %rbx, %rsi
callq 0x6038
leaq 0xabd2(%rip), %rcx      # 0x101f0
cmpq %rcx, %rax
je 0x564b
leaq 0xabbe(%rip), %rdi      # 0x101e8
movq %rbx, %rsi
callq 0x57da
movq (%rax), %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x72fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c6c(%rip), %rdi      # 0xb2cd
callq 0x2120
leaq 0x5c60(%rip), %rdi      # 0xb2cd
callq 0x2250
cmpl $0x0, (%r15)
jne 0x567b
movl %ebp, (%r15)
movq %rax, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/commands.cpp
// Function: statisticsRelation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void statisticsRelation(const string& relationName) {
    if (!isRelationExist(relationName)) {
        cout << "Error: Relation " << relationName << " doesn't exist.\n";
        return;
    }

    if (isRelationInRelationInt(relationName)) {
        relationNameToRelationInt[relationName]->printStatistics();
    }
    else if (isRelationInRelationStr(relationName)) {
        relationNameToRelationStr[relationName]->printStatistics();
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4893
testb %al, %al
je 0x56cc
leaq 0xab1e(%rip), %rdi      # 0x101b8
movq %rbx, %rsi
callq 0x5ff2
leaq 0xab17(%rip), %rcx      # 0x101c0
cmpq %rcx, %rax
je 0x5711
leaq 0xab03(%rip), %rdi      # 0x101b8
movq %rbx, %rsi
callq 0x575e
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6816
movq 0xa8fd(%rip), %r14      # 0xffd0
leaq 0x5c33(%rip), %rsi      # 0xb30d
movl $0x10, %edx
movq %r14, %rdi
callq 0x2220
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2220
leaq 0x5d79(%rip), %rsi      # 0xb476
movl $0x10, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
leaq 0xaad0(%rip), %rdi      # 0x101e8
movq %rbx, %rsi
callq 0x6038
leaq 0xaac9(%rip), %rcx      # 0x101f0
cmpq %rcx, %rax
je 0x574a
leaq 0xaab5(%rip), %rdi      # 0x101e8
movq %rbx, %rsi
callq 0x57da
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7306
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/Relation.cpp
// Function: Relation<int>::Relation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
Relation<T>::Relation(const string& relationName, const string& keyType, int recordLength)
    : _bpt(62), _sp(recordLength)
{
    _relationName = relationName;
    _keyType = keyType;
    _recordLength = recordLength;

    // initialize BPlusTree
    // calculate the key num per node in B+ tree
    int bptKeySize;
    if (_keyType == "string" || _keyType == "String" || _keyType == "str") {
        bptKeySize = 10;
    }
    else {
        bptKeySize = 4;
    }
    int bptMaxKeyNum = (_pageSize - 12) / (bptKeySize + 4);
    _bpt = BPlusTree<T>(bptMaxKeyNum);

    // initialize SlottedPageStructure
    // _sp = SlottedPageStructure(recordLength);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movabsq $0x400000200, %rax      # imm = 0x400000200
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x50(%rdi), %r15
movq %r15, %rdi
movl $0x3e, %esi
callq 0x84b4
leaq 0x68(%r13), %rdi
movq %rdi, 0x18(%rsp)
movl %ebp, %esi
callq 0x7428
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x2110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2110
movl %ebp, 0x48(%r13)
leaq 0x5224(%rip), %rsi      # 0xb344
movq %r14, %rdi
callq 0x20b0
movl $0xe, %ebx
testl %eax, %eax
je 0x6162
leaq 0x5213(%rip), %rsi      # 0xb34b
movq %r14, %rdi
callq 0x20b0
testl %eax, %eax
je 0x6162
leaq 0x5207(%rip), %rsi      # 0xb352
movq %r14, %rdi
callq 0x20b0
testl %eax, %eax
movl $0xe, %eax
movl $0x8, %ebx
cmovel %eax, %ebx
movl (%r13), %eax
addl $-0xc, %eax
cltd
idivl %ebx
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x84b4
movl 0x30(%rsp), %eax
movl %eax, 0x10(%r15)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%r15)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x619a
movq %rax, %rbx
movq 0x18(%rsp), %rdi
callq 0x61ec
jmp 0x61ac
movq %rax, %rbx
movq (%r14), %rdi
cmpq (%rsp), %rdi
je 0x61c4
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0x61e3
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/Relation.cpp
// Function: Relation<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::insertRecord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Relation<T>::insertRecord(T key, string record) {
    cout << "Insert into relation " << _relationName << " with key " << key << " and record " << record << ":\n";
    int rid = _sp.insertRecord(record);
    _bpt.insertValue(key, rid);
    cout << "    Record inserted.\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x953e(%rip), %r12      # 0xffd0
leaq 0x496e(%rip), %rsi      # 0xb407
movl $0x15, %edx
movq %r12, %rdi
callq 0x2220
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r12, %rdi
callq 0x2220
movq %rax, %r12
leaq 0x495d(%rip), %rsi      # 0xb41d
movl $0xa, %edx
movq %rax, %rdi
callq 0x2220
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x2220
movq %rax, %r12
leaq 0x4942(%rip), %rsi      # 0xb428
movl $0xc, %edx
movq %rax, %rdi
callq 0x2220
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x2220
leaq 0x47fd(%rip), %rsi      # 0xb306
movl $0x2, %edx
movq %rax, %rdi
callq 0x2220
leaq 0x68(%rbx), %r12
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x42ae
movq %r12, %rdi
movq %r15, %rsi
callq 0x7476
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6b5e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
addq $0x50, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x42ae
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x9474
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6ba6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x9423(%rip), %rdi      # 0xffd0
leaq 0x4881(%rip), %rsi      # 0xb435
movl $0x15, %edx
callq 0x2220
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x6bdf
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6bf0
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/Relation.cpp
// Function: Relation<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::deleteRecord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Relation<T>::deleteRecord(T key) {
    cout << "Delete record in relation " << _relationName << " by key " << key << ":\n";
    if (!_bpt.checkKeyExist(key)) {
        cout << "    Key doesn't exist.\n";
    }
    else {
        int rid = _bpt.queryValue(key);
        _sp.deleteRecord(rid);
        _bpt.deleteValue(key);
        cout << "    Record deleted.\n";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x93bd(%rip), %r15      # 0xffd0
leaq 0x4831(%rip), %rsi      # 0xb44b
movl $0x1a, %edx
movq %r15, %rdi
callq 0x2220
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
leaq 0x4825(%rip), %rsi      # 0xb466
movl $0x8, %edx
movq %rax, %rdi
callq 0x2220
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x2220
leaq 0x46a2(%rip), %rsi      # 0xb306
movl $0x2, %edx
movq %rax, %rdi
callq 0x2220
leaq 0x50(%r14), %r15
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x42ae
movq %r15, %rdi
movq %r12, %rsi
callq 0x9326
movl %eax, %ebp
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x6cb9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21e0
testb %bpl, %bpl
je 0x6d6b
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x42ae
movq %r15, %rdi
movq %r12, %rsi
callq 0x9920
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6d06
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
addq $0x68, %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x7608
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x42ae
movq %r15, %rdi
movq %rbx, %rsi
callq 0x96e2
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6d56
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x9273(%rip), %rdi      # 0xffd0
leaq 0x4723(%rip), %rsi      # 0xb487
movl $0x14, %edx
jmp 0x6d7e
movq 0x925e(%rip), %rdi      # 0xffd0
leaq 0x46f6(%rip), %rsi      # 0xb46f
movl $0x17, %edx
callq 0x2220
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x6dae
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x6dae
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x6dbf
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/Relation.cpp
// Function: Relation<int>::scanIndex()
void Relation<T>::scanIndex() {
    // Output (# of leaf pages, # of total index pages)
    cout << "Scan index pages of relation " << _relationName << ":\n";
    cout << "    # of leaf pages: " << _bpt.getLeafPageNum() << endl;
    cout << "    # of total index pages: " << _bpt.getPageNum() << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x9b8f(%rip), %rbx      # 0xffd0
leaq 0x5054(%rip), %rsi      # 0xb49c
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x2220
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x2220
leaq 0x4e9a(%rip), %rsi      # 0xb306
movl $0x2, %edx
movq %rax, %rdi
callq 0x2220
leaq 0x503a(%rip), %rsi      # 0xb4ba
movl $0x15, %edx
movq %rbx, %rdi
callq 0x2220
addq $0x50, %r14
movq %r14, %rdi
callq 0x8d0c
movq %rbx, %rdi
movl %eax, %esi
callq 0x22c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
leaq 0x4ffc(%rip), %rsi      # 0xb4d0
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x2220
movq %r14, %rdi
callq 0x8d08
movq %rbx, %rdi
movl %eax, %esi
callq 0x22c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/Relation.cpp
// Function: Relation<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::queryRid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Relation<T>::queryRid(T key) {
    // Output (Key, size of rest of the record, RID)
    cout << "Query relation " << _relationName << " with key " << key << ":" << endl;
    if (!_bpt.checkKeyExist(key)) {
        cout << "    Key doesn't exist.\n";
    }
    else {
        cout << "    RID: " << _bpt.queryValue(key) << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90ff(%rip), %r15      # 0xffd0
leaq 0x4615(%rip), %rsi      # 0xb4ed
movl $0xf, %edx
movq %r15, %rdi
callq 0x2220
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
leaq 0x451e(%rip), %rsi      # 0xb41d
movl $0xa, %edx
movq %rax, %rdi
callq 0x2220
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
leaq 0x462f(%rip), %rsi      # 0xb554
movl $0x1, %edx
movq %rax, %rdi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
addq $0x50, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x42ae
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9326
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fa2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x9027(%rip), %rdi      # 0xffd0
testb %bpl, %bpl
je 0x703d
leaq 0x4544(%rip), %rsi      # 0xb4fd
movl $0x9, %edx
callq 0x2220
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x42ae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9920
movq 0x8fdc(%rip), %rdi      # 0xffd0
movl %eax, %esi
callq 0x22c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x704e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x704e
leaq 0x442b(%rip), %rsi      # 0xb46f
movl $0x17, %edx
callq 0x2220
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x706c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x707d
movq (%r12), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::insertRecordAtEnd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int SlottedPageStructure::insertRecordAtEnd(const string& record) {
    int spaceId = _records.size();
    _records.push_back(record);
    _recordsExist.push_back(true);
    return spaceId2rid(spaceId);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x20, %rdi
movq 0x28(%rbx), %r14
subq 0x20(%rbx), %r14
shrq $0x5, %r14
callq 0x420a
leaq 0x38(%rbx), %rdi
movl $0x1, %esi
callq 0x7c48
movb 0x4(%rbx), %cl
movl %r14d, %eax
cltd
idivl 0x1c(%rbx)
shlb $0x3, %cl
shll %cl, %eax
addl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::deleteRecord(int)
void SlottedPageStructure::deleteRecord(int rid) {
    int spaceId = rid2spaceId(rid);
    if (spaceId >= _records.size()) {
        cerr << "error: in deleteRecord, spaceId out of range\n";
        return;
    }
    if (_recordsExist[spaceId] == false) {
        cerr << "error: in deleteRecord, record has been deleted\n";
        return;
    }
    _recordsExist[spaceId] = false;
    _freeSpaces.push_back(spaceId);
}

// Assembly:
pushq %rax
movl %esi, %eax
movb 0x4(%rdi), %cl
shlb $0x3, %cl
sarl %cl, %esi
imull 0x1c(%rdi), %esi
movl $0x1, %r8d
shll %cl, %r8d
cltd
idivl %r8d
addl %esi, %edx
movl %edx, 0x4(%rsp)
movslq %edx, %rcx
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
sarq $0x5, %rax
cmpq %rcx, %rax
jbe 0x76ab
leaq 0x3f(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x38(%rdi), %rax
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
leaq 0x3f(%r8), %r9
andq %rcx, %r9
xorl %esi, %esi
cmpq %r8, %r9
setbe %sil
movl $0x1, %r8d
shlq %cl, %r8
movq -0x8(%rax,%rsi,8), %r9
btq %rcx, %r9
jae 0x76c0
leaq -0x8(,%rsi,8), %rcx
notq %r8
andq %r8, %r9
movq %r9, (%rax,%rcx)
movq 0x68(%rdi), %rsi
cmpq 0x70(%rdi), %rsi
je 0x76d9
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x68(%rdi)
jmp 0x76e7
movq 0x893e(%rip), %rdi      # 0xfff0
leaq 0x3f07(%rip), %rsi      # 0xb5c0
movl $0x2d, %edx
jmp 0x76d3
movq 0x8929(%rip), %rdi      # 0xfff0
leaq 0x3f20(%rip), %rsi      # 0xb5ee
movl $0x30, %edx
popq %rax
jmp 0x2220
addq $0x60, %rdi
leaq 0x4(%rsp), %rdx
callq 0x7c96
popq %rax
retq
nop