LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/AlexTheMagnus[P]Project_Hex/src/ProjectHex.cc
// Function: main
int main(int argc, char* argv[]) {
    string infoFileName = getFileInfoName(argc, argv);
    std::cout << infoFileName << std::endl;

    changeIconsFromFileController changeIconsFromFileController;
    changeIconsFromFileController.changeIconsFromFile(infoFileName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x24fd
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x49f1(%rip), %rdi      # 0x6fd0
callq 0x21c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x4142
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x26ee
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x264c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2665
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x268f
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
jmp 0x268f
jmp 0x268c
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26a8
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/AlexTheMagnus[P]Project_Hex/src/infraestructure/changeIconsFromFileController.cc
// Function: changeIconsFromFileController::printWelcomeMessage()
void printWelcomeMessage() {
        std::cout << CLEAR;  //hace un clear pero mas bonito
        std::cout << std::endl;
        std::cout << UBLUE;  //Color azul
        std::cout << "\t"
                  << "Project_Hex" << std::endl;
        std::cout << RESET;  //Reset de formato de letra (color, negrita,..)
        std::cout << std::endl;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x45b3(%rip), %rbx      # 0x6fd0
leaq 0x2654(%rip), %rsi      # 0x5078
movl $0x4, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x261e(%rip), %rsi      # 0x507d
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21c0
leaq 0x2612(%rip), %rsi      # 0x5085
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21c0
leaq 0x2600(%rip), %rsi      # 0x5087
movl $0xb, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x25a3(%rip), %rsi      # 0x5065
movl $0x4, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/AlexTheMagnus[P]Project_Hex/src/infraestructure/fileReaderMapper.cc
// Function: NativeFileReaderMapper::openFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ifstream openFile(string fileNameInfo) {
        ifstream fileInfo(fileNameInfo);
        if (!fileInfo) {
            printErrorOpeningInfoFileMessage();
            exit(-1);
        }

        return fileInfo;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movl $0x8, %edx
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x30a4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x3102
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2060
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/AlexTheMagnus[P]Project_Hex/src/infraestructure/iconChanger.cc
// Function: NativeIconChanger::openFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ifstream openFile(string infoFileName) {
        ifstream infoFile(infoFileName);
        if (!infoFile) {
            printErrorOpeningInfoFileMessage();
            exit(-1);
        }

        return infoFile;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movl $0x8, %edx
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x3d58
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x3fb4
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2060
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/AlexTheMagnus[P]Project_Hex/src/infraestructure/iconChanger.cc
// Function: NativeIconChanger::printErrorOpeningAppFileMessage()
void printErrorOpeningAppFileMessage() {
        std::cout << RED;  //Color rojo
        std::cout << "Error al abrir el archivo de la app" << std::endl;
        std::cout << "Compruebe que haya asignado privilegios al programa" << std::endl;
        std::cout << RESET;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x3179(%rip), %rbx      # 0x6fd0
leaq 0x11a6(%rip), %rsi      # 0x5004
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21c0
leaq 0x1299(%rip), %rsi      # 0x510b
movl $0x23, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x1282(%rip), %rsi      # 0x512f
movl $0x33, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x117d(%rip), %rsi      # 0x5065
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40e2
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 0x41dc
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4142
leaq 0x10b3(%rip), %rsi      # 0x5163
movq %rbx, %rdi
callq 0x22a0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x40cd
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 0x107c(%rip), %rsi      # 0x5174
leaq 0x107a(%rip), %rdx      # 0x5179
movq %rbx, %rdi
callq 0x41dc
jmp 0x40cd
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x4125
movq (%r13), %rsi
incq %rsi
callq 0x21a0
jmp 0x4125
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x413a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaa68(%rip), %rbx      # 0xefd0
leaq 0x7b87(%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 0x7b53(%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 0x7b1f(%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 0x7ae9(%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 0x7ab3(%rip), %rsi      # 0xc11a
movl $0x4, %edx
movq %rax, %rdi
callq 0x32f0
leaq 0x7aa4(%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 0x79ab(%rip), %r12      # 0xc04c
movl $0x5, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32f0
leaq 0x7a6d(%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 0x7a0d(%rip), %rsi      # 0xc12f
movl $0xd, %edx
movq %rax, %rdi
callq 0x32f0
movq 0xa8aa(%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_O1/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 0x8e10
movq 0x60(%rbx), %r14
cmpq 0x68(%rbx), %r14
je 0x6f3e
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 0x88b0
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 0x6f34
callq 0x3260
addq $0x40, %r14
cmpq 0x68(%rbx), %r14
jne 0x6ed1
leaq 0x54bd(%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 0x547f(%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 0x6fbb
callq 0x3260
movq 0x8006(%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 0x7ef6
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 0x703e
callq 0x3260
jmp 0x703e
movq %rax, %rbx
leaq -0x308(%rbp), %rdi
callq 0x33d0
jmp 0x704f
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x7ef6
jmp 0x7090
jmp 0x7066
movq %rax, %rbx
jmp 0x7099
jmp 0x7066
movq %rax, %rbx
jmp 0x7090
movq %rax, %rbx
jmp 0x707f
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x3140
movq -0x308(%rbp), %rdi
cmpq %r13, %rdi
je 0x7090
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_O1/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 0x35b4(%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 0x8ec5
leaq -0x348(%rbp), %rdi
callq 0x3080
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e89
callq 0x3260
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e9e
callq 0x3260
leaq -0xf0(%rbp), %rdi
callq 0xa850
leaq -0x140(%rbp), %rdi
callq 0xa9de
movq %rbx, %rax
addq $0x340, %rsp            # imm = 0x340
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6104(%rip), %rdi      # 0xefd0
leaq 0x35c3(%rip), %rsi      # 0xc496
movl $0x1a, %edx
callq 0x32f0
movq 0x60ec(%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 0x8f41
callq 0x3260
jmp 0x8f41
jmp 0x8f3e
movq %rax, %r14
jmp 0x8f4d
movq %rax, %r14
jmp 0x8f59
movq %rax, %r14
leaq -0x348(%rbp), %rdi
callq 0x3080
leaq -0x140(%rbp), %rdi
callq 0xa800
movq %rbx, %rdi
callq 0x3140
movq %r14, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x351e(%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 0x902f
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 0x8fed
callq 0x3260
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9002
callq 0x3260
leaq -0x110(%rbp), %rdi
callq 0xa850
leaq -0x160(%rbp), %rdi
callq 0xa9de
leaq -0x50(%rbp), %rdi
callq 0x3140
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %rbp
retq
movq 0x5f9a(%rip), %rdi      # 0xefd0
leaq 0x3488(%rip), %rsi      # 0xc4c5
movl $0x1b, %edx
callq 0x32f0
movq 0x5f82(%rip), %rdi      # 0xefd0
callq 0x3130
movq %rax, %rbx
leaq 0x3484(%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 0x90ca
callq 0x3260
jmp 0x90ca
jmp 0x90c7
movq %rax, %rbx
jmp 0x90d6
movq %rax, %rbx
jmp 0x90e2
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x160(%rbp), %rdi
callq 0xa800
leaq -0x50(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33cb(%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 0x91b9
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 0x9177
callq 0x3260
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x918c
callq 0x3260
leaq -0x110(%rbp), %rdi
callq 0xa850
leaq -0x160(%rbp), %rdi
callq 0xa9de
leaq -0x50(%rbp), %rdi
callq 0x3140
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %rbp
retq
movq 0x5e10(%rip), %rdi      # 0xefd0
leaq 0x3335(%rip), %rsi      # 0xc4fc
movl $0x1c, %edx
callq 0x32f0
movq 0x5df8(%rip), %rdi      # 0xefd0
callq 0x3130
movq %rax, %rbx
leaq 0x32fa(%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 0x9254
callq 0x3260
jmp 0x9254
jmp 0x9251
movq %rax, %rbx
jmp 0x9260
movq %rax, %rbx
jmp 0x926c
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x160(%rbp), %rdi
callq 0xa800
leaq -0x50(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3241(%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 0x9395
movq 0x5ced(%rip), %rbx      # 0xefd0
leaq 0x3212(%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 0x5cbb(%rip), %rdi      # 0xefd0
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rax, %rbx
leaq 0x31b5(%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 0x9395
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 0x93be
callq 0x3260
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93d3
callq 0x3260
leaq -0x110(%rbp), %rdi
callq 0xa850
leaq -0x160(%rbp), %rdi
callq 0xa9de
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 0x9426
callq 0x3260
jmp 0x9426
jmp 0x9423
movq %rax, %rbx
jmp 0x9432
movq %rax, %rbx
jmp 0x943e
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3080
leaq -0x160(%rbp), %rdi
callq 0xa800
leaq -0x50(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a78(%rip), %rdi      # 0xefd0
movq %rax, %rsi
callq 0x32f0
cmpq $0x0, 0x8(%r15)
je 0xb5b8
imull $0x3e8, %r14d, %r12d    # imm = 0x3E8
movl $0x1, %ebx
xorl %eax, %eax
leaq -0x29(%rbp), %r14
movq 0x3a20(%rip), %r13      # 0xefa0
movq (%r15), %rcx
movb (%rcx,%rax), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq 0x3a3b(%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 0xb580
movq 0x3a11(%rip), %r14      # 0xefd0
leaq 0xa86(%rip), %rsi       # 0xc04c
movl $0x5, %edx
movq %r14, %rdi
callq 0x32f0
cmpb $0x0, -0x30(%rbp)
je 0xb600
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 0xb612
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_O1/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), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
shrq %rax
cvtsi2ss %rax, %xmm0
xorps %xmm3, %xmm3
movss 0x2c76c(%rip), %xmm1    # 0x33004
movss 0x2c768(%rip), %xmm2    # 0x33008
leaq 0x3ab19(%rip), %rsi     # 0x413c0
ucomiss %xmm3, %xmm0
jbe 0x6902
movaps %xmm3, %xmm4
addss %xmm1, %xmm4
cvttss2si %xmm4, %edi
cvttss2si %xmm3, %r8
movq %r8, %r9
subss %xmm2, %xmm3
cvttss2si %xmm3, %r10
sarq $0x3f, %r9
andq %r9, %r10
orq %r8, %r10
movb (%rcx,%r10), %r8b
movslq %edi, %rdi
movq %rdx, %r9
subq %rdi, %r9
movsbq (%rcx,%r9), %rdi
movb (%rdi,%rsi), %dil
cmpb %dil, %r8b
setge %r9b
setg %r10b
orb %r10b, %al
andb %r9b, %al
movaps %xmm4, %xmm3
cmpb %dil, %r8b
je 0x68a7
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x687b
testb %al, %al
je 0x6980
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
setne %sil
addq %rcx, %rdx
decq %rdx
cmpq %rcx, %rdx
seta %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x6956
incq %rcx
movb -0x1(%rcx), %sil
movb (%rdx), %dil
movb %dil, -0x1(%rcx)
movb %sil, (%rdx)
decq %rdx
leaq 0x1(%rcx), %rsi
cmpq %rdx, %rcx
movq %rsi, %rcx
jb 0x6939
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x6980
movq (%rbx), %rdx
xorl %esi, %esi
leaq 0x3aa55(%rip), %rdi     # 0x413c0
movsbq (%rdx,%rsi), %r8
movb (%r8,%rdi), %r8b
movb %r8b, (%rdx,%rsi)
incq %rsi
cmpq %rsi, %rcx
jne 0x696b
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x0, 0x8(%rdi)
je 0x69a8
addl (%rdx), %ecx
xorl %eax, %eax
movq (%rsi), %rdx
movsbl (%rdx,%rax), %edx
cmpl %edx, %ecx
jle 0x699f
movq (%rdi), %rdx
movb $0x4e, (%rdx,%rax)
incq %rax
cmpq 0x8(%rdi), %rax
jb 0x698d
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
setne %bpl
je 0x6bb3
cmpq $0x3, %rax
jb 0x6b3d
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movl $0x2, %esi
leaq 0x3a95a(%rip), %rdi     # 0x41440
leaq -0x2(%rsi), %rax
movq (%rbx), %r8
movsbq -0x2(%r8,%rsi), %rdx
movsbq -0x1(%r8,%rsi), %r9
movb (%r9,%rdi), %r9b
shlb $0x2, %r9b
movsbq (%r8,%rsi), %r10
movb (%r10,%rdi), %r10b
shlb $0x4, %r10b
addb (%rdx,%rdi), %r9b
addb %r10b, %r9b
mulq %rcx
addb $0x3f, %r9b
shrq %rdx
movb %r9b, (%r8,%rdx)
leaq 0x1(%rsi), %rdx
movq 0x8(%rbx), %rax
cmpq %rax, %rdx
setb %bpl
jae 0x6bb3
addq $0x3, %rsi
cmpq %rax, %rsi
jb 0x6ae6
movq 0x3a4ac(%rip), %r14     # 0x40ff0
leaq 0x2c4ec(%rip), %rsi     # 0x33037
movl $0x22, %edx
movq %r14, %rdi
callq 0x5420
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movl $0x1, %eax
testb %bpl, %bpl
jne 0x6bd1
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
mulq 0x8(%rbx)
shrq %rdx
movq %rdx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c96
xorl %eax, %eax
leaq 0x3a8b8(%rip), %rcx     # 0x414c5
xorl %edx, %edx
movq (%r14), %rsi
movsbl (%rsi,%rdx), %esi
leal -0x3f(%rsi), %edi
addl $-0x30, %esi
testl %edi, %edi
cmovnsl %edi, %esi
sarl $0x4, %esi
movslq %esi, %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
testl %edi, %edi
cmovnsl %edi, %r8d
andl $-0x10, %r8d
subl %r8d, %edi
negl %r8d
addl %r8d, %esi
addl $-0x3c, %esi
testl %edi, %edi
cmovnsl %edi, %esi
movl %esi, %r8d
sarl $0x2, %r8d
movslq %r8d, %r8
movb (%r8,%rcx), %r8b
movq (%rbx), %r9
movb %r8b, 0x1(%r9,%rax)
andl $-0x4, %esi
subl %esi, %edi
movslq %edi, %rsi
movb (%rsi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, (%rdi,%rax)
incq %rdx
addq $0x3, %rax
cmpq 0x8(%r14), %rdx
jb 0x6c0f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7742
movq (%r14), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x7d76
leaq 0x1b0(%rsp), %r15
movq %r15, %rdi
callq 0x5460
cmpl $0x3e, %eax
jne 0x74f4
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 0x758e
incl (%rbx)
jmp 0x74ce
movq 0x39af5(%rip), %rdi     # 0x40ff0
leaq 0x2bb58(%rip), %rsi     # 0x3305a
movl $0x7, %edx
callq 0x5420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x39ad6(%rip), %rdi     # 0x40ff0
callq 0x5420
movq %rax, %rbx
leaq 0x2bcc0(%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 0x75b1
leaq 0x28(%rsp), %rdi
callq 0x782c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x75af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
xorl %ebx, %ebx
leaq 0x39640(%rip), %rax     # 0x40bf8
leaq 0x1c0(%rsp), %r14
movq %rax, -0x10(%r14)
leaq 0x39655(%rip), %rax     # 0x40c20
movq %rax, (%r14)
movq $0x0, -0x8(%r14)
leaq 0x3955b(%rip), %rsi     # 0x40b38
leaq 0x28(%rsp), %rdi
callq 0x7954
movq %r14, %rdi
callq 0x5120
movl %ebx, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7607
movq %rax, %rbx
jmp 0x7621
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7621
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x28(%rsp), %rdi
callq 0x7862
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76f2
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 0x76d5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76f0
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 0x771f
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x771f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x773a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c48
cmpq 0x18(%rbx), %rsi
jae 0x7c48
movzbl (%rsi), %ebp
jmp 0x7cb6
testb $0x8, 0x178(%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x7cb6
cmpb $0x0, 0x177(%rbx)
je 0x7cb6
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 0x7cb6
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_O1/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 0x7cfb
cmpb $0x0, 0x177(%rdi)
je 0x7cfb
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0x7ced
movq 0x28(%rdi), %rax
movb %bl, (%rax)
incq 0x28(%rdi)
callq 0x7cfc
cmpl $-0x1, %eax
cmovel %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d34
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_O1/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 0x7d63
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
movb $0x0, 0x177(%rbx)
movq 0x40(%rbx), %rdi
callq 0x5660
testl %eax, %eax
je 0x7d65
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7e12
movq %rdi, %rbx
movl %edx, 0x178(%rdi)
testb $0x3, %dl
jne 0x7e12
movl %edx, %eax
notl %eax
testb $0x18, %al
je 0x7e12
testb $0x8, %dl
jne 0x7dd7
testb $0x10, %dl
jne 0x7de2
leaq 0x6(%rsp), %rax
jmp 0x7deb
leaq 0x7(%rsp), %rax
movb $0x72, -0x1(%rax)
jmp 0x7deb
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 0x7e12
movb $0x1, 0x177(%rbx)
jmp 0x7e14
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x859a
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2c458(%rip), %rdx     # 0x342b2
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x862a
leaq 0x2b40a(%rip), %rsi     # 0x33278
movl $0x2, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x5740
cmpq $-0x1, %rax
je 0x7f0d
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 0x7ece
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 0x7f0d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7f24
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 0x7f38
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7f57
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53c0
jmp 0x7f57
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x7f6b
movq (%r13), %rsi
incq %rsi
callq 0x53c0
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ff7
movq 0x39016(%rip), %r15     # 0x40fc0
leaq 0x2b2ca(%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 0x809d
movq 0x38fcf(%rip), %r14     # 0x40ff0
leaq 0x2b40f(%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_O1/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 0x782c
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 0x7d76
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x8175
movq 0x38ef7(%rip), %r14     # 0x40ff0
leaq 0x2b337(%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