LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/AlexTheMagnus[P]Project_Hex/src/infraestructure/iconChanger.cc
// Function: NativeIconChanger::getIconFolderPath[abi:cxx11]()
string getIconFolderPath() {
        char cwd[PATH_MAX];
        if (getcwd(cwd, sizeof(cwd)) != NULL) {
            string executionPath(cwd);           //Paso de char* a string con el constructor de string
            return (executionPath + "/icons/");  //ruta donde se esta ejecutando el programa
        } else {
            printErrorGettingExecutionPathMessage();
            return "error";
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1050(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x20d0
testq %rax, %rax
je 0x40ea
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x1050(%rbp), %r14
movq %r14, %rdi
callq 0x20c0
leaq (%rax,%rbp), %rdx
addq $-0x1050, %rdx          # imm = 0xEFB0
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x41e8
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x414a
leaq 0x10ab(%rip), %rsi      # 0x5163
movq %rbx, %rdi
callq 0x22a0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x40d5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x22d0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1074(%rip), %rsi      # 0x5174
leaq 0x1072(%rip), %rdx      # 0x5179
movq %rbx, %rdi
callq 0x41e8
jmp 0x40d5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x412d
movq (%r13), %rsi
incq %rsi
callq 0x21a0
jmp 0x412d
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x4142
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/Agusyc[P]CTRPG/src/battle.cpp
// Function: Battle::showMenu()
int Battle::showMenu() {
    cout << "1. Attack" << endl << "2. Defend" << endl << "3. Item" << endl << "4. Flee" << endl << "HP: " << GREEN << player.hp << WHITE << " | Mana: " << GREEN << player.mana << WHITE << endl << "Your choice: ";

    int choice;
    cin >> choice;

    cout << endl;

    return choice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xaa74(%rip), %rbx      # 0xefd0
leaq 0x7b93(%rip), %rsi      # 0xc0f6
movl $0x9, %edx
movq %rbx, %rdi
callq 0x32f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rax, %r15
leaq 0x7b5f(%rip), %rsi      # 0xc100
movl $0x9, %edx
movq %rax, %rdi
callq 0x32f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rax, %r15
leaq 0x7b2b(%rip), %rsi      # 0xc10a
movl $0x7, %edx
movq %rax, %rdi
callq 0x32f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rax, %r15
leaq 0x7af5(%rip), %rsi      # 0xc112
movl $0x7, %edx
movq %rax, %rdi
callq 0x32f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rax, %r12
leaq 0x7abf(%rip), %rsi      # 0xc11a
movl $0x4, %edx
movq %rax, %rdi
callq 0x32f0
leaq 0x7ab0(%rip), %r15      # 0xc11f
movl $0x5, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x32f0
movl 0x34(%r14), %esi
movq %r12, %rdi
callq 0x34b0
movq %rax, %r13
leaq 0x79b7(%rip), %r12      # 0xc04c
movl $0x5, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32f0
leaq 0x7a79(%rip), %rsi      # 0xc125
movl $0x9, %edx
movq %r13, %rdi
callq 0x32f0
movl $0x5, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x32f0
movl 0x2c(%r14), %esi
movq %r13, %rdi
callq 0x34b0
movq %rax, %r14
movl $0x5, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x7a19(%rip), %rsi      # 0xc12f
movl $0xd, %edx
movq %rax, %rdi
callq 0x32f0
movq 0xa8b6(%rip), %rdi      # 0xefe0
leaq -0x2c(%rbp), %r14
movq %r14, %rsi
callq 0x3180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp            # imm = 0x2E8
movq %rdi, %rbx
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
callq 0x3100
leaq -0x70(%rbp), %rdi
callq 0x8dc0
movq 0x60(%rbx), %r14
cmpq 0x68(%rbx), %r14
je 0x6eb6
leaq -0x2f8(%rbp), %r13
leaq -0x108(%rbp), %r15
leaq -0x98(%rbp), %r12
movq %r13, -0x308(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x308(%rbp), %rdi
callq 0x886e
movups 0x20(%r14), %xmm0
movups 0x30(%r14), %xmm1
movups %xmm1, 0x20(%r13)
movups %xmm0, 0x10(%r13)
movl -0x2cc(%rbp), %esi
movq %r15, %rdi
callq 0x3170
movq %r12, %rdi
movq %r15, %rsi
callq 0x3370
movq %r15, %rdi
callq 0x3140
movq -0x308(%rbp), %rdi
cmpq %r13, %rdi
je 0x6eac
callq 0x3260
addq $0x40, %r14
cmpq 0x68(%rbx), %r14
jne 0x6e49
leaq 0x5545(%rip), %rsi      # 0xc402
leaq -0x70(%rbp), %rdi
callq 0x30e0
leaq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x3390
leaq -0x108(%rbp), %rdi
callq 0x3060
leaq 0x5507(%rip), %rsi      # 0xc3ef
leaq -0x308(%rbp), %rdi
movl $0x10, %edx
callq 0x32b0
leaq -0x48(%rbp), %rdi
leaq -0x108(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x3350
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x308(%rbp), %rdi
callq 0x32f0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6f33
callq 0x3260
movq 0x808e(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x300(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x308(%rbp,%rcx)
callq 0x3200
leaq -0x210(%rbp), %rdi
callq 0x30c0
leaq -0x108(%rbp), %rdi
callq 0x7e6a
leaq -0x70(%rbp), %rdi
callq 0x3140
leaq -0x98(%rbp), %rdi
callq 0x3140
addq $0x2e8, %rsp            # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6fb6
callq 0x3260
jmp 0x6fb6
movq %rax, %rbx
leaq -0x308(%rbp), %rdi
callq 0x33d0
jmp 0x6fc7
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x7e6a
jmp 0x7008
jmp 0x6fde
movq %rax, %rbx
jmp 0x7011
jmp 0x6fde
movq %rax, %rbx
jmp 0x7008
movq %rax, %rbx
jmp 0x6ff7
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x3140
movq -0x308(%rbp), %rdi
cmpq %r13, %rdi
je 0x7008
callq 0x3260
leaq -0x70(%rbp), %rdi
callq 0x3140
leaq -0x98(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x340, %rsp            # imm = 0x340
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3100
leaq -0x140(%rbp), %rdi
callq 0x32a0
leaq 0x3604(%rip), %rsi      # 0xc3ef
leaq -0x348(%rbp), %rdi
movl $0x8, %edx
callq 0x34f0
leaq -0x140(%rbp), %rdi
leaq -0x348(%rbp), %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x3510
testb %al, %al
je 0x8e75
leaq -0x348(%rbp), %rdi
callq 0x3080
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e39
callq 0x3260
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e4e
callq 0x3260
leaq -0xf0(%rbp), %rdi
callq 0xa800
leaq -0x140(%rbp), %rdi
callq 0xa9a0
movq %rbx, %rax
addq $0x340, %rsp            # imm = 0x340
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6154(%rip), %rdi      # 0xefd0
leaq 0x3613(%rip), %rsi      # 0xc496
movl $0x1a, %edx
callq 0x32f0
movq 0x613c(%rip), %rdi      # 0xefd0
callq 0x3130
movq %rax, %r14
leaq -0x30(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x3420
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x3230
leaq -0x30(%rbp), %rdi
callq 0x3120
movl $0x1, %edi
callq 0x3320
movq %rax, %r14
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ef1
callq 0x3260
jmp 0x8ef1
jmp 0x8eee
movq %rax, %r14
jmp 0x8efd
movq %rax, %r14
jmp 0x8f09
movq %rax, %r14
leaq -0x348(%rbp), %rdi
callq 0x3080
leaq -0x140(%rbp), %rdi
callq 0xa7b0
movq %rbx, %rdi
callq 0x3140
movq %r14, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x3100
leaq -0x160(%rbp), %rdi
callq 0x32a0
leaq 0x356e(%rip), %rsi      # 0xc4b1
leaq -0x368(%rbp), %rdi
movl $0x8, %edx
callq 0x34f0
leaq -0x160(%rbp), %rdi
leaq -0x368(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movl $0x1, %ecx
callq 0x3510
testb %al, %al
je 0x8fdf
leaq -0x50(%rbp), %rdi
callq 0x3480
movl %eax, %ebx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f9d
callq 0x3260
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8fb2
callq 0x3260
leaq -0x110(%rbp), %rdi
callq 0xa800
leaq -0x160(%rbp), %rdi
callq 0xa9a0
leaq -0x50(%rbp), %rdi
callq 0x3140
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %rbp
retq
movq 0x5fea(%rip), %rdi      # 0xefd0
leaq 0x34d8(%rip), %rsi      # 0xc4c5
movl $0x1b, %edx
callq 0x32f0
movq 0x5fd2(%rip), %rdi      # 0xefd0
callq 0x3130
movq %rax, %rbx
leaq 0x34d4(%rip), %rsi      # 0xc4e1
movl $0x6, %edx
movq %rax, %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x3130
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x3420
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x3230
leaq -0x28(%rbp), %rdi
callq 0x3120
movl $0x1, %edi
callq 0x3320
movq %rax, %rbx
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x907a
callq 0x3260
jmp 0x907a
jmp 0x9077
movq %rax, %rbx
jmp 0x9086
movq %rax, %rbx
jmp 0x9092
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x160(%rbp), %rdi
callq 0xa7b0
leaq -0x50(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x3100
leaq -0x160(%rbp), %rdi
callq 0x32a0
leaq 0x341b(%rip), %rsi      # 0xc4e8
leaq -0x368(%rbp), %rdi
movl $0x8, %edx
callq 0x34f0
leaq -0x160(%rbp), %rdi
leaq -0x368(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movl $0x1, %ecx
callq 0x3510
testb %al, %al
je 0x9169
leaq -0x50(%rbp), %rdi
callq 0x3480
movl %eax, %ebx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9127
callq 0x3260
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x913c
callq 0x3260
leaq -0x110(%rbp), %rdi
callq 0xa800
leaq -0x160(%rbp), %rdi
callq 0xa9a0
leaq -0x50(%rbp), %rdi
callq 0x3140
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %rbp
retq
movq 0x5e60(%rip), %rdi      # 0xefd0
leaq 0x3385(%rip), %rsi      # 0xc4fc
movl $0x1c, %edx
callq 0x32f0
movq 0x5e48(%rip), %rdi      # 0xefd0
callq 0x3130
movq %rax, %rbx
leaq 0x334a(%rip), %rsi      # 0xc4e1
movl $0x6, %edx
movq %rax, %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x3130
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x3420
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x3230
leaq -0x28(%rbp), %rdi
callq 0x3120
movl $0x1, %edi
callq 0x3320
movq %rax, %rbx
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9204
callq 0x3260
jmp 0x9204
jmp 0x9201
movq %rax, %rbx
jmp 0x9210
movq %rax, %rbx
jmp 0x921c
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x160(%rbp), %rdi
callq 0xa7b0
leaq -0x50(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x3100
leaq -0x160(%rbp), %rdi
callq 0x32a0
leaq 0x3291(%rip), %rsi      # 0xc4e8
leaq -0x368(%rbp), %rdi
movl $0x8, %edx
callq 0x34f0
leaq -0x160(%rbp), %rdi
leaq -0x368(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movl $0x1, %ecx
callq 0x3510
testb %al, %al
jne 0x9345
movq 0x5d3d(%rip), %rbx      # 0xefd0
leaq 0x3262(%rip), %rsi      # 0xc4fc
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x32f0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq 0x5d0b(%rip), %rdi      # 0xefd0
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rax, %rbx
leaq 0x3205(%rip), %rsi      # 0xc4e1
movl $0x6, %edx
movq %rax, %rdi
callq 0x32f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x3420
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq %rbx, %rdi
callq 0x32f0
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9345
callq 0x3260
leaq -0x50(%rbp), %rdi
callq 0x3480
movl %eax, %ebx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x936e
callq 0x3260
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9383
callq 0x3260
leaq -0x110(%rbp), %rdi
callq 0xa800
leaq -0x160(%rbp), %rdi
callq 0xa9a0
leaq -0x50(%rbp), %rdi
callq 0x3140
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93d6
callq 0x3260
jmp 0x93d6
jmp 0x93d3
movq %rax, %rbx
jmp 0x93e2
movq %rax, %rbx
jmp 0x93ee
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x160(%rbp), %rdi
callq 0xa7b0
leaq -0x50(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movl %edx, %r14d
movq %rdi, %r15
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0x3adc(%rip), %rdi      # 0xefd0
movq %rax, %rsi
callq 0x32f0
cmpq $0x0, 0x8(%r15)
je 0xb554
imull $0x3e8, %r14d, %r12d    # imm = 0x3E8
movl $0x1, %ebx
xorl %eax, %eax
leaq -0x29(%rbp), %r14
movq 0x3a84(%rip), %r13      # 0xefa0
movq (%r15), %rcx
movb (%rcx,%rax), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq 0x3a9f(%rip), %rdi      # 0xefd0
movq %r14, %rsi
callq 0x32f0
movq (%r13), %rdi
callq 0x3300
movl %r12d, %edi
callq 0x3380
movl %ebx, %eax
incl %ebx
cmpq %rax, 0x8(%r15)
ja 0xb51c
movq 0x3a75(%rip), %r14      # 0xefd0
leaq 0xaea(%rip), %rsi       # 0xc04c
movl $0x5, %edx
movq %r14, %rdi
callq 0x32f0
cmpb $0x0, -0x30(%rbp)
je 0xb59c
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movl -0x34(%rbp), %eax
testl %eax, %eax
je 0xb5ae
imull $0x3e8, %eax, %edi      # imm = 0x3E8
callq 0x3380
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
shrq %rdx
cvtsi2ss %rdx, %xmm0
xorps %xmm4, %xmm4
movss 0x2c78c(%rip), %xmm1    # 0x33004
movss 0x2c788(%rip), %xmm2    # 0x33008
leaq 0x3ab39(%rip), %rdx     # 0x413c0
ucomiss %xmm4, %xmm0
jbe 0x68d5
movaps %xmm4, %xmm3
addss %xmm1, %xmm3
cvttss2si %xmm3, %esi
cvttss2si %xmm4, %rdi
movq %rdi, %r8
sarq $0x3f, %r8
subss %xmm2, %xmm4
cvttss2si %xmm4, %r9
andq %r8, %r9
orq %rdi, %r9
movb (%rax,%r9), %dil
movslq %esi, %rsi
movq %rcx, %r8
subq %rsi, %r8
movsbq (%rax,%r8), %rsi
movb (%rsi,%rdx), %sil
cmpb %sil, %dil
jl 0x68d5
movaps %xmm3, %xmm4
jle 0x6887
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x685b
testb %al, %al
je 0x6952
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
setne %dil
leaq (%rcx,%rdx), %rsi
decq %rsi
cmpq %rcx, %rsi
seta %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0x692f
incq %rcx
movb -0x1(%rcx), %dl
movb (%rsi), %dil
movb %dil, -0x1(%rcx)
movb %dl, (%rsi)
decq %rsi
leaq 0x1(%rcx), %rdx
cmpq %rsi, %rcx
movq %rdx, %rcx
jb 0x690d
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x6952
xorl %esi, %esi
leaq 0x3aa83(%rip), %rdi     # 0x413c0
movsbq (%rcx,%rsi), %r8
movb (%r8,%rdi), %r8b
movb %r8b, (%rcx,%rsi)
incq %rsi
cmpq %rsi, %rdx
jne 0x693d
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/DNA.cpp
// Function: codons_from_ascii(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string codons_from_ascii(std::string & myascii){
	std::string myDNA ((myascii.length()*3), '-');
	for (std::string::size_type i = 0; i<myascii.length(); ++i){
		myDNA[(i*3)+2]=bases[int(myascii[i]-63)/16];
		int sixteensreamainder=int(myascii[i]-63)%16;
		myDNA[(i*3)+1]=bases[sixteensreamainder/4];
		myDNA[(i*3)]=bases[sixteensreamainder%4];
	}
	return myDNA;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
leaq (%rax,%rax,2), %rsi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl $0x2d, %edx
callq 0x5440
cmpq $0x0, 0x8(%r14)
je 0x6c50
xorl %eax, %eax
leaq 0x3a910(%rip), %rcx     # 0x414c5
xorl %edx, %edx
movq (%r14), %rsi
movsbl (%rsi,%rdx), %esi
leal -0x3f(%rsi), %edi
addl $-0x30, %esi
testw %di, %di
cmovnsl %edi, %esi
movswl %si, %esi
shrl $0x4, %esi
movswq %si, %rsi
movb (%rsi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, 0x2(%rdi,%rax)
movq (%r14), %rsi
movsbl (%rsi,%rdx), %esi
leal -0x3f(%rsi), %edi
leal -0x30(%rsi), %r8d
testw %di, %di
cmovnsl %edi, %r8d
andl $0xf0, %r8d
negl %r8d
addl %r8d, %esi
addl $-0x3f, %esi
movl %esi, %edi
sarb $0x7, %dil
shrb $0x6, %dil
addb %sil, %dil
movl %edi, %r8d
sarb $0x2, %r8b
movsbq %r8b, %r8
movb (%r8,%rcx), %r8b
movq (%rbx), %r9
movb %r8b, 0x1(%r9,%rax)
andb $-0x4, %dil
subb %dil, %sil
movsbq %sil, %rsi
movb (%rsi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, (%rdi,%rax)
incq %rdx
addq $0x3, %rax
cmpq 0x8(%r14), %rdx
jb 0x6bb7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x7710
movq (%r14), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x7d44
leaq 0x1b0(%rsp), %r15
movq %r15, %rdi
callq 0x5460
cmpl $0x3e, %eax
jne 0x74c2
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
movl $0x3e, %edx
callq 0x56c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x755c
incl (%rbx)
jmp 0x749c
movq 0x39b27(%rip), %rdi     # 0x40ff0
leaq 0x2bb8a(%rip), %rsi     # 0x3305a
movl $0x7, %edx
callq 0x5420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x39b08(%rip), %rdi     # 0x40ff0
callq 0x5420
movq %rax, %rbx
leaq 0x2bcf2(%rip), %rsi     # 0x331e9
movl $0x40, %edx
movq %rax, %rdi
callq 0x5420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x5250
jmp 0x757f
leaq 0x28(%rsp), %rdi
callq 0x77fa
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x757d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
xorl %ebx, %ebx
leaq 0x39672(%rip), %rax     # 0x40bf8
leaq 0x1c0(%rsp), %r14
movq %rax, -0x10(%r14)
leaq 0x39687(%rip), %rax     # 0x40c20
movq %rax, (%r14)
movq $0x0, -0x8(%r14)
leaq 0x3958d(%rip), %rsi     # 0x40b38
leaq 0x28(%rsp), %rdi
callq 0x7922
movq %r14, %rdi
callq 0x5120
movl %ebx, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x75d5
movq %rax, %rbx
jmp 0x75ef
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x75ef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x28(%rsp), %rdi
callq 0x7830
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leal (%rsi,%rsi), %eax
movslq %eax, %r14
movl $0x1, %eax
cmpq %r14, 0x8(%rdi)
jb 0x76c0
movq %rdi, %rbx
movslq %esi, %r15
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x53e0
movq 0x8(%rbx), %rdx
subq %r15, %rdx
movq %rsp, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x53e0
addq 0x8(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55f0
movq 0x8(%rbx), %rsi
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5400
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5400
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76a3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76be
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x76ed
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76ed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7708
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x7c16
cmpq 0x18(%rbx), %rsi
jae 0x7c16
movzbl (%rsi), %ebp
jmp 0x7c84
testb $0x8, 0x178(%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x7c84
cmpb $0x0, 0x177(%rbx)
je 0x7c84
movl 0x8(%rbx), %eax
movl %esi, %ecx
subl %eax, %ecx
movl $0x4, %eax
cmpl %eax, %ecx
cmovgel %eax, %ecx
subl %ecx, %eax
leaq (%rbx,%rax), %r14
addq $0x48, %r14
movslq %ecx, %rdx
subq %rdx, %rsi
movq %r14, %rdi
callq 0x5320
movq 0x40(%rbx), %rdi
leaq 0x4c(%rbx), %r15
movq %r15, %rsi
movl $0x12b, %edx            # imm = 0x12B
callq 0x56e0
testl %eax, %eax
jle 0x7c84
movl %eax, %eax
addq %r15, %rax
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movzbl 0x4c(%rbx), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
testb $0x10, 0x178(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
je 0x7cc9
cmpb $0x0, 0x177(%rdi)
je 0x7cc9
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0x7cbb
movq 0x28(%rdi), %rax
movb %bl, (%rax)
incq 0x28(%rdi)
callq 0x7cca
cmpl $-0x1, %eax
cmovel %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %r14
subq %rsi, %r14
movq 0x40(%rdi), %rdi
movl %r14d, %edx
callq 0x5570
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r14d, %ecx
jne 0x7d02
movl %r14d, %eax
negl %eax
cltq
addq %rax, 0x28(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
cmpb $0x0, 0x177(%rdi)
je 0x7d31
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
movb $0x0, 0x177(%rbx)
movq 0x40(%rbx), %rdi
callq 0x5660
testl %eax, %eax
je 0x7d33
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
cmpb $0x0, 0x177(%rdi)
jne 0x7de0
movq %rdi, %rbx
movl %edx, 0x178(%rdi)
testb $0x3, %dl
jne 0x7de0
movl %edx, %eax
notl %eax
testb $0x18, %al
je 0x7de0
testb $0x8, %dl
jne 0x7da5
testb $0x10, %dl
jne 0x7db0
leaq 0x6(%rsp), %rax
jmp 0x7db9
leaq 0x7(%rsp), %rax
movb $0x72, -0x1(%rax)
jmp 0x7db9
leaq 0x7(%rsp), %rax
movb $0x77, -0x1(%rax)
movw $0x62, (%rax)
leaq 0x6(%rsp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5590
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x7de0
movb $0x1, 0x177(%rbx)
jmp 0x7de2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x8566
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2c47c(%rip), %rdx     # 0x342a2
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x85fc
leaq 0x2b43e(%rip), %rsi     # 0x33278
movl $0x2, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x5740
cmpq $-0x1, %rax
je 0x7ed9
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x53e0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x5470
movq (%r12), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x7e9a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
incq %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x53e0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5470
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x7ed9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7ef0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7f04
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7f23
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53c0
jmp 0x7f23
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x7f37
movq (%r13), %rsi
incq %rsi
callq 0x53c0
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x50b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x5670
testl %r15d, %r15d
je 0x7fc3
movq 0x3904a(%rip), %r15     # 0x40fc0
leaq 0x2b2fe(%rip), %rsi     # 0x3327b
movl $0x8, %edx
movq %r15, %rdi
callq 0x5420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x5420
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x5350
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x8069
movq 0x39003(%rip), %r14     # 0x40ff0
leaq 0x2b443(%rip), %rsi     # 0x33437
movl $0xf, %edx
movq %r14, %rdi
callq 0x5420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5420
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x77fa
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x5670
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x7d44
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x8141
movq 0x38f2b(%rip), %r14     # 0x40ff0
leaq 0x2b36b(%rip), %rsi     # 0x33437
movl $0xf, %edx
movq %r14, %rdi
callq 0x5420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5420
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x5410
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5350
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x8216
movq 0x38e5c(%rip), %rdi     # 0x40ff0
leaq 0x2b29c(%rip), %rsi     # 0x33437
movl $0xf, %edx
callq 0x5420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x38e3d(%rip), %rdi     # 0x40ff0
callq 0x5420
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x5250
jmp 0x82d3
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5490
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x826e
movq 0x8(%rsp), %rax
cmpq $0x1f5, %rax            # imm = 0x1F5
jae 0x8272
testq %rax, %rax
je 0x8236
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8528
jmp 0x8236
xorl %ebx, %ebx
jmp 0x82bd
movq 0x38d77(%rip), %rbx     # 0x40ff0
leaq 0x2b004(%rip), %rsi     # 0x33284
movl $0x26, %edx
movq %rbx, %rdi
callq 0x5420
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq 0x38d45(%rip), %rdi     # 0x40ff0
callq 0x5030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x5250
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x82d3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x20(%rsp), %rdi
callq 0x50d0
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x82f5
movq %rax, %rbx
jmp 0x830e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x830e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x20(%rsp), %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/general.cpp
// Function: printDuration(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
void printDuration(const std::chrono::high_resolution_clock::time_point start){
	std::chrono::high_resolution_clock::time_point finish = std::chrono::high_resolution_clock::now();
	std::chrono::duration<double> elapsed = finish - start;
	std::cout << "Done" << std::endl;
	std::cout << "Total time required: " << elapsed.count() << "s" << std::endl;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x5060
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x2af1b(%rip), %xmm0    # 0x33258
movsd %xmm0, 0x8(%rsp)
movq 0x38c76(%rip), %rbx     # 0x40fc0
leaq 0x2af5a(%rip), %rsi     # 0x332ab
movl $0x4, %edx
movq %rbx, %rdi
callq 0x5420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
leaq 0x2af24(%rip), %rsi     # 0x332b0
movl $0x15, %edx
movq %rbx, %rdi
callq 0x5420
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x5610
movq %rax, %rbx
leaq 0x2cff7(%rip), %rsi     # 0x353a8
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x5250
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/general.cpp
// Function: calculateMissedSNPs(float, float, int)
int calculateMissedSNPs(float totalSiteCount, const float variantSiteCount, const int kmerSize){

	if (variantSiteCount==0){
		std::cout << "Expected number of missed alignments = 0" << std::endl;
		return 0;
	}
	if (totalSiteCount<variantSiteCount){
		std::cout << "Error in calculateMissedSNPs. More variants than sites." << std::endl;
		return 1;
	}

	double nonvariantSiteCount=totalSiteCount-variantSiteCount;
	totalSiteCount--;//as we are assuming the kmer includes one snp
	double snpprobability=nonvariantSiteCount/totalSiteCount;

	for (int i=0; i<kmerSize*2; ++i){
		totalSiteCount--;
		nonvariantSiteCount--;
		snpprobability*=nonvariantSiteCount/totalSiteCount;
	}

	std::cout << "Expected number of missed alignments = " << (1.0-snpprobability)*variantSiteCount << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x841a
jp 0x841a
movq 0x38bbf(%rip), %rbx     # 0x40fc0
leaq 0x2aebe(%rip), %rsi     # 0x332c6
movl $0x28, %edx
movq %rbx, %rdi
callq 0x5420
jmp 0x84f5
ucomiss %xmm0, %xmm1
jbe 0x8444
movq 0x38b9a(%rip), %rbx     # 0x40fc0
leaq 0x2aec2(%rip), %rsi     # 0x332ef
movl $0x37, %edx
movq %rbx, %rdi
callq 0x5420
movl $0x1, %ebp
jmp 0x84f7
movaps %xmm0, %xmm2
movss %xmm1, 0xc(%rsp)
subss %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
addss 0x2ae10(%rip), %xmm0    # 0x33270
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
movaps %xmm1, %xmm6
divsd %xmm2, %xmm6
testl %edi, %edi
jle 0x84ae
addl %edi, %edi
cmpl $0x2, %edi
movl $0x1, %eax
cmovgel %edi, %eax
movss 0x2ade9(%rip), %xmm2    # 0x33270
movsd 0x2add1(%rip), %xmm3    # 0x33260
addss %xmm2, %xmm0
addsd %xmm3, %xmm1
xorps %xmm4, %xmm4
cvtss2sd %xmm0, %xmm4
movapd %xmm1, %xmm5
divsd %xmm4, %xmm5
mulsd %xmm5, %xmm6
decl %eax
jne 0x848f
movsd %xmm6, 0x10(%rsp)
movq 0x38b05(%rip), %rbx     # 0x40fc0
leaq 0x2ae65(%rip), %rsi     # 0x33327
movl $0x27, %edx
movq %rbx, %rdi
callq 0x5420
movsd 0x2ad91(%rip), %xmm1    # 0x33268
subsd 0x10(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x5610
movq %rax, %rbx
xorl %ebp, %ebp
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/kmers.cpp
// Function: ascii_bitstring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void ascii_bitstring(std::string & mybits){
	int myremainder=::fmod(int(mybits.length()),6);
	if (myremainder>0){
		for (int i = 0; i<(6-myremainder); ++i){
			mybits.push_back('0');
		}
	}
	for (std::string::size_type i = 0; i<mybits.length(); i+=6){
		assert((i+5)<mybits.length());
		mybits[i/6] = ((int(mybits[i])-'0')+((int(mybits[i+1])-'0')*2)+((int(mybits[i+2])-'0')*4)+((int(mybits[i+3])-'0')*8)+((int(mybits[i+4])-'0')*16)+((int(mybits[i+5])-'0')*32))+33;
	}
	mybits.erase(mybits.length()/6);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2sdl 0x8(%rdi), %xmm0
movsd 0x2aae5(%rip), %xmm1    # 0x33398
callq 0x54d0
cvttsd2si %xmm0, %ebp
testl %ebp, %ebp
jle 0x88d9
cmpl $0x5, %ebp
ja 0x88d9
addl $-0x6, %ebp
movq %rbx, %rdi
movl $0x30, %esi
callq 0x5340
incl %ebp
jne 0x88c8
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x8960
movl $0x5, %esi
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
cmpq %rax, %rsi
jae 0x8974
leaq -0x5(%rsi), %rax
movq (%rbx), %rdi
movb -0x4(%rdi,%rsi), %r8b
movb -0x3(%rdi,%rsi), %dl
addb %r8b, %r8b
shlb $0x2, %dl
movb -0x2(%rdi,%rsi), %r9b
shlb $0x3, %r9b
addb %dl, %r9b
movb -0x1(%rdi,%rsi), %dl
shlb $0x4, %dl
addb %r9b, %dl
movb (%rdi,%rsi), %r9b
shlb $0x5, %r9b
addb %dl, %r9b
addb -0x5(%rdi,%rsi), %r8b
addb %r9b, %r8b
addb $0x51, %r8b
mulq %rcx
shrq $0x2, %rdx
movb %r8b, (%rdi,%rdx)
movq 0x8(%rbx), %rax
leaq 0x6(%rsi), %rdx
incq %rsi
cmpq %rax, %rsi
movq %rdx, %rsi
jb 0x88f1
mulq %rcx
shrq $0x2, %rdx
jmp 0x8962
xorl %edx, %edx
movq %rdx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2aa55(%rip), %rdi     # 0x333d0
leaq 0x2aa64(%rip), %rsi     # 0x333e6
leaq 0x2aa6b(%rip), %rcx     # 0x333f4
movl $0x17, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/kmers.cpp
// Function: vectorbool_from_ascii(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<bool, std::allocator<bool>>&)
void vectorbool_from_ascii(std::string & myascii, std::vector < bool > & mybits){
	mybits.resize(myascii.length()*6, false);
	for (std::string::size_type i = 0; i<myascii.length(); ++i){
		int bits=int(myascii[i])-33;
		for (int j=5; j>=0; --j){
			int power=int(pow(2,j));
			mybits[j+(6*i)]=int(bits/power);
			bits=bits%power;
		}
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
addq %rax, %rax
leaq (%rax,%rax,2), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xaa82
cmpq $0x0, 0x8(%r14)
je 0x8a7c
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
xorl %r12d, %r12d
leaq 0x3f(%r15), %r13
xorl %ecx, %ecx
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movq %rcx, 0x10(%rsp)
movsbl (%rax,%rcx), %ebp
addl $-0x21, %ebp
movl $0x5, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
callq 0x5370
cvttsd2si %xmm0, %ecx
movl %ebp, %eax
cltd
idivl %ecx
movq %r12, %rcx
addq %r14, %rcx
leaq 0x3f(%r12,%r14), %rsi
cmovnsq %rcx, %rsi
sarq $0x6, %rsi
shlq $0x3, %rsi
addq (%rbx), %rsi
movq %rcx, %rdi
andq %r13, %rdi
xorl %r8d, %r8d
cmpq %r15, %rdi
setbe %r8b
movl $0x1, %edi
shlq %cl, %rdi
leaq -0x8(,%r8,8), %rcx
movl %edx, %ebp
testl %eax, %eax
je 0x8a50
orq (%rsi,%rcx), %rdi
jmp 0x8a57
notq %rdi
andq (%rsi,%rcx), %rdi
movq %rdi, (%rsi,%rcx)
addq $-0x1, %r14
jb 0x89f4
movq 0x10(%rsp), %rcx
incq %rcx
addq $0x6, %r12
movq 0x8(%rsp), %r14
cmpq 0x8(%r14), %rcx
jb 0x89df
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq