LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Agusyc[P]CTRPG/src/battle.cpp
// Function: Battle::writeItems()
void Battle::writeItems() {
    Json::Value newArray;
    Json::Value jPlayer = getJsonPlayer();

    for(vector<Item>::iterator it = player.items.begin(); it != player.items.end(); ++it) {
        Item item = *it;
        newArray.append(item.id);
    }

    jPlayer["items"] = newArray;

    Json::StyledWriter writer;
    ofstream jPlayerFile("./json/player.json");
    jPlayerFile << writer.write(jPlayer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp            # imm = 0x380
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x378(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x3120
leaq -0x58(%rbp), %rdi
callq 0xca00
jmp 0x6f70
movq -0x378(%rbp), %rdi
addq $0x60, %rdi
callq 0x87f0
movq %rax, -0x70(%rbp)
movq -0x378(%rbp), %rdi
addq $0x60, %rdi
callq 0x8a50
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8a10
testb $0x1, %al
jne 0x6fae
jmp 0x706a
leaq -0x70(%rbp), %rdi
callq 0x8a80
movq %rax, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x8730
jmp 0x6fc8
movl -0x7c(%rbp), %esi
leaq -0xe0(%rbp), %rdi
callq 0x3190
jmp 0x6fd9
leaq -0x30(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x33d0
jmp 0x6feb
leaq -0xe0(%rbp), %rdi
callq 0x3150
leaq -0xb8(%rbp), %rdi
callq 0x85f0
leaq -0x70(%rbp), %rdi
callq 0x8aa0
jmp 0x6f84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x717f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7176
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7059
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x3150
leaq -0xb8(%rbp), %rdi
callq 0x85f0
jmp 0x7176
leaq 0xa381(%rip), %rsi      # 0x113f2
leaq -0x58(%rbp), %rdi
callq 0x3100
movq %rax, -0x380(%rbp)
jmp 0x7083
movq -0x380(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33f0
jmp 0x7095
leaq -0x150(%rbp), %rdi
callq 0x3080
jmp 0x70a3
leaq 0xa335(%rip), %rsi      # 0x113df
leaq -0x350(%rbp), %rdi
movl $0x10, %edx
callq 0x32e0
jmp 0x70bd
leaq -0x370(%rbp), %rdi
leaq -0x150(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x3390
jmp 0x70d6
leaq -0x350(%rbp), %rdi
leaq -0x370(%rbp), %rsi
callq 0x3230
jmp 0x70eb
leaq -0x370(%rbp), %rdi
callq 0x31b0
leaq -0x350(%rbp), %rdi
callq 0x3430
leaq -0x150(%rbp), %rdi
callq 0x89b0
leaq -0x58(%rbp), %rdi
callq 0x3150
leaq -0x30(%rbp), %rdi
callq 0x3150
addq $0x380, %rsp            # imm = 0x380
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x716a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x715e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x370(%rbp), %rdi
callq 0x31b0
leaq -0x350(%rbp), %rdi
callq 0x3430
leaq -0x150(%rbp), %rdi
callq 0x89b0
leaq -0x58(%rbp), %rdi
callq 0x3150
leaq -0x30(%rbp), %rdi
callq 0x3150
movq -0x60(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: Agusyc[P]CTRPG/src/jsonparser.cpp
// Function: getJsonPlayer()
Json::Value getJsonPlayer() {
    Json::Value jPlayer;

    Json::Reader reader; // The reader... that reads

    ifstream ifs("./json/player.json");

    bool parsingSuccessful = reader.parse(ifs, jPlayer);
    if (!parsingSuccessful) {
        // Print error
        cout << "Failed to parse the player" << endl << reader.getFormattedErrorMessages();
        exit(1);
    }

    return jPlayer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp            # imm = 0x390
movq %rdi, -0x370(%rbp)
movq %rdi, %rax
movq %rax, -0x368(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
xorl %esi, %esi
callq 0x3120
leaq -0x120(%rbp), %rdi
callq 0x32c0
jmp 0xca39
leaq 0x499f(%rip), %rsi      # 0x113df
leaq -0x338(%rbp), %rdi
movl $0x8, %edx
callq 0x3550
jmp 0xca53
movq -0x370(%rbp), %rdx
leaq -0x120(%rbp), %rdi
leaq -0x338(%rbp), %rsi
movl $0x1, %ecx
callq 0x3570
movb %al, -0x371(%rbp)
jmp 0xca7a
movb -0x371(%rbp), %al
andb $0x1, %al
movb %al, -0x339(%rbp)
testb $0x1, -0x339(%rbp)
jne 0xcb6c
movq 0xb534(%rip), %rdi      # 0x17fd0
leaq 0x49b9(%rip), %rsi      # 0x1145c
callq 0x3290
movq %rax, -0x380(%rbp)
jmp 0xcab1
movq -0x380(%rbp), %rdi
movq 0xb501(%rip), %rsi      # 0x17fc0
callq 0x32b0
movq %rax, -0x388(%rbp)
jmp 0xcacd
leaq -0x360(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3480
jmp 0xcae2
movq -0x388(%rbp), %rdi
leaq -0x360(%rbp), %rsi
callq 0x3230
jmp 0xcaf7
leaq -0x360(%rbp), %rdi
callq 0x31b0
movl $0x1, %edi
callq 0x3350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0xcbc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0xcb9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0xcb90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
leaq -0x360(%rbp), %rdi
callq 0x31b0
jmp 0xcb90
movb $0x1, -0x9(%rbp)
leaq -0x338(%rbp), %rdi
callq 0x30b0
leaq -0x120(%rbp), %rdi
callq 0xf0a0
testb $0x1, -0x9(%rbp)
jne 0xcbb6
jmp 0xcbaa
leaq -0x338(%rbp), %rdi
callq 0x30b0
leaq -0x120(%rbp), %rdi
callq 0xf0a0
jmp 0xcbc6
movq -0x370(%rbp), %rdi
callq 0x3150
movq -0x368(%rbp), %rax
addq $0x390, %rsp            # imm = 0x390
popq %rbp
retq
movq -0x370(%rbp), %rdi
callq 0x3150
movq -0x128(%rbp), %rdi
callq 0x3530
nop
// File: Agusyc[P]CTRPG/src/jsonparser.cpp
// Function: getAttacksNumber()
int getAttacksNumber() {
    Json::Value attacks;

    Json::Reader reader; //The reader... that reads

    ifstream ifs("./json/attacks.json");

    bool parsingSuccessful = reader.parse(ifs, attacks);
    if (!parsingSuccessful) {
        // Print error
        cout << "Failed to parse the enmies." << endl << "Error:" << endl << reader.getFormattedErrorMessages();
        exit(1);
    }

    return attacks.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp            # imm = 0x3B0
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x3120
leaq -0x138(%rbp), %rdi
callq 0x32c0
jmp 0xcc04
leaq 0x486c(%rip), %rsi      # 0x11477
leaq -0x350(%rbp), %rdi
movl $0x8, %edx
callq 0x3550
jmp 0xcc1e
leaq -0x138(%rbp), %rdi
leaq -0x350(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0x3570
movb %al, -0x379(%rbp)
jmp 0xcc42
movb -0x379(%rbp), %al
andb $0x1, %al
movb %al, -0x351(%rbp)
testb $0x1, -0x351(%rbp)
jne 0xcd6f
movq 0xb36c(%rip), %rdi      # 0x17fd0
leaq 0x4820(%rip), %rsi      # 0x1148b
callq 0x3290
movq %rax, -0x388(%rbp)
jmp 0xcc79
movq -0x388(%rbp), %rdi
movq 0xb339(%rip), %rsi      # 0x17fc0
callq 0x32b0
movq %rax, -0x390(%rbp)
jmp 0xcc95
movq -0x390(%rbp), %rdi
leaq 0x4804(%rip), %rsi      # 0x114a7
callq 0x3290
movq %rax, -0x398(%rbp)
jmp 0xccb1
movq -0x398(%rbp), %rdi
movq 0xb301(%rip), %rsi      # 0x17fc0
callq 0x32b0
movq %rax, -0x3a0(%rbp)
jmp 0xcccd
leaq -0x378(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x3480
jmp 0xcce2
movq -0x3a0(%rbp), %rdi
leaq -0x378(%rbp), %rsi
callq 0x3230
jmp 0xccf7
leaq -0x378(%rbp), %rdi
callq 0x31b0
movl $0x1, %edi
callq 0x3350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xcdc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xcdbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xcdb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x378(%rbp), %rdi
callq 0x31b0
jmp 0xcdb0
leaq -0x28(%rbp), %rdi
callq 0x34e0
movl %eax, -0x3a4(%rbp)
jmp 0xcd80
leaq -0x350(%rbp), %rdi
callq 0x30b0
leaq -0x138(%rbp), %rdi
callq 0xf0a0
leaq -0x28(%rbp), %rdi
callq 0x3150
movl -0x3a4(%rbp), %eax
addq $0x3b0, %rsp            # imm = 0x3B0
popq %rbp
retq
leaq -0x350(%rbp), %rdi
callq 0x30b0
leaq -0x138(%rbp), %rdi
callq 0xf0a0
leaq -0x28(%rbp), %rdi
callq 0x3150
movq -0x140(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: Agusyc[P]CTRPG/src/jsonparser.cpp
// Function: getItemsNumber()
int getItemsNumber() {
    Json::Value items;

    Json::Reader reader; // The reader... that reads

    ifstream ifs("./json/enemies.json");

    bool parsingSuccessful = reader.parse(ifs, items);
    if (!parsingSuccessful) {
        // Print error
        cout << "Failed to parse the enemies." << endl << "Error:" << endl << reader.getFormattedErrorMessages();
        exit(1);
    }

    return items.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp            # imm = 0x3B0
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x3120
leaq -0x138(%rbp), %rdi
callq 0x32c0
jmp 0xce04
leaq 0x46a3(%rip), %rsi      # 0x114ae
leaq -0x350(%rbp), %rdi
movl $0x8, %edx
callq 0x3550
jmp 0xce1e
leaq -0x138(%rbp), %rdi
leaq -0x350(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0x3570
movb %al, -0x379(%rbp)
jmp 0xce42
movb -0x379(%rbp), %al
andb $0x1, %al
movb %al, -0x351(%rbp)
testb $0x1, -0x351(%rbp)
jne 0xcf6f
movq 0xb16c(%rip), %rdi      # 0x17fd0
leaq 0x4657(%rip), %rsi      # 0x114c2
callq 0x3290
movq %rax, -0x388(%rbp)
jmp 0xce79
movq -0x388(%rbp), %rdi
movq 0xb139(%rip), %rsi      # 0x17fc0
callq 0x32b0
movq %rax, -0x390(%rbp)
jmp 0xce95
movq -0x390(%rbp), %rdi
leaq 0x4604(%rip), %rsi      # 0x114a7
callq 0x3290
movq %rax, -0x398(%rbp)
jmp 0xceb1
movq -0x398(%rbp), %rdi
movq 0xb101(%rip), %rsi      # 0x17fc0
callq 0x32b0
movq %rax, -0x3a0(%rbp)
jmp 0xcecd
leaq -0x378(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x3480
jmp 0xcee2
movq -0x3a0(%rbp), %rdi
leaq -0x378(%rbp), %rsi
callq 0x3230
jmp 0xcef7
leaq -0x378(%rbp), %rdi
callq 0x31b0
movl $0x1, %edi
callq 0x3350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xcfc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xcfbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xcfb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x378(%rbp), %rdi
callq 0x31b0
jmp 0xcfb0
leaq -0x28(%rbp), %rdi
callq 0x34e0
movl %eax, -0x3a4(%rbp)
jmp 0xcf80
leaq -0x350(%rbp), %rdi
callq 0x30b0
leaq -0x138(%rbp), %rdi
callq 0xf0a0
leaq -0x28(%rbp), %rdi
callq 0x3150
movl -0x3a4(%rbp), %eax
addq $0x3b0, %rsp            # imm = 0x3B0
popq %rbp
retq
leaq -0x350(%rbp), %rdi
callq 0x30b0
leaq -0x138(%rbp), %rdi
callq 0xf0a0
leaq -0x28(%rbp), %rdi
callq 0x3150
movq -0x140(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: Agusyc[P]CTRPG/src/jsonparser.cpp
// Function: getEnemiesNumber()
int getEnemiesNumber() {
    Json::Value enemies;

    Json::Reader reader; // The reader... that reads

    ifstream ifs("./json/enemies.json");

    bool parsingSuccessful = reader.parse(ifs, enemies);
    if (!parsingSuccessful) {
        // Print error
        cout << "Failed to parse the enemies." << endl << "Error:" << endl << reader.getFormattedErrorMessages();
    }

    return enemies.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp            # imm = 0x3B0
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x3120
leaq -0x138(%rbp), %rdi
callq 0x32c0
jmp 0xd004
leaq 0x44a3(%rip), %rsi      # 0x114ae
leaq -0x350(%rbp), %rdi
movl $0x8, %edx
callq 0x3550
jmp 0xd01e
leaq -0x138(%rbp), %rdi
leaq -0x350(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0x3570
movb %al, -0x379(%rbp)
jmp 0xd042
movb -0x379(%rbp), %al
andb $0x1, %al
movb %al, -0x351(%rbp)
testb $0x1, -0x351(%rbp)
jne 0xd167
movq 0xaf6c(%rip), %rdi      # 0x17fd0
leaq 0x4457(%rip), %rsi      # 0x114c2
callq 0x3290
movq %rax, -0x388(%rbp)
jmp 0xd079
movq -0x388(%rbp), %rdi
movq 0xaf39(%rip), %rsi      # 0x17fc0
callq 0x32b0
movq %rax, -0x390(%rbp)
jmp 0xd095
movq -0x390(%rbp), %rdi
leaq 0x4404(%rip), %rsi      # 0x114a7
callq 0x3290
movq %rax, -0x398(%rbp)
jmp 0xd0b1
movq -0x398(%rbp), %rdi
movq 0xaf01(%rip), %rsi      # 0x17fc0
callq 0x32b0
movq %rax, -0x3a0(%rbp)
jmp 0xd0cd
leaq -0x378(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x3480
jmp 0xd0e2
movq -0x3a0(%rbp), %rdi
leaq -0x378(%rbp), %rsi
callq 0x3230
jmp 0xd0f7
leaq -0x378(%rbp), %rdi
callq 0x31b0
jmp 0xd167
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xd1c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xd1b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0xd1a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x378(%rbp), %rdi
callq 0x31b0
jmp 0xd1a8
leaq -0x28(%rbp), %rdi
callq 0x34e0
movl %eax, -0x3a4(%rbp)
jmp 0xd178
leaq -0x350(%rbp), %rdi
callq 0x30b0
leaq -0x138(%rbp), %rdi
callq 0xf0a0
leaq -0x28(%rbp), %rdi
callq 0x3150
movl -0x3a4(%rbp), %eax
addq $0x3b0, %rsp            # imm = 0x3B0
popq %rbp
retq
leaq -0x350(%rbp), %rdi
callq 0x30b0
leaq -0x138(%rbp), %rdi
callq 0xf0a0
leaq -0x28(%rbp), %rdi
callq 0x3150
movq -0x140(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: Agusyc[P]CTRPG/src/main.cpp
// Function: main
int main() {
    init();

    while (true) {
        bool goodEnemy = false;
        while (!goodEnemy) {
            enemy = parseEnemy(rand() % getEnemiesNumber());
            // Check if the player's level is right for the enemy. Otherwise, get another one (Run loop again).
            if (player.level >= enemy.minLevel && player.level <= enemy.maxLevel) {
                goodEnemy = true; // Exit the while loop
            }
        }

        Battle testBattle(enemy, player);

        player =testBattle.start("Are you ready?");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movl $0x0, -0x4(%rbp)
callq 0x105a0
movb $0x0, -0x5(%rbp)
movb -0x5(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x10616
jmp 0x10677
callq 0x30c0
movl %eax, -0x2d0(%rbp)
callq 0xcfe0
movl %eax, %ecx
movl -0x2d0(%rbp), %eax
cltd
idivl %ecx
movl %edx, %esi
leaq -0x68(%rbp), %rdi
callq 0xdb60
leaq 0x7d35(%rip), %rdi      # 0x18378
leaq -0x68(%rbp), %rsi
callq 0x10870
leaq -0x68(%rbp), %rdi
callq 0x8140
movl 0x7cdd(%rip), %eax      # 0x18338
cmpl 0x7d57(%rip), %eax      # 0x183b8
jl 0x10675
movl 0x7ccf(%rip), %eax      # 0x18338
cmpl 0x7d4d(%rip), %eax      # 0x183bc
jg 0x10675
movb $0x1, -0x5(%rbp)
jmp 0x1060b
leaq 0x7cfa(%rip), %rsi      # 0x18378
leaq -0x1a8(%rbp), %rdi
callq 0x108d0
leaq 0x7c6f(%rip), %rsi      # 0x18300
leaq -0x220(%rbp), %rdi
callq 0x83e0
jmp 0x1069f
leaq -0x148(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
leaq -0x220(%rbp), %rdx
callq 0x3820
jmp 0x106bb
leaq -0x220(%rbp), %rdi
callq 0x8170
leaq -0x1a8(%rbp), %rdi
callq 0x8140
leaq -0x2c9(%rbp), %rdi
movq %rdi, -0x2d8(%rbp)
callq 0x3540
movq -0x2d8(%rbp), %rdx
leaq 0xedc(%rip), %rsi       # 0x115d0
leaq -0x2c8(%rbp), %rdi
callq 0x33a0
jmp 0x10702
leaq -0x2a8(%rbp), %rdi
leaq -0x148(%rbp), %rsi
leaq -0x2c8(%rbp), %rdx
callq 0x38d0
jmp 0x1071e
leaq 0x7bdb(%rip), %rdi      # 0x18300
leaq -0x2a8(%rbp), %rsi
callq 0x10800
leaq -0x2a8(%rbp), %rdi
callq 0x8170
leaq -0x2c8(%rbp), %rdi
callq 0x31b0
leaq -0x2c9(%rbp), %rdi
callq 0x32d0
leaq -0x148(%rbp), %rdi
callq 0x10950
jmp 0x10607
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x10798
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x8170
leaq -0x1a8(%rbp), %rdi
callq 0x8140
jmp 0x107f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x107d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x2c8(%rbp), %rdi
callq 0x31b0
leaq -0x2c9(%rbp), %rdi
callq 0x32d0
leaq -0x148(%rbp), %rdi
callq 0x10950
movq -0x228(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: Agusyc[P]CTRPG/src/utils.cpp
// Function: printMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, bool)
void printMessage(string message, string color, int time, int extraTime, bool newLine) {
    cout << color;

    for (unsigned int i = 0; i < message.length(); i++) {
        cout << message.at(i);
        fflush(stdout);
        usleep(time * 1000);
    }

    cout << WHITE;

    if (newLine)
        cout << endl;

    if (extraTime != 0) {
        usleep(extraTime * 1000);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq 0x71a7(%rip), %rdi      # 0x17fd0
callq 0x3230
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x3440
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x10e94
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x3590
movq 0x716a(%rip), %rdi      # 0x17fd0
movsbl (%rax), %esi
callq 0x3320
movq 0x7133(%rip), %rax      # 0x17fa8
movq (%rax), %rdi
callq 0x3330
imull $0x3e8, -0x14(%rbp), %edi # imm = 0x3E8
callq 0x33e0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x10e35
movq 0x7135(%rip), %rdi      # 0x17fd0
leaq 0x19a(%rip), %rsi       # 0x1103c
callq 0x3290
testb $0x1, -0x19(%rbp)
je 0x10ec0
movq 0x711c(%rip), %rdi      # 0x17fd0
movq 0x7105(%rip), %rsi      # 0x17fc0
callq 0x32b0
cmpl $0x0, -0x18(%rbp)
je 0x10ed2
imull $0x3e8, -0x18(%rbp), %edi # imm = 0x3E8
callq 0x33e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: simonrharris[P]SKA/src/DNA.cpp
// Function: reverseComplementIsMin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool reverseComplementIsMin(const std::string & mystring){
	for (float i = 0; i < ((mystring.length())/2); ++i){
		int j = i+1;
		if (mystring[i]<complement_table[int(mystring[mystring.length()-j])]){
			return false;
		}
		else if (complement_table[int(mystring[mystring.length()-j])]<mystring[i]){
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67e0
movss -0x1c(%rbp), %xmm1
shrq %rax
cvtsi2ss %rax, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x7eab
movss -0x14(%rbp), %xmm0
movss 0x5127a(%rip), %xmm1    # 0x59004
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movss -0x14(%rbp), %xmm0
movss 0x51262(%rip), %xmm2    # 0x59008
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
cvttss2si %xmm1, %rax
cvttss2si %xmm0, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rsi
callq 0x65c0
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movslq -0x18(%rbp), %rax
subq %rax, %rsi
callq 0x65c0
movq %rax, %rcx
movl -0x20(%rbp), %eax
movsbl (%rcx), %ecx
movslq %ecx, %rdx
leaq 0x7170a(%rip), %rcx     # 0x79510
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x7e17
movb $0x0, -0x1(%rbp)
jmp 0x7eaf
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x67e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movslq -0x18(%rbp), %rax
subq %rax, %rsi
callq 0x65c0
movsbq (%rax), %rax
leaq 0x716ce(%rip), %rcx     # 0x79510
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movss -0x14(%rbp), %xmm0
movss 0x511ae(%rip), %xmm2    # 0x59008
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
cvttss2si %xmm1, %rax
cvttss2si %xmm0, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rsi
callq 0x65c0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x7e90
movb $0x1, -0x1(%rbp)
jmp 0x7eaf
jmp 0x7e92
jmp 0x7e94
movss 0x51168(%rip), %xmm0    # 0x59004
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x7d54
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: simonrharris[P]SKA/src/DNA.cpp
// Function: reverseComplementIfMin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool reverseComplementIfMin(std::string & mystring){
	if (reverseComplementIsMin(mystring)){
		std::reverse(mystring.begin(), mystring.end());
		std::transform(mystring.begin(),mystring.end(),mystring.begin(),complement);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7d40
testb $0x1, %al
jne 0x7edb
jmp 0x7f4b
movq -0x10(%rbp), %rdi
callq 0x64a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9010
movq -0x10(%rbp), %rdi
callq 0x64a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64a0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x21c(%rip), %rcx      # 0x7d20
callq 0x9050
movq %rax, -0x40(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x7f4f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: simonrharris[P]SKA/src/DNA.cpp
// Function: lowqualitytoN(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&, int const&, int)
int lowqualitytoN(std::string & mysequence,const std::string & myquality, const int & userminquality, int adjustment){
	int minquality=userminquality+adjustment;
	for (std::string::size_type i = 0; i<mysequence.length(); ++i){
		if (int(myquality[i])<minquality){
			mysequence[i]='N';
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x67e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x7fdd
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x65c0
movsbl (%rax), %eax
cmpl -0x20(%rbp), %eax
jge 0x7fcd
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x69e0
movb $0x4e, (%rax)
jmp 0x7fcf
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7f8b
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: simonrharris[P]SKA/src/DNA.cpp
// Function: IUPACToN(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int IUPACToN(std::string & mysequence){
	for (std::string::iterator it=mysequence.begin(); it!=mysequence.end(); ++it){
		if (base_score[int(*it)]>4){
			std::cerr << "Error: Unrecognised character " << *it << "in sequence" << std::endl << std::endl;
			return 1;
		}
		else if (base_score[int(*it)]>3){
			*it='N';
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x90d0
testb $0x1, %al
jne 0x802c
jmp 0x80ea
leaq -0x18(%rbp), %rdi
callq 0x9110
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0x7154e(%rip), %rax     # 0x79590
movsbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jle 0x80ad
movq 0x70f9e(%rip), %rdi     # 0x78ff0
leaq 0x50fc3(%rip), %rsi     # 0x5901c
callq 0x6520
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9110
movq -0x28(%rbp), %rdi
movsbl (%rax), %esi
callq 0x6620
movq %rax, %rdi
leaq 0x50fba(%rip), %rsi     # 0x5903b
callq 0x6520
movq %rax, %rdi
movq 0x70f00(%rip), %rsi     # 0x78f90
callq 0x6570
movq %rax, %rdi
movq 0x70ef1(%rip), %rsi     # 0x78f90
callq 0x6570
movl $0x1, -0x4(%rbp)
jmp 0x80f1
leaq -0x18(%rbp), %rdi
callq 0x9110
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0x714cd(%rip), %rax     # 0x79590
movsbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jle 0x80d8
leaq -0x18(%rbp), %rdi
callq 0x9110
movb $0x4e, (%rax)
jmp 0x80da
jmp 0x80dc
leaq -0x18(%rbp), %rdi
callq 0x9130
jmp 0x8009
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: simonrharris[P]SKA/src/DNA.cpp
// Function: ascii_codons(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int ascii_codons(std::string & myDNA){
	for (std::string::size_type i = 0; i<myDNA.length(); i+=3){
		if ((i+2)>=myDNA.length()){
			std::cerr << "Kmer length must be divisible by 3" << std::endl << std::endl;
			return 1;
		}
		myDNA[i/3] = (base_score[int(myDNA[i])]+(base_score[int(myDNA[i+1])]*4)+(base_score[int(myDNA[i+2])]*16))+63;
	}
	myDNA.erase(myDNA.length()/3);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x8247
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x8193
movq 0x70e93(%rip), %rdi     # 0x78ff0
leaq 0x50ee3(%rip), %rsi     # 0x59047
callq 0x6520
movq %rax, %rdi
movq 0x70e1d(%rip), %rsi     # 0x78f90
callq 0x6570
movq %rax, %rdi
movq 0x70e0e(%rip), %rsi     # 0x78f90
callq 0x6570
movl $0x1, -0x4(%rbp)
jmp 0x827c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x69e0
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0x713e3(%rip), %rax     # 0x79590
movsbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x69e0
movq %rax, %rcx
movl -0x34(%rbp), %eax
movsbl (%rcx), %ecx
movslq %ecx, %rdx
leaq 0x713b8(%rip), %rcx     # 0x79590
movsbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0x69e0
movq %rax, %rcx
movl -0x30(%rbp), %eax
movsbl (%rcx), %ecx
movslq %ecx, %rdx
leaq 0x71388(%rip), %rcx     # 0x79590
movsbl (%rcx,%rdx), %ecx
shll $0x4, %ecx
addl %ecx, %eax
addl $0x3f, %eax
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
callq 0x69e0
movb -0x29(%rbp), %cl
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x8114
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67e0
movq -0x40(%rbp), %rdi
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
movq $-0x1, %rdx
callq 0x6110
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: simonrharris[P]SKA/src/DNA.cpp
// Function: countSequencesinFasta(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
int countSequencesinFasta(const std::string & filename, int & sequenceCount){	
	igzstream gzfileStream;
	gzfileStream.open(filename.c_str());
	if (gzfileStream.get()!='>'){
		std::cerr << "Error: " << filename << " is not in the correct format. Expecting header to start with >." << std::endl << std::endl;
		return 1;
	}
	std::string sequence;
	while (getline(gzfileStream, sequence, '>')){
		sequenceCount++;
	}
	gzfileStream.close();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp            # imm = 0x330
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x2b8(%rbp), %rdi
movq %rdi, -0x2f0(%rbp)
callq 0x92d0
movq -0x10(%rbp), %rdi
callq 0x6210
movq -0x2f0(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x93d0
jmp 0x8d25
leaq -0x130(%rbp), %rdi
callq 0x6630
movl %eax, -0x2f4(%rbp)
jmp 0x8d39
movl -0x2f4(%rbp), %eax
cmpl $0x3e, %eax
je 0x8df7
movq 0x702a1(%rip), %rdi     # 0x78ff0
leaq 0x50314(%rip), %rsi     # 0x5906a
callq 0x6520
movq %rax, -0x300(%rbp)
jmp 0x8d64
movq -0x300(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64d0
movq %rax, -0x308(%rbp)
jmp 0x8d7d
movq -0x308(%rbp), %rdi
leaq 0x5046e(%rip), %rsi     # 0x591f9
callq 0x6520
movq %rax, -0x310(%rbp)
jmp 0x8d99
movq -0x310(%rbp), %rdi
movq 0x701e9(%rip), %rsi     # 0x78f90
callq 0x6570
movq %rax, -0x318(%rbp)
jmp 0x8db5
movq -0x318(%rbp), %rdi
movq 0x701cd(%rip), %rsi     # 0x78f90
callq 0x6570
jmp 0x8dca
movl $0x1, -0x4(%rbp)
movl $0x1, -0x2c8(%rbp)
jmp 0x8ea6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2c0(%rbp)
movl %eax, -0x2c4(%rbp)
jmp 0x8ebe
leaq -0x2e8(%rbp), %rdi
callq 0x6730
leaq -0x130(%rbp), %rdi
leaq -0x2e8(%rbp), %rsi
movl $0x3e, %edx
callq 0x6960
movq %rax, -0x320(%rbp)
jmp 0x8e24
movq -0x320(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6670
movb %al, -0x321(%rbp)
jmp 0x8e42
movb -0x321(%rbp), %al
testb $0x1, %al
jne 0x8e4e
jmp 0x8e7b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x8e03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2c0(%rbp)
movl %eax, -0x2c4(%rbp)
leaq -0x2e8(%rbp), %rdi
callq 0x6a08
jmp 0x8ebe
leaq -0x2b8(%rbp), %rdi
callq 0x9400
jmp 0x8e89
movl $0x0, -0x4(%rbp)
movl $0x1, -0x2c8(%rbp)
leaq -0x2e8(%rbp), %rdi
callq 0x6a08
leaq -0x2b8(%rbp), %rdi
callq 0x9480
movl -0x4(%rbp), %eax
addq $0x330, %rsp            # imm = 0x330
popq %rbp
retq
leaq -0x2b8(%rbp), %rdi
callq 0x9480
movq -0x2c0(%rbp), %rdi
callq 0x6900
nopw %cs:(%rax,%rax)
// File: simonrharris[P]SKA/src/DNA.cpp
// Function: circulariseSequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
int circulariseSequence(std::string & mySequence, const int myKmerLength){

	if (mySequence.length()<myKmerLength*2){
		return 1;
	}

	std::string myNewEnd=mySequence.substr(0,myKmerLength);
	std::string myNewStart=mySequence.substr(mySequence.length()-myKmerLength,myKmerLength);
	mySequence.reserve(mySequence.length()+(myKmerLength*2));
	mySequence.insert(mySequence.length(), myNewEnd);
	mySequence.insert(0, myNewStart);

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67e0
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x8f14
movl $0x1, -0x4(%rbp)
jmp 0x8fef
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0x6550
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x67e0
movq -0x70(%rbp), %rsi
movq %rax, %rdx
movslq -0x14(%rbp), %rcx
subq %rcx, %rdx
leaq -0x58(%rbp), %rdi
callq 0x6550
jmp 0x8f4f
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x67e0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %eax
addl %eax, %eax
cltq
addq %rax, %rsi
callq 0x6810
jmp 0x8f74
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x67e0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
leaq -0x38(%rbp), %rdx
callq 0x6830
jmp 0x8f93
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x58(%rbp), %rdx
callq 0x6830
jmp 0x8fa6
movl $0x0, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6a08
leaq -0x38(%rbp), %rdi
callq 0x6a08
jmp 0x8fef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x8fe4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6a08
leaq -0x38(%rbp), %rdi
callq 0x6a08
jmp 0x8ffb
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6900
nopw %cs:(%rax,%rax)
nop
// File: simonrharris[P]SKA/src/gzstream.h
// Function: gzstreambuf::sync()
virtual int sync() {
        // Changed to use flush_buffer() instead of overflow( EOF)
        // which caused improper behavior with std::endl and flush(),
        // bug reported by Vincent Ricard.
        if ( pptr() && pptr() > pbase()) {
            if ( flush_buffer() == EOF)
                return -1;
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x6180
cmpq $0x0, %rax
je 0x985a
movq -0x18(%rbp), %rdi
callq 0x6180
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x61a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x985a
movq -0x18(%rbp), %rdi
callq 0x9a70
cmpl $-0x1, %eax
jne 0x9858
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9861
jmp 0x985a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: simonrharris[P]SKA/src/gzstream.h
// Function: gzstreambuf::underflow()
virtual int underflow() { // used for input buffer only
        if ( gptr() && ( gptr() < egptr()))
            return * reinterpret_cast<unsigned char *>( gptr());
        
        if ( ! (mode & std::ios::in) || ! opened)
            return EOF;
        // Josuttis' implementation of inbuf
        int n_putback = gptr() - eback();
        if ( n_putback > 4)
            n_putback = 4;
        std::memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback);
        
        int num = gzread( file, buffer+4, bufferSize-4);
        if (num <= 0) // ERROR or EOF
            return EOF;
        
        // reset buffer pointers
        setg( buffer + (4 - n_putback),   // beginning of putback area
             buffer + 4,                 // read position
             buffer + 4 + num);          // end of buffer
        
        // return next character
        return * reinterpret_cast<unsigned char *>( gptr());    
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6190
cmpq $0x0, %rax
je 0x98c5
movq -0x20(%rbp), %rdi
callq 0x6190
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x6840
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x98c5
movq -0x20(%rbp), %rdi
callq 0x6190
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x99d3
movq -0x20(%rbp), %rax
movl 0x178(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x98e4
movq -0x20(%rbp), %rax
cmpb $0x0, 0x177(%rax)
jne 0x98f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x99d3
movq -0x20(%rbp), %rdi
callq 0x6190
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x6760
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jle 0x9920
movl $0x4, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x48, %rax
movl $0x4, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
callq 0x6190
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x6460
movq -0x20(%rbp), %rsi
movq 0x40(%rsi), %rdi
addq $0x48, %rsi
addq $0x4, %rsi
movl $0x12b, %edx            # imm = 0x12B
callq 0x6970
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x998a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x99d3
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x48, %rsi
movl $0x4, %eax
subl -0x14(%rbp), %eax
cltq
addq %rax, %rsi
movq %rdi, %rdx
addq $0x48, %rdx
addq $0x4, %rdx
movq %rdi, %rcx
addq $0x48, %rcx
addq $0x4, %rcx
movslq -0x18(%rbp), %rax
addq %rax, %rcx
callq 0x6790
movq -0x20(%rbp), %rdi
callq 0x6190
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: simonrharris[P]SKA/src/gzstream.h
// Function: gzstreambuf::overflow(int)
virtual int overflow( int c=EOF) { // used for output buffer only
        if ( ! ( mode & std::ios::out) || ! opened)
            return EOF;
        if (c != EOF) {
            *pptr() = c;
            pbump(1);
        }
        if ( flush_buffer() == EOF)
            return EOF;
        return c;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x178(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x9a12
movq -0x20(%rbp), %rax
cmpb $0x0, 0x177(%rax)
jne 0x9a1b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a60
cmpl $-0x1, -0x14(%rbp)
je 0x9a43
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movb %al, -0x21(%rbp)
callq 0x6180
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rdi
movb %cl, (%rax)
movl $0x1, %esi
callq 0x6770
movq -0x20(%rbp), %rdi
callq 0x9a70
cmpl $-0x1, %eax
jne 0x9a5a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a60
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: simonrharris[P]SKA/src/gzstream.h
// Function: gzstreambuf::flush_buffer()
int flush_buffer() {
        // Separate the writing of the buffer from overflow() and
        // sync() operation.
        int w = pptr() - pbase();
        if ( gzwrite( file, pbase(), w) != w)
            return EOF;
        pbump( -w);
        return w;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6180
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x61a0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movq 0x40(%rdi), %rax
movq %rax, -0x20(%rbp)
callq 0x61a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x67a0
cmpl -0x14(%rbp), %eax
je 0x9ad1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9ae5
movq -0x30(%rbp), %rdi
xorl %esi, %esi
subl -0x14(%rbp), %esi
callq 0x6770
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: simonrharris[P]SKA/src/gzstream.h
// Function: gzstreambuf::close()
gzstreambuf * close() {
        if ( is_open()) {
            sync();
            opened = 0;
            if ( gzclose( file) == Z_OK)
                return this;
        }
        return (gzstreambuf*)0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x9b60
cmpl $0x0, %eax
je 0x9b3d
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x177(%rax)
movq 0x40(%rax), %rdi
callq 0x6890
cmpl $0x0, %eax
jne 0x9b3b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b45
jmp 0x9b3d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: simonrharris[P]SKA/src/gzstream.h
// Function: gzstreambuf::open(char const*, int)
gzstreambuf* open( const char* name, int open_mode) {
        if ( is_open())
            return (gzstreambuf*)0;
        mode = open_mode;
        // no append nor read/write mode
        if ((mode & std::ios::ate) || (mode & std::ios::app)
            || ((mode & std::ios::in) && (mode & std::ios::out)))
            return (gzstreambuf*)0;
        char  fmode[10];
        char* fmodeptr = fmode;
        if ( mode & std::ios::in)
            *fmodeptr++ = 'r';
        else if ( mode & std::ios::out)
            *fmodeptr++ = 'w';
        *fmodeptr++ = 'b';
        *fmodeptr = '\0';
        file = gzopen( name, fmode);
        if (file == 0)
            return (gzstreambuf*)0;
        opened = 1;
        return this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x9b60
cmpl $0x0, %eax
je 0x9c22
movq $0x0, -0x8(%rbp)
jmp 0x9d25
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x178(%rax)
movl 0x178(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x9c73
movq -0x38(%rbp), %rax
movl 0x178(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x9c73
movq -0x38(%rbp), %rax
movl 0x178(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x9c80
movq -0x38(%rbp), %rax
movl 0x178(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x9c80
movq $0x0, -0x8(%rbp)
jmp 0x9d25
movq -0x38(%rbp), %rax
leaq -0x26(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl 0x178(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x9cae
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x72, (%rax)
jmp 0x9cd4
movq -0x38(%rbp), %rax
movl 0x178(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x9cd2
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x77, (%rax)
jmp 0x9cd4
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x62, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
leaq -0x26(%rbp), %rsi
callq 0x67c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, 0x40(%rax)
jne 0x9d16
movq $0x0, -0x8(%rbp)
jmp 0x9d25
movq -0x38(%rbp), %rax
movb $0x1, 0x177(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: simonrharris[P]SKA/src/general.cpp
// Function: splitFileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string splitFileName(const std::string & str){
	std::string filename=str;
	std::string path="";
	std::string::size_type found=filename.find_last_of("/\\");
	if (found!=std::string::npos){
		path=str.substr(0,found);
		filename=str.substr(found+1);
	}
	return filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x6230
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6910
movq -0xa0(%rbp), %rdx
leaq 0x4fef3(%rip), %rsi     # 0x5a2b2
leaq -0x38(%rbp), %rdi
callq 0xab20
jmp 0xa3ca
leaq -0x39(%rbp), %rdi
callq 0x65a0
movq -0xb0(%rbp), %rdi
leaq 0x4eea3(%rip), %rsi     # 0x59284
movq $-0x1, %rdx
callq 0x64f0
movq %rax, -0x58(%rbp)
cmpq $-0x1, -0x58(%rbp)
je 0xa4a2
movq -0x10(%rbp), %rsi
movq -0x58(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x78(%rbp), %rdi
callq 0x6550
jmp 0xa413
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x6640
movq -0xb8(%rbp), %rdi
callq 0x6a08
movq -0x10(%rbp), %rsi
movq -0x58(%rbp), %rdx
incq %rdx
leaq -0x98(%rbp), %rdi
movq $-0x1, %rcx
callq 0x6550
jmp 0xa453
movq -0xb0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x6640
leaq -0x98(%rbp), %rdi
callq 0x6a08
jmp 0xa4a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x65a0
jmp 0xa4d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6a08
jmp 0xa4d1
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6a08
testb $0x1, -0x11(%rbp)
jne 0xa4c1
movq -0xb0(%rbp), %rdi
callq 0x6a08
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x6a08
movq -0x48(%rbp), %rdi
callq 0x6900
nopw %cs:(%rax,%rax)
// File: simonrharris[P]SKA/src/general.cpp
// Function: openFileStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::basic_ifstream<char, std::char_traits<char>>&, bool)
int openFileStream(const std::string & fileName, std::ifstream & fileStream, bool verbose){

	fileStream.close();
	fileStream.clear();

	if (verbose){
		std::cout << "Reading " << fileName << std::endl;
	}

	fileStream.open(fileName, std::ios::in);
	if (fileStream.fail()) {
		std::cerr << "Failed to open " << fileName << std::endl << std::endl;
		return 1;
	}
	return 0;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x60f0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x68a0
testb $0x1, -0x19(%rbp)
je 0xa556
movq 0x6ea79(%rip), %rdi     # 0x78fa8
leaq 0x4ed51(%rip), %rsi     # 0x59287
callq 0x6520
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x64d0
movq %rax, %rdi
movq 0x6ea3f(%rip), %rsi     # 0x78f90
callq 0x6570
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x6490
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x6030
testb $0x1, %al
jne 0xa57e
jmp 0xa5c4
movq 0x6ea6b(%rip), %rdi     # 0x78ff0
leaq 0x4eeab(%rip), %rsi     # 0x59437
callq 0x6520
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x64d0
movq %rax, %rdi
movq 0x6e9e9(%rip), %rsi     # 0x78f90
callq 0x6570
movq %rax, %rdi
movq 0x6e9da(%rip), %rsi     # 0x78f90
callq 0x6570
movl $0x1, -0x4(%rbp)
jmp 0xa5cb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: simonrharris[P]SKA/src/general.cpp
// Function: openGzFileStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, igzstream&, bool)
int openGzFileStream(const std::string & fileName, igzstream & gzFileStream, bool verbose){

	gzFileStream.close();
	gzFileStream.clear();

	gzFileStream.open(fileName.c_str());
	if (gzFileStream.fail()) {
		std::cerr << "Failed to open " << fileName << std::endl << std::endl;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9400
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x68a0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6210
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x93d0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x6030
testb $0x1, %al
jne 0xa64a
jmp 0xa690
movq 0x6e99f(%rip), %rdi     # 0x78ff0
leaq 0x4eddf(%rip), %rsi     # 0x59437
callq 0x6520
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x64d0
movq %rax, %rdi
movq 0x6e91d(%rip), %rsi     # 0x78f90
callq 0x6570
movq %rax, %rdi
movq 0x6e90e(%rip), %rsi     # 0x78f90
callq 0x6570
movl $0x1, -0x4(%rbp)
jmp 0xa697
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: simonrharris[P]SKA/src/general.cpp
// Function: fileToVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
int fileToVector(const std::string & filename, std::vector < std::string > & fileargs){
	std::ifstream fileStream;
	fileStream.open(filename, std::ios::in);
	if (fileStream.fail()) {
		std::cerr << "Failed to open " << filename << std::endl << std::endl;
		return 1;
	}
	std::string word;
	while (fileStream >> word){
		if (word.length()>500){
			std::cerr << "Names > 500 characters are not allowed" << std::endl;
			return 1;
		}
		else if (word.length()>0){
			fileargs.push_back(word);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x65f0
movq -0x258(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x6490
jmp 0xa6dd
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x6030
movb %al, -0x259(%rbp)
jmp 0xa6fd
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0xa70c
jmp 0xa79f
movq 0x6e8dd(%rip), %rdi     # 0x78ff0
leaq 0x4ed1d(%rip), %rsi     # 0x59437
callq 0x6520
movq %rax, -0x268(%rbp)
jmp 0xa728
movq -0x268(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64d0
movq %rax, -0x270(%rbp)
jmp 0xa741
movq -0x270(%rbp), %rdi
movq 0x6e841(%rip), %rsi     # 0x78f90
callq 0x6570
movq %rax, -0x278(%rbp)
jmp 0xa75d
movq -0x278(%rbp), %rdi
movq 0x6e825(%rip), %rsi     # 0x78f90
callq 0x6570
jmp 0xa772
movl $0x1, -0x4(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0xa8b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0xa8ce
leaq -0x250(%rbp), %rdi
callq 0x6730
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x6690
movq %rax, -0x280(%rbp)
jmp 0xa7c7
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6670
movb %al, -0x281(%rbp)
jmp 0xa7e5
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0xa7f4
jmp 0xa899
leaq -0x250(%rbp), %rdi
callq 0x67e0
cmpq $0x1f4, %rax            # imm = 0x1F4
jbe 0xa86c
movq 0x6e7e1(%rip), %rdi     # 0x78ff0
leaq 0x4ea7a(%rip), %rsi     # 0x59290
callq 0x6520
movq %rax, -0x290(%rbp)
jmp 0xa824
movq -0x290(%rbp), %rdi
movq 0x6e75e(%rip), %rsi     # 0x78f90
callq 0x6570
jmp 0xa839
movl $0x1, -0x4(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0xa8aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x6a08
jmp 0xa8ce
leaq -0x250(%rbp), %rdi
callq 0x67e0
cmpq $0x0, %rax
jbe 0xa892
movq -0x18(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0xabd0
jmp 0xa890
jmp 0xa892
jmp 0xa894
jmp 0xa7ab
movl $0x0, -0x4(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x6a08
leaq -0x220(%rbp), %rdi
callq 0x6140
movl -0x4(%rbp), %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x6140
movq -0x228(%rbp), %rdi
callq 0x6900
nopw %cs:(%rax,%rax)