LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x4, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x10421
movq 0x1eccb(%rip), %rdi     # 0x2efd0
leaq 0xd1c6(%rip), %rsi      # 0x1d4d2
callq 0x41b0
movq %rax, -0x38(%rbp)
movl $0x2, %edi
callq 0xb850
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
callq 0x4230
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf60
movq %rax, %rdi
addq $0x2c, %rdi
movslq -0x20(%rbp), %rsi
callq 0xafa0
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0xd174(%rip), %rsi      # 0x1d4d4
callq 0x41b0
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb870
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x10411
movq -0x10(%rbp), %rdi
callq 0xaf60
movq %rax, %rdi
addq $0x1c, %rdi
movslq -0x20(%rbp), %rsi
callq 0x5000
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0xb890
movq %rax, %rdi
callq 0xb8b0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
jne 0x10401
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0xb890
movq %rax, %rdi
callq 0xb8b0
movq %rax, %rsi
addq $0x8, %rsi
movq 0x1ebe3(%rip), %rdi     # 0x2efd0
callq 0x4190
movq %rax, %rdi
leaq 0xd1de(%rip), %rsi      # 0x1d5da
callq 0x41b0
jmp 0x10403
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1036c
jmp 0x10413
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x102f2
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
callq 0x105f0
movq -0x10(%rbp), %rdi
callq 0xaf60
movq %rax, %rsi
addq $0x40, %rsi
movq 0x1eb11(%rip), %rdi     # 0x2efd0
callq 0x4190
movq %rax, %rdi
leaq 0xd316(%rip), %rsi      # 0x1d7e4
callq 0x41b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf60
movq -0x28(%rbp), %rdi
movl 0x90(%rax), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0xd07e(%rip), %rsi      # 0x1d577
callq 0x41b0
movq -0x20(%rbp), %rdi
callq 0x10730
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf60
cmpl $0x0, 0x90(%rax)
jle 0x105be
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x105a4
movq -0x30(%rbp), %rax
leaq 0xd299(%rip), %rcx      # 0x1d7d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0x8(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0xc(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0xc(%rax)
jmp 0x105a4
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x105a4
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x105a4
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0x90(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x90(%rax)
jmp 0x105d1
movq 0x1ea0b(%rip), %rdi     # 0x2efd0
leaq 0xd228(%rip), %rsi      # 0x1d7f4
callq 0x41b0
jmp 0x105d3
cmpl $0x0, -0x14(%rbp)
jne 0x1049f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x1e9c5(%rip), %rdi     # 0x2efd0
leaq 0xcfc2(%rip), %rsi      # 0x1d5d4
callq 0x41b0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0x4190
movq %rax, %rdi
leaq 0xcfa9(%rip), %rsi      # 0x1d5da
callq 0x41b0
movq %rax, %rdi
leaq 0xcf94(%rip), %rsi      # 0x1d5d4
callq 0x41b0
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xf9e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x106cb
movq 0x1e960(%rip), %rdi     # 0x2efd0
leaq 0xd248(%rip), %rsi      # 0x1d8bf
callq 0x41b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0xd068(%rip), %rsi      # 0x1d6f9
callq 0x41b0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0xc(%rbp), %rsi
callq 0xfa00
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4190
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1064c
movq 0x1e8fe(%rip), %rdi     # 0x2efd0
leaq 0xcefb(%rip), %rsi      # 0x1d5d4
callq 0x41b0
movq %rax, %rdi
leaq 0xd00f(%rip), %rsi      # 0x1d6f7
callq 0x41b0
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xde40
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4190
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x1e886(%rip), %rdi     # 0x2efd0
leaq 0xd0bf(%rip), %rsi      # 0x1d810
callq 0x41b0
movq 0x1e883(%rip), %rdi     # 0x2efe0
leaq -0xc(%rbp), %rsi
callq 0x40e0
movl -0xc(%rbp), %edi
callq 0x41a0
cmpl $0x0, %eax
jne 0x10743
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x11411
jmp 0x113f6
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x1145c
jmp 0x11400
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x114a7
jmp 0x114ec
leaq -0xd(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x42f0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xc498(%rip), %rsi      # 0x1d8c5
callq 0x4f50
jmp 0x11434
leaq -0xd(%rbp), %rdi
callq 0x4200
jmp 0x11531
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x4200
jmp 0x1153b
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x42f0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xc452(%rip), %rsi      # 0x1d8ca
callq 0x4f50
jmp 0x1147f
leaq -0x1d(%rbp), %rdi
callq 0x4200
jmp 0x11531
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x4200
jmp 0x1153b
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x42f0
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xc40c(%rip), %rsi      # 0x1d8cf
callq 0x4f50
jmp 0x114ca
leaq -0x1e(%rbp), %rdi
callq 0x4200
jmp 0x11531
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x4200
jmp 0x1153b
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x42f0
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xc3bc(%rip), %rsi      # 0x1d8c4
callq 0x4f50
jmp 0x1150f
leaq -0x1f(%rbp), %rdi
callq 0x4200
jmp 0x11531
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x4200
jmp 0x1153b
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x42e0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x17440
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
leaq 0x679b(%rip), %rsi      # 0x1da16
callq 0x4260
jmp 0x17282
movq -0x40(%rbp), %rdi
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xde40
movq %rax, -0x48(%rbp)
jmp 0x1729c
movq -0x48(%rbp), %rdi
leaq 0x677d(%rip), %rsi      # 0x1da24
callq 0x4260
jmp 0x172ae
movq -0x40(%rbp), %rdi
movl $0x1, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xde40
movq %rax, -0x50(%rbp)
jmp 0x172c8
movq -0x50(%rbp), %rdi
leaq 0x6758(%rip), %rsi      # 0x1da2b
callq 0x4260
jmp 0x172da
movq -0x40(%rbp), %rdi
movl $0x2, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xde40
movq %rax, -0x58(%rbp)
jmp 0x172f4
movq -0x58(%rbp), %rdi
leaq 0x6776(%rip), %rsi      # 0x1da75
callq 0x4260
jmp 0x17306
movq -0x40(%rbp), %rdi
movl $0x3, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xde40
movq %rax, -0x60(%rbp)
jmp 0x17320
movq -0x60(%rbp), %rdi
leaq 0x6707(%rip), %rsi      # 0x1da32
callq 0x4260
jmp 0x17332
movq -0x40(%rbp), %rdi
movl $0x4, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xde40
movq %rax, -0x68(%rbp)
jmp 0x1734c
movq -0x68(%rbp), %rdi
leaq 0x66e1(%rip), %rsi      # 0x1da38
callq 0x4260
jmp 0x1735e
movq -0x40(%rbp), %rdi
movl $0x5, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0xde40
movq %rax, -0x70(%rbp)
jmp 0x17378
movq -0x70(%rbp), %rdi
leaq 0x67f4(%rip), %rsi      # 0x1db77
callq 0x4260
jmp 0x1738a
movq -0x40(%rbp), %rdi
movl $0x6, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xde40
movq %rax, -0x78(%rbp)
jmp 0x173a4
movq -0x78(%rbp), %rdi
leaq 0x6690(%rip), %rsi      # 0x1da3f
callq 0x4260
jmp 0x173b6
movq -0x40(%rbp), %rdi
movl $0x7, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xde40
movq %rax, -0x80(%rbp)
jmp 0x173d0
movq -0x80(%rbp), %rdi
leaq 0x666d(%rip), %rsi      # 0x1da48
callq 0x4260
jmp 0x173e2
movq -0x40(%rbp), %rdi
movl $0x8, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xde40
movq %rax, -0x88(%rbp)
jmp 0x173ff
movq -0x88(%rbp), %rdi
leaq 0x6641(%rip), %rsi      # 0x1da4e
callq 0x4260
jmp 0x17414
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x17470
movq -0x10(%rbp), %rdi
callq 0x42e0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x17440
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
leaq 0x5a1d(%rip), %rsi      # 0x1da55
callq 0x4260
jmp 0x1803f
movq -0x30(%rbp), %rdi
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xde40
movq %rax, -0x38(%rbp)
jmp 0x18059
movq -0x38(%rbp), %rdi
leaq 0x59c0(%rip), %rsi      # 0x1da24
callq 0x4260
jmp 0x1806b
movq -0x30(%rbp), %rdi
movl $0x1, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xde40
movq %rax, -0x40(%rbp)
jmp 0x18085
movq -0x40(%rbp), %rdi
leaq 0x503f(%rip), %rsi      # 0x1d0cf
callq 0x4260
jmp 0x18097
movq -0x30(%rbp), %rdi
movl $0x2, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xde40
movq %rax, -0x48(%rbp)
jmp 0x180b1
movq -0x48(%rbp), %rdi
leaq 0x50bf(%rip), %rsi      # 0x1d17b
callq 0x4260
jmp 0x180c3
movq -0x30(%rbp), %rdi
movl $0x3, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xde40
movq %rax, -0x50(%rbp)
jmp 0x180dd
movq -0x50(%rbp), %rdi
leaq 0x50d0(%rip), %rsi      # 0x1d1b8
callq 0x4260
jmp 0x180ef
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x17470
movq -0x10(%rbp), %rdi
callq 0x42e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x17440
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
leaq 0x3ce1(%rip), %rsi      # 0x1da7c
callq 0x4260
jmp 0x19da2
movq -0x40(%rbp), %rdi
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xde40
movq %rax, -0x48(%rbp)
jmp 0x19dbc
movq -0x48(%rbp), %rdi
leaq 0x3c5d(%rip), %rsi      # 0x1da24
callq 0x4260
jmp 0x19dce
movq -0x40(%rbp), %rdi
movl $0x1, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xde40
movq %rax, -0x50(%rbp)
jmp 0x19de8
movq -0x50(%rbp), %rdi
leaq 0x3c9d(%rip), %rsi      # 0x1da90
callq 0x4260
jmp 0x19dfa
movq -0x40(%rbp), %rdi
movl $0x2, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xde40
movq %rax, -0x58(%rbp)
jmp 0x19e14
movq -0x58(%rbp), %rdi
leaq 0x3c80(%rip), %rsi      # 0x1da9f
callq 0x4260
jmp 0x19e26
movq -0x40(%rbp), %rdi
movl $0x3, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xde40
movq %rax, -0x60(%rbp)
jmp 0x19e40
movq -0x60(%rbp), %rdi
leaq 0x3c6e(%rip), %rsi      # 0x1dab9
callq 0x4260
jmp 0x19e52
movq -0x40(%rbp), %rdi
movl $0x4, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xde40
movq %rax, -0x68(%rbp)
jmp 0x19e6c
movq -0x68(%rbp), %rdi
leaq 0x3c56(%rip), %rsi      # 0x1dacd
callq 0x4260
jmp 0x19e7e
movq -0x40(%rbp), %rdi
movl $0x5, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0xde40
movq %rax, -0x70(%rbp)
jmp 0x19e98
movq -0x70(%rbp), %rdi
leaq 0x3c41(%rip), %rsi      # 0x1dae4
callq 0x4260
jmp 0x19eaa
movq -0x40(%rbp), %rdi
movl $0x6, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xde40
movq %rax, -0x78(%rbp)
jmp 0x19ec4
movq -0x78(%rbp), %rdi
leaq 0x3c2b(%rip), %rsi      # 0x1dafa
callq 0x4260
jmp 0x19ed6
movq -0x40(%rbp), %rdi
movl $0x7, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xde40
movq %rax, -0x80(%rbp)
jmp 0x19ef0
movq -0x80(%rbp), %rdi
leaq 0x3c14(%rip), %rsi      # 0x1db0f
callq 0x4260
jmp 0x19f02
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x17470
movq -0x10(%rbp), %rdi
callq 0x42e0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x17440
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
leaq 0x3291(%rip), %rsi      # 0x1db29
callq 0x4260
jmp 0x1a89f
movq -0x30(%rbp), %rdi
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xde40
movq %rax, -0x38(%rbp)
jmp 0x1a8b9
movq -0x38(%rbp), %rdi
leaq 0x3160(%rip), %rsi      # 0x1da24
callq 0x4260
jmp 0x1a8cb
movq -0x30(%rbp), %rdi
movl $0x1, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xde40
movq %rax, -0x40(%rbp)
jmp 0x1a8e5
movq -0x40(%rbp), %rdi
leaq 0x324d(%rip), %rsi      # 0x1db3d
callq 0x4260
jmp 0x1a8f7
movq -0x30(%rbp), %rdi
movl $0x2, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xde40
movq %rax, -0x48(%rbp)
jmp 0x1a911
movq -0x48(%rbp), %rdi
leaq 0x322b(%rip), %rsi      # 0x1db47
callq 0x4260
jmp 0x1a923
movq -0x30(%rbp), %rdi
movl $0x3, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xde40
movq %rax, -0x50(%rbp)
jmp 0x1a93d
movq -0x50(%rbp), %rdi
leaq 0x320b(%rip), %rsi      # 0x1db53
callq 0x4260
jmp 0x1a94f
movq -0x30(%rbp), %rdi
movl $0x4, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xde40
movq %rax, -0x58(%rbp)
jmp 0x1a969
movq -0x58(%rbp), %rdi
leaq 0x31ea(%rip), %rsi      # 0x1db5e
callq 0x4260
jmp 0x1a97b
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x17470
movq -0x10(%rbp), %rdi
callq 0x42e0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x17440
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
leaq 0x2866(%rip), %rsi      # 0x1db6e
callq 0x4260
jmp 0x1b30f
movq -0x38(%rbp), %rdi
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xde40
movq %rax, -0x40(%rbp)
jmp 0x1b329
movq -0x40(%rbp), %rdi
leaq 0x26f0(%rip), %rsi      # 0x1da24
callq 0x4260
jmp 0x1b33b
movq -0x38(%rbp), %rdi
movl $0x1, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xde40
movq %rax, -0x48(%rbp)
jmp 0x1b355
movq -0x48(%rbp), %rdi
leaq 0x281c(%rip), %rsi      # 0x1db7c
callq 0x4260
jmp 0x1b367
movq -0x38(%rbp), %rdi
movl $0x2, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xde40
movq %rax, -0x50(%rbp)
jmp 0x1b381
movq -0x50(%rbp), %rdi
leaq 0x2804(%rip), %rsi      # 0x1db90
callq 0x4260
jmp 0x1b393
movq -0x38(%rbp), %rdi
movl $0x3, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xde40
movq %rax, -0x58(%rbp)
jmp 0x1b3ad
movq -0x58(%rbp), %rdi
leaq 0x27f1(%rip), %rsi      # 0x1dba9
callq 0x4260
jmp 0x1b3bf
movq -0x38(%rbp), %rdi
movl $0x4, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xde40
movq %rax, -0x60(%rbp)
jmp 0x1b3d9
movq -0x60(%rbp), %rdi
leaq 0x27dc(%rip), %rsi      # 0x1dbc0
callq 0x4260
jmp 0x1b3eb
movq -0x38(%rbp), %rdi
movl $0x5, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0xde40
movq %rax, -0x68(%rbp)
jmp 0x1b405
movq -0x68(%rbp), %rdi
leaq 0x27ca(%rip), %rsi      # 0x1dbda
callq 0x4260
jmp 0x1b417
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x17470
movq -0x10(%rbp), %rdi
callq 0x42e0
nopl (%rax,%rax)
// File: umdreamer[P]leetcodeproblems/zigzagConversion.cpp
// Function: main
int main() {
    Solution sln;
    string s = "abcdefghijklmn";
    int n = 5;
    sln.convert(s, n);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2210
movq -0x88(%rbp), %rdx
leaq 0x1c84(%rip), %rsi      # 0x4004
leaq -0x28(%rbp), %rdi
callq 0x2440
jmp 0x238b
leaq -0x29(%rbp), %rdi
callq 0x2170
movl $0x5, -0x40(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2090
jmp 0x23aa
movl -0x40(%rbp), %ecx
leaq -0x60(%rbp), %rdi
leaq -0x5(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x24f0
jmp 0x23c0
leaq -0x60(%rbp), %rdi
callq 0x20d0
leaq -0x80(%rbp), %rdi
callq 0x20d0
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20d0
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2170
jmp 0x2431
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2428
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20d0
leaq -0x28(%rbp), %rdi
callq 0x20d0
movq -0x38(%rbp), %rdi
callq 0x2200
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x53e0
movq $0x0, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3360
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3470
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
je 0x3c76
movq -0x90(%rbp), %rsi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
callq 0x32b0
jmp 0x3be2
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x68(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x3320
movq -0xa0(%rbp), %rdi
callq 0x3190
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x5400
jmp 0x3c1e
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3390
movq -0xa8(%rbp), %rdx
movq -0x90(%rbp), %rdi
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x30a0
jmp 0x3c4e
jmp 0x3ba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3190
movq -0x88(%rbp), %rdi
callq 0x5470
jmp 0x3cb7
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x5400
jmp 0x3c8b
movb $0x1, -0x19(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3190
testb $0x1, -0x19(%rbp)
jne 0x3caa
movq -0x88(%rbp), %rdi
callq 0x5470
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3410
// File: ChaohuiYu[P]BPlusTree/commands.cpp
// Function: deleteRecord(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 deleteRecord(const string& relationName, const string& key) {
    // need to check if key should be integer
    // need to check if key exists

    if (!isRelationExist(relationName)) {
        cout << "Error: Relation " << relationName << " doesn't exist.\n";
        return;
    }

    if (isRelationInRelationInt(relationName)) {
        if (!is_number(key)) {
            cout << "Error: Key " << key << " is not a number.\n";
            return;
        }
        relationNameToRelationInt[relationName]->deleteRecord(stoi(key));
    }
    else if (isRelationInRelationStr(relationName)) {
        relationNameToRelationStr[relationName]->deleteRecord(key.substr(1, 10));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6940
testb $0x1, %al
jne 0x6cf0
movq 0x19304(%rip), %rdi     # 0x1ffc8
leaq 0xf636(%rip), %rsi      # 0x16301
callq 0x3280
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xf784(%rip), %rsi      # 0x1646a
callq 0x3280
jmp 0x6de9
movq -0x8(%rbp), %rdi
callq 0x6b80
testb $0x1, %al
jne 0x6cff
jmp 0x6d75
movq -0x10(%rbp), %rdi
callq 0x6bd0
testb $0x1, %al
jne 0x6d3f
movq 0x192b5(%rip), %rdi     # 0x1ffc8
leaq 0xf675(%rip), %rsi      # 0x1638f
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xf666(%rip), %rsi      # 0x1639b
callq 0x3280
jmp 0x6de9
movq -0x8(%rbp), %rsi
leaq 0x19526(%rip), %rdi     # 0x20270
callq 0x7770
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x5570
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0xa4e0
jmp 0x6de9
movq -0x8(%rbp), %rdi
callq 0x6c50
testb $0x1, %al
jne 0x6d84
jmp 0x6de7
movq -0x8(%rbp), %rsi
leaq 0x19511(%rip), %rdi     # 0x202a0
callq 0x7850
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x1, %edx
movl $0xa, %ecx
callq 0x32b0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xaee0
jmp 0x6dc5
leaq -0x30(%rbp), %rdi
callq 0x3190
jmp 0x6de7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3190
jmp 0x6def
jmp 0x6de9
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6940
testb $0x1, %al
jne 0x6e49
movq 0x191a8(%rip), %rdi     # 0x1ffc8
leaq 0xf4da(%rip), %rsi      # 0x16301
callq 0x3280
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xf628(%rip), %rsi      # 0x1646a
callq 0x3280
jmp 0x6e9b
movq -0x8(%rbp), %rdi
callq 0x6b80
testb $0x1, %al
jne 0x6e58
jmp 0x6e72
movq -0x8(%rbp), %rsi
leaq 0x1940d(%rip), %rdi     # 0x20270
callq 0x7770
movq (%rax), %rdi
callq 0xa5c0
jmp 0x6e9b
movq -0x8(%rbp), %rdi
callq 0x6c50
testb $0x1, %al
jne 0x6e81
jmp 0x6e99
movq -0x8(%rbp), %rsi
leaq 0x19414(%rip), %rdi     # 0x202a0
callq 0x7850
movq (%rax), %rdi
callq 0xb100
jmp 0x6e9b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/commands.cpp
// Function: queryRecord(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 queryRecord(const string& relationName, const string& key) {
    if (!isRelationExist(relationName)) {
        cout << "Error: Relation " << relationName << " doesn't exist.\n";
        return;
    }

    if (isRelationInRelationInt(relationName)) {
        if (!is_number(key)) {
            cout << "Error: Key " << key << " is not a number.\n";
            return;
        }
        relationNameToRelationInt[relationName]->queryRid(stoi(key));
    }
    else if (isRelationInRelationStr(relationName)) {
        relationNameToRelationStr[relationName]->queryRid(key.substr(1, 10));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6940
testb $0x1, %al
jne 0x6f00
movq 0x190f4(%rip), %rdi     # 0x1ffc8
leaq 0xf426(%rip), %rsi      # 0x16301
callq 0x3280
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xf574(%rip), %rsi      # 0x1646a
callq 0x3280
jmp 0x6ff9
movq -0x8(%rbp), %rdi
callq 0x6b80
testb $0x1, %al
jne 0x6f0f
jmp 0x6f85
movq -0x10(%rbp), %rdi
callq 0x6bd0
testb $0x1, %al
jne 0x6f4f
movq 0x190a5(%rip), %rdi     # 0x1ffc8
leaq 0xf465(%rip), %rsi      # 0x1638f
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xf456(%rip), %rsi      # 0x1639b
callq 0x3280
jmp 0x6ff9
movq -0x8(%rbp), %rsi
leaq 0x19316(%rip), %rdi     # 0x20270
callq 0x7770
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x5570
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0xa690
jmp 0x6ff9
movq -0x8(%rbp), %rdi
callq 0x6c50
testb $0x1, %al
jne 0x6f94
jmp 0x6ff7
movq -0x8(%rbp), %rsi
leaq 0x19301(%rip), %rdi     # 0x202a0
callq 0x7850
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x1, %edx
movl $0xa, %ecx
callq 0x32b0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xb1d0
jmp 0x6fd5
leaq -0x30(%rbp), %rdi
callq 0x3190
jmp 0x6ff7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3190
jmp 0x6fff
jmp 0x6ff9
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6940
testb $0x1, %al
jne 0x7270
movq 0x18d84(%rip), %rdi     # 0x1ffc8
leaq 0xf0b6(%rip), %rsi      # 0x16301
callq 0x3280
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xf204(%rip), %rsi      # 0x1646a
callq 0x3280
jmp 0x731d
movq -0x10(%rbp), %rdi
callq 0x6bd0
testb $0x1, %al
jne 0x7295
movq 0x18d44(%rip), %rdi     # 0x1ffc8
leaq 0xf13d(%rip), %rsi      # 0x163c8
callq 0x3280
jmp 0x731d
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x5570
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x72c5
movq 0x18d11(%rip), %rdi     # 0x1ffc8
leaq 0xf10a(%rip), %rsi      # 0x163c8
callq 0x3280
jmp 0x731d
movq -0x8(%rbp), %rdi
callq 0x6b80
testb $0x1, %al
jne 0x72d4
jmp 0x72f1
movq -0x8(%rbp), %rsi
leaq 0x18f91(%rip), %rdi     # 0x20270
callq 0x7770
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xaab0
jmp 0x731d
movq -0x8(%rbp), %rdi
callq 0x6c50
testb $0x1, %al
jne 0x7300
jmp 0x731b
movq -0x8(%rbp), %rsi
leaq 0x18f95(%rip), %rdi     # 0x202a0
callq 0x7850
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xb620
jmp 0x731d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6940
testb $0x1, %al
jne 0x7379
movq 0x18c78(%rip), %rdi     # 0x1ffc8
leaq 0xefaa(%rip), %rsi      # 0x16301
callq 0x3280
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xf0f8(%rip), %rsi      # 0x1646a
callq 0x3280
jmp 0x73cb
movq -0x8(%rbp), %rdi
callq 0x6b80
testb $0x1, %al
jne 0x7388
jmp 0x73a2
movq -0x8(%rbp), %rsi
leaq 0x18edd(%rip), %rdi     # 0x20270
callq 0x7770
movq (%rax), %rdi
callq 0xaae0
jmp 0x73cb
movq -0x8(%rbp), %rdi
callq 0x6c50
testb $0x1, %al
jne 0x73b1
jmp 0x73c9
movq -0x8(%rbp), %rsi
leaq 0x18ee4(%rip), %rdi     # 0x202a0
callq 0x7850
movq (%rax), %rdi
callq 0xb650
jmp 0x73cb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x200, (%rdi)          # imm = 0x200
movl $0x4, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x3360
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x60(%rbp)
callq 0x3360
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
movl $0x3e, %esi
callq 0xfeb0
jmp 0xa251
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x70(%rbp)
movl -0x1c(%rbp), %esi
callq 0xbc70
jmp 0xa267
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x3050
jmp 0xa27a
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rdi
callq 0x3050
jmp 0xa28d
movq -0x58(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, 0x48(%rdi)
addq $0x28, %rdi
leaq 0xc096(%rip), %rsi      # 0x16338
callq 0x54f0
movb %al, -0x71(%rbp)
jmp 0xa2ac
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xa2f9
jmp 0xa2b5
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
leaq 0xc07b(%rip), %rsi      # 0x1633f
callq 0x54f0
movb %al, -0x72(%rbp)
jmp 0xa2ce
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0xa2f9
jmp 0xa2d7
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
leaq 0xc060(%rip), %rsi      # 0x16346
callq 0x54f0
movb %al, -0x73(%rbp)
jmp 0xa2f0
movb -0x73(%rbp), %al
testb $0x1, %al
jne 0xa2f9
jmp 0xa327
movl $0xa, -0x30(%rbp)
jmp 0xa32e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xa374
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xa390
jmp 0xa374
movl $0x4, -0x30(%rbp)
movq -0x58(%rbp), %rax
movl (%rax), %eax
addl $-0xc, %eax
movl -0x30(%rbp), %ecx
addl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0xfeb0
jmp 0xa351
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl -0x40(%rbp), %ecx
movl %ecx, 0x60(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3190
movq -0x68(%rbp), %rdi
callq 0x3190
movq -0x28(%rbp), %rdi
callq 0x3410
nop
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x15241(%rip), %rdi     # 0x1ffc8
leaq 0xb66d(%rip), %rsi      # 0x163fb
callq 0x3280
movq -0x90(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xb661(%rip), %rsi      # 0x16411
callq 0x3280
movq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
leaq 0xb64e(%rip), %rsi      # 0x1641c
callq 0x3280
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
leaq 0xb50e(%rip), %rsi      # 0x162fa
callq 0x3280
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3120
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0xbd00
movl %eax, -0x74(%rbp)
jmp 0xae2c
leaq -0x40(%rbp), %rdi
callq 0x3190
movl -0x74(%rbp), %ecx
movq -0x90(%rbp), %rax
movq -0xa0(%rbp), %rsi
movl %ecx, -0x1c(%rbp)
addq $0x50, %rax
movq %rax, -0xb0(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3120
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x11a40
jmp 0xae7c
leaq -0x70(%rbp), %rdi
callq 0x3190
movq 0x1513c(%rip), %rdi     # 0x1ffc8
leaq 0xb596(%rip), %rsi      # 0x16429
callq 0x3280
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
jmp 0xaecd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3190
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x150bc(%rip), %rdi     # 0x1ffc8
leaq 0xb52c(%rip), %rsi      # 0x1643f
callq 0x3280
movq -0xa0(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xb525(%rip), %rsi      # 0x1645a
callq 0x3280
movq -0xa8(%rbp), %rsi
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
leaq 0xb3a7(%rip), %rsi      # 0x162fa
callq 0x3280
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3120
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x11830
movb %al, -0x81(%rbp)
jmp 0xaf9c
movb -0x81(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa9(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3190
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0xafbf
jmp 0xaff1
movq 0x15002(%rip), %rdi     # 0x1ffc8
leaq 0xb496(%rip), %rsi      # 0x16463
callq 0x3280
jmp 0xb0e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3190
jmp 0xb0ed
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rax
addq $0x50, %rax
movq %rax, -0xc0(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3120
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x11f70
movl %eax, -0xb0(%rbp)
jmp 0xb035
leaq -0x60(%rbp), %rdi
callq 0x3190
movl -0xb0(%rbp), %eax
movq -0xa0(%rbp), %rdi
movl %eax, -0x40(%rbp)
addq $0x68, %rdi
movl -0x40(%rbp), %esi
callq 0xbf40
movq -0xa0(%rbp), %rax
movq -0xa8(%rbp), %rsi
addq $0x50, %rax
movq %rax, -0xd0(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3120
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x11d00
jmp 0xb098
leaq -0x80(%rbp), %rdi
callq 0x3190
movq 0x14f20(%rip), %rdi     # 0x1ffc8
leaq 0xb3cc(%rip), %rsi      # 0x1647b
callq 0x3280
jmp 0xb0e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3190
jmp 0xb0ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3190
jmp 0xb0ed
addq $0xd0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x159ed(%rip), %rdi     # 0x1ffc8
leaq 0xbeae(%rip), %rsi      # 0x16490
callq 0x3280
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xbcf9(%rip), %rsi      # 0x162fa
callq 0x3280
movq 0x159bb(%rip), %rdi     # 0x1ffc8
leaq 0xbe9a(%rip), %rsi      # 0x164ae
callq 0x3280
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x50, %rdi
callq 0x10d90
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x3400
movq %rax, %rdi
movq 0x15979(%rip), %rsi     # 0x1ffb8
callq 0x32d0
movq 0x1597d(%rip), %rdi     # 0x1ffc8
leaq 0xbe72(%rip), %rsi      # 0x164c4
callq 0x3280
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x50, %rdi
callq 0x10d70
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x3400
movq %rax, %rdi
movq 0x1593b(%rip), %rsi     # 0x1ffb8
callq 0x32d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x14dcf(%rip), %rdi     # 0x1ffc8
leaq 0xb2e1(%rip), %rsi      # 0x164e1
callq 0x3280
movq -0x80(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xb1f2(%rip), %rsi      # 0x16411
callq 0x3280
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
leaq 0xb30b(%rip), %rsi      # 0x16548
callq 0x3280
movq %rax, %rdi
movq 0x14d6c(%rip), %rsi     # 0x1ffb8
callq 0x32d0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3120
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x11830
movb %al, -0x61(%rbp)
jmp 0xb283
movb -0x61(%rbp), %al
xorb $-0x1, %al
movb %al, -0x89(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3190
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0xb2a3
jmp 0xb2d5
movq 0x14d1e(%rip), %rdi     # 0x1ffc8
leaq 0xb1b2(%rip), %rsi      # 0x16463
callq 0x3280
jmp 0xb385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3190
jmp 0xb38e
movq 0x14cec(%rip), %rdi     # 0x1ffc8
leaq 0xb20e(%rip), %rsi      # 0x164f1
callq 0x3280
movq -0x88(%rbp), %rsi
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0xa8(%rbp)
addq $0x50, %rax
movq %rax, -0xa0(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3120
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x11f70
movl %eax, -0x90(%rbp)
jmp 0xb333
movl -0x90(%rbp), %esi
movq -0xa8(%rbp), %rdi
callq 0x3400
movq %rax, -0xb0(%rbp)
jmp 0xb34e
movq -0xb0(%rbp), %rdi
movq 0x14c5c(%rip), %rsi     # 0x1ffb8
callq 0x32d0
jmp 0xb363
leaq -0x60(%rbp), %rdi
callq 0x3190
jmp 0xb385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3190
jmp 0xb38e
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::insertRecord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int SlottedPageStructure::insertRecord(string record) {
    // return rid after the record is inserted
    int rid;

    // if the current page is not full
    // or there is no free space in the middle (no record deleted),
    // directly insert record in it
    if (!isCurrentPageFull() || !hasFreeSpaceInMiddle()) {
        rid = insertRecordAtEnd(record);
    }
    // if the current page is full
    // and there is any free space in the middle
    // insert record to the free space
    else {
        rid = insertRecordAtMiddle(record);
    }
    return rid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xbd60
testb $0x1, %al
jne 0xbd27
jmp 0xbd34
movq -0x20(%rbp), %rdi
callq 0xbdb0
testb $0x1, %al
jne 0xbd46
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xbde0
movl %eax, -0x14(%rbp)
jmp 0xbd56
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xbe40
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop