LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/TTLIUJJ[P]acker_redis/redis.cpp
// Function: initRedisClient()
redisClient *initRedisClient()
{
	redisClient *client = (redisClient *)zmalloc(sizeof(struct redisClient));
	redisCommand *cmd = (redisCommand *)zmalloc(sizeof(struct redisCommand));
	redisDb *db = (redisDb *)zmalloc(sizeof(struct redisDb));
	dict *d = dictCreate(&dictObjectType, NULL);
	db->dict = d;
	client->db = db;
	
	client->fd = -1;
	client->argv = (robj **)zmalloc(MAXQUERYARGC * sizeof(robj *));
	client->argc = 0;
	client->cmd = NULL;
	client->querybuf = NULL;
	client->bufpos = 0;
	memset(client->buf, 0, REDIS_REPLY_CHUNK_BYTES);

	return client;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x4038, %edi           # imm = 0x4038
callq 0x3564
movq %rax, %rbx
pushq $0x18
popq %rdi
callq 0x3564
pushq $0x10
popq %rdi
callq 0x3564
movq %rax, %r14
leaq 0x536f(%rip), %rdi      # 0x9170
xorl %esi, %esi
callq 0x2863
movq %rax, (%r14)
movq %r14, (%rbx)
orl $-0x1, 0x8(%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x3564
movq %rax, 0x20(%rbx)
andl $0x0, 0x18(%rbx)
leaq 0x28(%rbx), %rdi
andq $0x0, 0x10(%rbx)
movl $0x400c, %edx           # imm = 0x400C
xorl %esi, %esi
callq 0x10d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/TTLIUJJ[P]acker_redis/main.cpp
// Function: main
int main(int argc,char *argv[])
{
	
	
    int  listenfd;
    listenfd = socket_bind(IPADDRESS,PORT);
    listen(listenfd,LISTENQ);
    do_epoll(listenfd);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4d8, %rsp            # imm = 0x4D8
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x1050
cmpl $-0x1, %eax
je 0x3fed
movl %eax, %r13d
xorps %xmm0, %xmm0
leaq 0x24(%rsp), %r14
movaps %xmm0, -0x4(%r14)
movw $0x2, -0x4(%r14)
leaq 0x16b1(%rip), %rsi      # 0x553a
pushq $0x2
popq %rdi
movq %r14, %rdx
callq 0x1230
movw $0x5322, -0x2(%r14)     # imm = 0x5322
leaq 0x20(%rsp), %rsi
pushq $0x10
popq %rdx
movl %r13d, %edi
callq 0x1040
cmpl $-0x1, %eax
je 0x3ff6
pushq $0x5
popq %rsi
movl %r13d, %edi
callq 0x1150
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x1220
movl %eax, %ebp
pushq $0x1
popq %rdx
movl %eax, %edi
movl %r13d, %esi
callq 0x38bc
callq 0x3dd6
movq %rax, (%rsp)
movl %ebp, %edi
leaq 0x20(%rsp), %rsi
pushq $0x64
popq %rdx
pushq $-0x1
popq %rcx
callq 0x10c0
movl %r13d, %r15d
movl %eax, %r13d
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x36b8
movq %rax, %r12
testl %r13d, %r13d
movl $0x0, %eax
cmovlel %eax, %r13d
imulq $0xc, %r13, %r14
movl %r15d, %r13d
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x3fd1
movl 0x24(%rsp,%rbx), %ecx
movl %ecx, 0x8(%r12)
movl 0x20(%rsp,%rbx), %eax
cmpl %r13d, %ecx
jne 0x3f60
testb $0x1, %al
je 0x3f64
movl %r13d, %edi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x1060
cmpl $-0x1, %eax
jne 0x3f96
leaq 0x1606(%rip), %rdi      # 0x555f
callq 0x1120
jmp 0x3fc5
testb $0x1, %al
jne 0x3f7f
testb $0x4, %al
je 0x3fc8
movl $0x2, 0x4(%r12)
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x3809
jmp 0x3fc8
movl $0x1, 0x4(%r12)
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x36e7
jmp 0x3fc8
movl %eax, %r13d
movl 0x14(%rsp), %edi
callq 0x10a0
movzwl 0x12(%rsp), %edx
leaq 0x15bf(%rip), %rdi      # 0x556d
movq %rax, %rsi
xorl %eax, %eax
callq 0x1030
movl %ebp, %edi
movl %r13d, %esi
pushq $0x1
popq %rdx
callq 0x38bc
movl %r15d, %r13d
addq $0xc, %rbx
jmp 0x3f1c
movq %r12, %rdi
callq 0x3681
movq (%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2998
jmp 0x3ee1
leaq 0x1550(%rip), %rdi      # 0x5544
jmp 0x3ffd
leaq 0x1555(%rip), %rdi      # 0x5552
callq 0x1120
pushq $0x1
popq %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/utils.c
// Function: inUtils_TrimLeadingSpaceTextline
int inUtils_TrimLeadingSpaceTextline( char *buf )
{
   size_t i,ie=0,is=0;


   if( buf == NULL ) return(1);

   while( buf[is] == ' ' ) ++is;
   while( buf[ie] != '\0' ) ++ie;

   if( is == 0 ) return(0);

   for(i=0;i<ie-is;++i) {
      buf[i] = buf[i+is];
      buf[i+is] = '\0';
   }

   return(0);
}

// Assembly:
testq %rdi, %rdi
je 0x127b
xorl %ecx, %ecx
cmpb $0x20, (%rdi,%rcx)
leaq 0x1(%rcx), %rcx
je 0x1239
xorl %edx, %edx
cmpb $0x0, (%rdi,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x1245
xorl %eax, %eax
cmpq $0x1, %rcx
je 0x127e
subq %rcx, %rdx
xorl %eax, %eax
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x127e
leaq (%rdi,%rsi), %r8
movb -0x1(%rcx,%r8), %r9b
movb %r9b, (%rdi,%rsi)
movb $0x0, -0x1(%rcx,%r8)
incq %rsi
jmp 0x125e
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/AlexTheMagnus[P]Project_Hex/src/ProjectHex.cc
// Function: printUnexpectedArgumentsMessage()
void printUnexpectedArgumentsMessage() {
    std::cout << RED;  //Color rojo
    std::cout << "Error, demasiados argumetos." << std::endl;
    std::cout << "El uso adecuado es: \"sudo ./Project_Hex.out <infoFile.txt>\"" << std::endl;
    std::cout << RESET;  //Reset de formato de letra (color, negrita,..)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x4bb7(%rip), %rbx      # 0x6fd0
leaq 0x1be4(%rip), %rsi      # 0x4004
movq %rbx, %rdi
callq 0x2170
leaq 0x1bdd(%rip), %rsi      # 0x400c
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20c0
leaq 0x1be3(%rip), %rsi      # 0x4029
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20c0
leaq 0x1c08(%rip), %rsi      # 0x4065
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/AlexTheMagnus[P]Project_Hex/src/ProjectHex.cc
// Function: getFileInfoName[abi:cxx11](int, char**)
string getFileInfoName(int argc, char* argv[]) {
    if (argc > 2) {
        printUnexpectedArgumentsMessage();
        exit(-1);
    }
    if (argc == 2) {
        std::cerr << "info" << std::endl;

        return argv[1];
    }
    std::cerr << "info" << std::endl;

    return "info.txt";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %esi
jge 0x24cf
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x4b66(%rip), %rdi      # 0x6ff0
leaq 0x1bd9(%rip), %rsi      # 0x406a
callq 0x2170
movq %rax, %rdi
callq 0x20c0
cmpl $0x2, %r15d
jne 0x24ae
movq 0x8(%r14), %rsi
leaq -0x1a(%rbp), %rdx
jmp 0x24b9
leaq 0x1bba(%rip), %rsi      # 0x406f
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x2566
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x240c
pushq $-0x1
popq %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x246b
movq 0x4ad3(%rip), %rdi      # 0x6fd0
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x21e0
leaq -0x9(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x25a2
leaq -0x30(%rbp), %rdi
callq 0x20b0
leaq -0x50(%rbp), %rdi
callq 0x20b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20b0
jmp 0x2555
jmp 0x2552
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/AlexTheMagnus[P]Project_Hex/src/infraestructure/changeIconsFromFileController.cc
// Function: changeIconsFromFileController::changeIconsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void changeIconsFromFile(string infoFileName) {
        printWelcomeMessage();

        NativeFileReaderMapper fileReaderMapper;
        vector<App> apps = (fileReaderMapper.mapFileToApps(infoFileName));

        NativeIconChanger iconChanger;

        for (std::vector<App>::iterator iterator = apps.begin(); iterator != apps.end(); ++iterator) {
            printChangingIconMessage(iterator->getSettingFileName());

            iconChanger.changeIconOf(iterator->getSettingFileName(), iterator->getNewIconName());
            printOKMessage();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2712
leaq 0x4778(%rip), %rax      # 0x6d40
leaq -0x48(%rbp), %r15
movq %rax, (%r15)
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x21e0
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2788
leaq -0x68(%rbp), %rdi
callq 0x20b0
leaq -0x110(%rbp), %rdi
callq 0x2966
movq -0x40(%rbp), %r14
leaq -0xc8(%rbp), %r15
leaq -0xa8(%rbp), %r12
leaq -0x88(%rbp), %r13
cmpq -0x38(%rbp), %r14
je 0x2689
movq %r15, %rdi
movq %r14, %rsi
callq 0x21e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29c8
movq %r15, %rdi
callq 0x20b0
movq %r12, %rdi
movq %r14, %rsi
callq 0x21e0
addq $0x20, %r14
movq %r13, %rdi
movq %r14, %rsi
callq 0x21e0
leaq -0x110(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2a0c
movq %r13, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2ab0
addq $0x20, %r14
jmp 0x261b
leaq -0x110(%rbp), %rdi
callq 0x2af8
leaq -0x40(%rbp), %rdi
callq 0x2b26
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2700
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20b0
jmp 0x2709
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x20b0
jmp 0x26e3
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
jmp 0x26ea
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x20b0
jmp 0x26f4
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x2af8
leaq -0x40(%rbp), %rdi
callq 0x2b26
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x48b1(%rip), %rbx      # 0x6fd0
leaq 0x1952(%rip), %rsi      # 0x4078
movq %rbx, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x20c0
leaq 0x1940(%rip), %rsi      # 0x407d
movq %rbx, %rdi
callq 0x2170
leaq 0x1939(%rip), %rsi      # 0x4085
movq %rbx, %rdi
callq 0x2170
leaq 0x192c(%rip), %rsi      # 0x4087
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20c0
leaq 0x18f3(%rip), %rsi      # 0x4065
movq %rbx, %rdi
callq 0x2170
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/AlexTheMagnus[P]Project_Hex/src/infraestructure/fileReaderMapper.cc
// Function: NativeFileReaderMapper::mapFileToApps(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<App> mapFileToApps(string infoFilePath) {
        vector<App> apps;
        ifstream fileInfo = openFile(infoFilePath);
        string settingfileName, newIconName;

        while (getline(fileInfo, settingfileName, ',')) {
            getline(fileInfo, newIconName, '\n');

            App *auxiliaryApp = new App;
            auxiliaryApp->setSettingFileName(settingfileName);
            auxiliaryApp->setNewIconName(newIconName);

            apps.push_back(*auxiliaryApp);
        }

        return apps;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x10(%rdi)
leaq -0x90(%rbp), %rdi
movq %rdx, %rsi
callq 0x21e0
leaq -0x2d8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq %rbx, %rsi
callq 0x2b52
leaq -0x90(%rbp), %rdi
callq 0x20b0
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x70(%rbp), %r15
leaq -0x50(%rbp), %r13
leaq -0xd0(%rbp), %r12
leaq -0xb0(%rbp), %rbx
leaq -0x2d8(%rbp), %rdi
movq %r15, %rsi
pushq $0x2c
popq %rdx
callq 0x2290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x28ca
leaq -0x2d8(%rbp), %rdi
movq %r13, %rsi
pushq $0xa
popq %rdx
callq 0x2290
pushq $0x40
popq %rdi
callq 0x2180
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
xorl %ecx, %ecx
movb %cl, 0x10(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
andq $0x0, 0x28(%r14)
movb %cl, 0x30(%r14)
movq %r12, %rdi
movq %r15, %rsi
callq 0x21e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x20f0
movq %r12, %rdi
callq 0x20b0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21e0
movq %r14, %rdi
addq $0x20, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x20b0
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x2ba6
jmp 0x2815
leaq -0x50(%rbp), %rdi
callq 0x20b0
leaq -0x70(%rbp), %rdi
callq 0x20b0
leaq -0x2d8(%rbp), %rdi
callq 0x2060
movq -0x30(%rbp), %rax
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x20b0
jmp 0x2954
movq %rax, %rbx
jmp 0x2954
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x292a
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x20b0
jmp 0x2936
jmp 0x2933
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20b0
leaq -0x70(%rbp), %rdi
callq 0x20b0
leaq -0x2d8(%rbp), %rdi
callq 0x2060
movq -0x30(%rbp), %rdi
callq 0x2b26
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rax
movq %rdx, %rsi
movl %eax, %edx
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x2b82
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x2be2
pushq $-0x1
popq %rdi
callq 0x21a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2060
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rax
movq %rdx, %rsi
movl %eax, %edx
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x3338
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x3534
pushq $-0x1
popq %rdi
callq 0x21a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2060
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b75(%rip), %rbx      # 0x6fd0
leaq 0xba2(%rip), %rsi       # 0x4004
movq %rbx, %rdi
callq 0x2170
leaq 0xc9a(%rip), %rsi       # 0x410b
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20c0
leaq 0xca7(%rip), %rsi       # 0x412f
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20c0
leaq 0xbc6(%rip), %rsi       # 0x4065
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1030, %rsp           # imm = 0x1030
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1040(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x20d0
testq %rax, %rax
je 0x3604
leaq -0x38(%rbp), %r14
leaq -0x1040(%rbp), %rsi
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x2566
leaq 0xb75(%rip), %rdx       # 0x4163
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3642
leaq -0x38(%rbp), %rdi
callq 0x20b0
jmp 0x361f
movq %r14, %rdi
callq 0x367a
leaq 0xb61(%rip), %rsi       # 0x4174
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x2566
movq %rbx, %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/Agusyc[P]CTRPG/src/battle.cpp
// Function: Battle::start(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Player Battle::start(string message) {
    // Start the battle

    printMessage(message, YELLOW);

    printMessage(RED + enemy.name + WHITE + string(" wants to fight!"));

    // Seed the random number generator.
    srand(time(NULL));

    loop();

    return player;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rdx, %rsi
callq 0x3310
leaq 0x581a(%rip), %rsi      # 0x9040
leaq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x30c0
leaq -0xe0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
pushq $0x23
popq %rdx
pushq $0x1
popq %r8
movl $0x12c, %ecx            # imm = 0x12C
callq 0x8e78
leaq -0xc0(%rbp), %rdi
callq 0x3100
leaq -0xe0(%rbp), %rdi
callq 0x3100
leaq 0x78(%r14), %rdx
leaq 0x57ce(%rip), %rsi      # 0x9046
leaq -0x100(%rbp), %r15
movq %r15, %rdi
callq 0x6153
leaq 0x57be(%rip), %rdx      # 0x904c
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x612a
leaq 0x57b1(%rip), %rsi      # 0x9052
leaq -0x80(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x30c0
leaq -0xa0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x60b9
leaq 0x5783(%rip), %rsi      # 0x904c
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x30c0
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
pushq $0x23
popq %rdx
pushq $0x1
popq %r8
movl $0x12c, %ecx            # imm = 0x12C
callq 0x8e78
leaq -0x60(%rbp), %rdi
callq 0x3100
leaq -0xa0(%rbp), %rdi
callq 0x3100
leaq -0x80(%rbp), %rdi
callq 0x3100
leaq -0x40(%rbp), %rdi
callq 0x3100
leaq -0x100(%rbp), %rdi
callq 0x3100
xorl %edi, %edi
callq 0x31f0
movl %eax, %edi
callq 0x3210
movq %r14, %rdi
callq 0x39c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61ca
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3100
jmp 0x3968
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x3100
jmp 0x3979
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3100
jmp 0x3987
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3100
jmp 0x3995
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
jmp 0x39b9
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3100
jmp 0x39b2
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x91b7(%rip), %rbx      # 0xcfd0
leaq 0x52d6(%rip), %rsi      # 0x90f6
movq %rbx, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3110
leaq 0x52c9(%rip), %rsi      # 0x9100
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3110
leaq 0x52bc(%rip), %rsi      # 0x910a
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3110
leaq 0x52ad(%rip), %rsi      # 0x9112
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3110
leaq 0x529e(%rip), %rsi      # 0x911a
movq %rax, %rdi
callq 0x3220
leaq 0x5294(%rip), %r15      # 0x911f
movq %rax, %rdi
movq %r15, %rsi
callq 0x3220
movl 0x34(%r14), %esi
movq %rax, %rdi
callq 0x3470
leaq 0x51a3(%rip), %r12      # 0x904c
movq %rax, %rdi
movq %r12, %rsi
callq 0x3220
leaq 0x526a(%rip), %rsi      # 0x9125
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
movq %r15, %rsi
callq 0x3220
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x3470
movq %rax, %rdi
movq %r12, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3110
leaq 0x523b(%rip), %rsi      # 0x912f
movq %rax, %rdi
callq 0x3220
movq 0x90dd(%rip), %rdi      # 0xcfe0
leaq -0x24(%rbp), %r14
movq %r14, %rsi
callq 0x3160
movq %rbx, %rdi
callq 0x3110
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30e0
leaq -0x70(%rbp), %rdi
callq 0x709c
movq 0x60(%rbx), %r14
leaq -0x308(%rbp), %r15
leaq -0x108(%rbp), %r12
leaq -0x98(%rbp), %r13
cmpq 0x68(%rbx), %r14
je 0x5651
movq %r15, %rdi
movq %r14, %rsi
callq 0x6344
movl -0x2cc(%rbp), %esi
movq %r12, %rdi
callq 0x3150
movq %r13, %rdi
movq %r12, %rsi
callq 0x3320
movq %r12, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x3100
addq $0x40, %r14
jmp 0x5611
leaq 0x3daa(%rip), %rsi      # 0x9402
leaq -0x70(%rbp), %rdi
callq 0x30b0
leaq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x3340
leaq -0x108(%rbp), %rdi
callq 0x3050
leaq 0x3d6c(%rip), %rsi      # 0x93ef
leaq -0x308(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x3250
leaq -0x48(%rbp), %rdi
leaq -0x108(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x32f0
leaq -0x308(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x31d0
leaq -0x48(%rbp), %rdi
callq 0x3100
leaq -0x308(%rbp), %rdi
callq 0x3380
leaq -0x108(%rbp), %rdi
callq 0x639e
leaq -0x70(%rbp), %rdi
callq 0x3120
leaq -0x98(%rbp), %rdi
callq 0x3120
addq $0x2e8, %rsp            # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3100
jmp 0x570f
movq %rax, %rbx
leaq -0x308(%rbp), %rdi
callq 0x3380
jmp 0x5720
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x639e
jmp 0x575c
jmp 0x5737
movq %rax, %rbx
jmp 0x5765
jmp 0x5737
movq %rax, %rbx
jmp 0x575c
movq %rax, %rbx
jmp 0x5750
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x3120
leaq -0x308(%rbp), %rdi
callq 0x3100
leaq -0x70(%rbp), %rdi
callq 0x3120
leaq -0x98(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30e0
leaq -0x140(%rbp), %rdi
callq 0x3240
leaq 0x2328(%rip), %rsi      # 0x93ef
leaq -0x348(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x34a0
leaq -0x140(%rbp), %rdi
leaq -0x348(%rbp), %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdx
callq 0x34c0
testb %al, %al
je 0x711a
leaq -0x348(%rbp), %rdi
callq 0x3070
leaq -0x140(%rbp), %rdi
callq 0x860c
movq %rbx, %rax
addq $0x340, %rsp            # imm = 0x340
popq %rbx
popq %r14
popq %rbp
retq
movq 0x5eaf(%rip), %rdi      # 0xcfd0
leaq 0x2344(%rip), %rsi      # 0x946c
callq 0x3220
movq %rax, %rdi
callq 0x3110
movq %rax, %r14
leaq -0x30(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x33d0
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x3100
pushq $0x1
popq %rdi
callq 0x32b0
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x3100
jmp 0x7182
jmp 0x717f
movq %rax, %r14
jmp 0x718e
movq %rax, %r14
jmp 0x719a
movq %rax, %r14
leaq -0x348(%rbp), %rdi
callq 0x3070
leaq -0x140(%rbp), %rdi
callq 0x860c
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30e0
leaq -0x160(%rbp), %rdi
callq 0x3240
leaq 0x22b3(%rip), %rsi      # 0x9487
leaq -0x368(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x34a0
leaq -0x160(%rbp), %rdi
leaq -0x368(%rbp), %rsi
leaq -0x50(%rbp), %rdx
pushq $0x1
popq %rcx
callq 0x34c0
testb %al, %al
je 0x7239
leaq -0x50(%rbp), %rdi
callq 0x3440
movl %eax, %ebx
leaq -0x368(%rbp), %rdi
callq 0x3070
leaq -0x160(%rbp), %rdi
callq 0x860c
leaq -0x50(%rbp), %rdi
callq 0x3120
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %rbp
retq
movq 0x5d90(%rip), %rdi      # 0xcfd0
leaq 0x2254(%rip), %rsi      # 0x949b
callq 0x3220
movq %rax, %rdi
callq 0x3110
leaq 0x225c(%rip), %rsi      # 0x94b7
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x33d0
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x31d0
leaq -0x28(%rbp), %rdi
callq 0x3100
pushq $0x1
popq %rdi
callq 0x32b0
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3100
jmp 0x72b8
jmp 0x72b5
movq %rax, %rbx
jmp 0x72c4
movq %rax, %rbx
jmp 0x72d0
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3070
leaq -0x160(%rbp), %rdi
callq 0x860c
leaq -0x50(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30e0
leaq -0x160(%rbp), %rdi
callq 0x3240
leaq 0x21b3(%rip), %rsi      # 0x94be
leaq -0x368(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x34a0
leaq -0x160(%rbp), %rdi
leaq -0x368(%rbp), %rsi
leaq -0x50(%rbp), %rdx
pushq $0x1
popq %rcx
callq 0x34c0
testb %al, %al
je 0x7370
leaq -0x50(%rbp), %rdi
callq 0x3440
movl %eax, %ebx
leaq -0x368(%rbp), %rdi
callq 0x3070
leaq -0x160(%rbp), %rdi
callq 0x860c
leaq -0x50(%rbp), %rdi
callq 0x3120
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %rbp
retq
movq 0x5c59(%rip), %rdi      # 0xcfd0
leaq 0x2154(%rip), %rsi      # 0x94d2
callq 0x3220
movq %rax, %rdi
callq 0x3110
leaq 0x2125(%rip), %rsi      # 0x94b7
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x33d0
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x31d0
leaq -0x28(%rbp), %rdi
callq 0x3100
pushq $0x1
popq %rdi
callq 0x32b0
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3100
jmp 0x73ef
jmp 0x73ec
movq %rax, %rbx
jmp 0x73fb
movq %rax, %rbx
jmp 0x7407
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3070
leaq -0x160(%rbp), %rdi
callq 0x860c
leaq -0x50(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30e0
leaq -0x160(%rbp), %rdi
callq 0x3240
leaq 0x207c(%rip), %rsi      # 0x94be
leaq -0x368(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x34a0
leaq -0x160(%rbp), %rdi
leaq -0x368(%rbp), %rsi
leaq -0x50(%rbp), %rdx
pushq $0x1
popq %rcx
callq 0x34c0
testb %al, %al
jne 0x74c9
movq 0x5b5a(%rip), %rdi      # 0xcfd0
leaq 0x2055(%rip), %rsi      # 0x94d2
callq 0x3220
movq %rax, %rdi
callq 0x3110
leaq 0x2026(%rip), %rsi      # 0x94b7
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x33d0
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x31d0
leaq -0x28(%rbp), %rdi
callq 0x3100
leaq -0x50(%rbp), %rdi
callq 0x3440
movl %eax, %ebx
leaq -0x368(%rbp), %rdi
callq 0x3070
leaq -0x160(%rbp), %rdi
callq 0x860c
leaq -0x50(%rbp), %rdi
callq 0x3120
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3100
jmp 0x751e
jmp 0x751b
movq %rax, %rbx
jmp 0x752a
movq %rax, %rbx
jmp 0x7536
movq %rax, %rbx
leaq -0x368(%rbp), %rdi
callq 0x3070
leaq -0x160(%rbp), %rdi
callq 0x860c
leaq -0x50(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/Agusyc[P]CTRPG/src/main.cpp
// Function: main
int main() {
    init();

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

        Battle testBattle(enemy, player);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
callq 0x8b00
leaq -0x208(%rbp), %rbx
leaq -0x128(%rbp), %r13
leaq -0x50(%rbp), %r12
leaq -0x280(%rbp), %r14
callq 0x3080
movl %eax, %r15d
callq 0x7418
movl %eax, %ecx
movl %r15d, %eax
cltd
idivl %ecx
movq %rbx, %rdi
movl %edx, %esi
callq 0x7a4f
leaq 0x4787(%rip), %rdi      # 0xd320
movq %rbx, %rsi
callq 0x8ce6
movq %rbx, %rdi
callq 0x6070
movl 0x4731(%rip), %eax      # 0xd2e0
cmpl 0x47ab(%rip), %eax      # 0xd360
jl 0x8b73
cmpl 0x47a7(%rip), %eax      # 0xd364
jg 0x8b73
leaq -0xb0(%rbp), %r15
movq %r15, %rdi
leaq 0x4750(%rip), %rsi      # 0xd320
callq 0x8d2a
movq %r13, %rdi
leaq 0x46c9(%rip), %rsi      # 0xd2a8
callq 0x61ca
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x375c
movq %r13, %rdi
callq 0x6090
movq %r15, %rdi
callq 0x6070
movq %r12, %rdi
leaq 0x9d4(%rip), %rsi       # 0x95e0
leaq -0x29(%rbp), %rdx
callq 0x30c0
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x37fa
leaq 0x467e(%rip), %rdi      # 0xd2a8
movq %r14, %rsi
callq 0x8c96
movq %r14, %rdi
callq 0x6090
movq %r12, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x8d7e
jmp 0x8b73
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3100
jmp 0x8c60
movq %rax, %rbx
leaq -0x208(%rbp), %rdi
callq 0x8d7e
jmp 0x8c8e
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
callq 0x6090
jmp 0x8c82
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x6070
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movl %r8d, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movl %edx, %r14d
movq %rdi, %r15
movq 0x4136(%rip), %r12      # 0xcfd0
movq %r12, %rdi
callq 0x31d0
imull $0x3e8, %r14d, %r13d    # imm = 0x3E8
xorl %eax, %eax
movq 0x40fe(%rip), %rbx      # 0xcfb0
movl %eax, %r14d
cmpq %r14, 0x8(%r15)
jbe 0x8ee7
movq %r15, %rdi
movq %r14, %rsi
callq 0x34e0
movsbl (%rax), %esi
movq %r12, %rdi
callq 0x3280
movq (%rbx), %rdi
callq 0x3290
movl %r13d, %edi
callq 0x3330
leal 0x1(%r14), %eax
jmp 0x8eb2
movq 0x40e2(%rip), %rdi      # 0xcfd0
leaq 0x157(%rip), %rsi       # 0x904c
callq 0x3220
cmpb $0x0, -0x2c(%rbp)
je 0x8f0c
movq 0x40c9(%rip), %rdi      # 0xcfd0
callq 0x3110
movl -0x30(%rbp), %eax
testl %eax, %eax
je 0x8f2c
imull $0x3e8, %eax, %edi      # imm = 0x3E8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3330
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1eaec(%rip), %xmm1    # 0x25004
movss 0x1eae8(%rip), %xmm2    # 0x25008
leaq 0x2fea9(%rip), %rdx     # 0x363d0
ucomiss %xmm4, %xmm0
jbe 0x6575
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 0x6575
movaps %xmm3, %xmm4
jle 0x6527
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x64fb
movl %eax, %ebx
testb %al, %al
je 0x65c0
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
callq 0x71e2
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %edx, %edx
leaq 0x2fe27(%rip), %rsi     # 0x363d0
cmpq %rdx, %rcx
je 0x65c0
movsbq (%rax,%rdx), %rdi
movb (%rdi,%rsi), %dil
movb %dil, (%rax,%rdx)
incq %rdx
jmp 0x65a9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
addl (%rdx), %ecx
xorl %eax, %eax
cmpq 0x8(%rdi), %rax
jae 0x65eb
movq (%rsi), %rdx
movsbl (%rdx,%rax), %edx
cmpl %edx, %ecx
jle 0x65e6
movq (%rdi), %rdx
movb $0x4e, (%rdx,%rax)
incq %rax
jmp 0x65ce
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
xorl %eax, %eax
leaq 0x2fdd2(%rip), %r8      # 0x36450
pushq $0x3
popq %rsi
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
jae 0x66d3
leaq 0x2(%rax), %r9
cmpq %rcx, %r9
jae 0x66ea
movq (%rdi), %rcx
movsbq (%rcx,%rax), %rdx
movsbq 0x1(%rcx,%rax), %r10
movb (%r10,%r8), %r10b
shlb $0x2, %r10b
movsbq 0x2(%rcx,%rax), %r11
movb (%r11,%r8), %r11b
shlb $0x4, %r11b
addb (%rdx,%r8), %r10b
addb %r11b, %r10b
addb $0x3f, %r10b
xorl %edx, %edx
divq %rsi
movb %r10b, (%rcx,%rax)
incq %r9
movq %r9, %rax
jmp 0x6681
xorl %ebx, %ebx
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
pushq $-0x1
popq %rdx
movq %rax, %rsi
callq 0x50c0
jmp 0x6710
movq 0x2f8ff(%rip), %rdi     # 0x35ff0
leaq 0x1e93f(%rip), %rsi     # 0x25037
callq 0x53f0
movq %rax, %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x51c0
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x3, 0x8(%rsi), %rsi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
pushq $0x2d
popq %rdx
callq 0x5470
xorl %ecx, %ecx
movw $0x10, %si
leaq 0x2fd96(%rip), %rdi     # 0x364d5
movb $0x4, %r8b
xorl %r9d, %r9d
cmpq 0x8(%r14), %r9
jae 0x67a6
movq (%r14), %rax
movsbl (%rax,%r9), %eax
addl $-0x3f, %eax
cwtd
idivw %si
movswq %ax, %rax
movb (%rax,%rdi), %al
movq (%rbx), %rdx
movb %al, 0x2(%rdx,%rcx)
movq (%r14), %rax
movsbl (%rax,%r9), %eax
addl $-0x3f, %eax
cwtd
idivw %si
movsbl %dl, %eax
idivb %r8b
movsbl %ah, %edx
movsbq %al, %rax
movb (%rax,%rdi), %al
movq (%rbx), %r10
movb %al, 0x1(%r10,%rcx)
movslq %edx, %rax
movb (%rax,%rdi), %al
movq (%rbx), %rdx
movb %al, (%rdx,%rcx)
incq %r9
addq $0x3, %rcx
jmp 0x6745
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/simonrharris[P]SKA/src/DNA.cpp
// Function: countSequencesinFasta(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
int countSequencesinFasta(const std::string & filename, int & sequenceCount){	
	igzstream gzfileStream;
	gzfileStream.open(filename.c_str());
	if (gzfileStream.get()!='>'){
		std::cerr << "Error: " << filename << " is not in the correct format. Expecting header to start with >." << std::endl << std::endl;
		return 1;
	}
	std::string sequence;
	while (getline(gzfileStream, sequence, '>')){
		sequenceCount++;
	}
	gzfileStream.close();
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x6d0a
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x710e
leaq 0x1b0(%rsp), %r15
movq %r15, %rdi
callq 0x5490
cmpl $0x3e, %eax
jne 0x6bb8
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r14
pushq $0x3e
popq %rbp
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x56e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6bfa
incl (%rbx)
jmp 0x6b99
movq 0x2f431(%rip), %rdi     # 0x35ff0
leaq 0x1e494(%rip), %rsi     # 0x2505a
callq 0x53f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x53a0
leaq 0x1e60c(%rip), %rsi     # 0x251e9
movq %rax, %rdi
callq 0x53f0
movq %rax, %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x51c0
pushq $0x1
popq %rbx
jmp 0x6c10
leaq 0x28(%rsp), %rdi
callq 0x6db4
leaq 0x8(%rsp), %rdi
callq 0x5778
xorl %ebx, %ebx
leaq 0x28(%rsp), %rdi
callq 0x6dea
movl %ebx, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c31
movq %rax, %rbx
jmp 0x6c3e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5778
leaq 0x28(%rsp), %rdi
callq 0x6dea
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq %r14, 0x8(%rdi)
jae 0x6c6b
pushq $0x1
popq %r14
jmp 0x6cda
movq %rdi, %rbx
movslq %esi, %r15
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x5420
movq 0x8(%rbx), %rdx
subq %r15, %rdx
movq %rsp, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x5420
addq 0x8(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55f0
movq 0x8(%rbx), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x5610
xorl %r14d, %r14d
movq %rsp, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5610
movq %rsp, %rdi
callq 0x5778
leaq 0x20(%rsp), %rdi
callq 0x5778
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x6cf7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5778
leaq 0x20(%rsp), %rdi
callq 0x5778
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/simonrharris[P]SKA/src/gzstream.h
// Function: gzstreambuf::gzstreambuf()
gzstreambuf() : opened(0) {
        setp( buffer, buffer + (bufferSize-1));
        setg( buffer + 4,     // beginning of putback area
              buffer + 4,     // read position
              buffer + 4);    // end position      
        // ASSERT: both input & output capabilities will not be used together
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x50f0
leaq 0x2ed58(%rip), %rax     # 0x35c90
movq %rax, (%rbx)
movb $0x0, 0x177(%rbx)
leaq 0x48(%rbx), %rax
leaq 0x176(%rbx), %rcx
movq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x30(%rbx)
leaq 0x4c(%rbx), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6fec
cmpq 0x18(%rbx), %rsi
jae 0x6fec
movzbl (%rsi), %ebp
jmp 0x7056
testb $0x8, 0x178(%rbx)
pushq $-0x1
popq %rbp
je 0x7056
cmpb $0x0, 0x177(%rbx)
je 0x7056
movl 0x8(%rbx), %eax
movl %esi, %ecx
subl %eax, %ecx
pushq $0x4
popq %rax
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 0x5360
movq 0x40(%rbx), %rdi
leaq 0x4c(%rbx), %r15
movq %r15, %rsi
movl $0x12b, %edx            # imm = 0x12B
callq 0x5700
testl %eax, %eax
jle 0x7056
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_O2/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)
pushq $-0x1
popq %rax
je 0x7099
cmpb $0x0, 0x177(%rdi)
je 0x7099
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0x708b
movq 0x28(%rdi), %rax
movb %bl, (%rax)
incq 0x28(%rdi)
callq 0x709a
cmpl $-0x1, %eax
cmovel %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rbx
subq %rsi, %rbx
movq 0x40(%rdi), %rdi
movl %ebx, %edx
callq 0x5590
cmpl %ebx, %eax
jne 0x70c7
movl %ebx, %eax
negl %eax
cltq
addq %rax, 0x28(%r14)
jmp 0x70ca
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq