LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/GAUtils.cpp
// Function: GAUtils::roulete(Population&)
vector<int> GAUtils::roulete(Population &pop){
    double sumFitness{0.0},ctrl{0.0};

    for_each(pop.getPopulation().begin(),pop.getPopulation().end(),[&sumFitness](vector<int> t){sumFitness+=(1.0/(double)getFitness(t));});    

    uniform_real_distribution<double> dist(0,sumFitness);
    ctrl = dist(Globals::urng);

    int i=0;
    for(vector<int> t : pop.getPopulation()){
        ctrl -= (1.0/(double)getFitness(t));
        if(ctrl<=0){
            return(t);
        }
        i++;
    }
    return(pop.getPopulation().back());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb988
movq (%rax), %r15
movq %r14, %rdi
callq 0xb988
movq 0x8(%rax), %r13
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
je 0x7858
movq %r12, %rdi
movq %r15, %rsi
callq 0x9210
movq %r12, %rdi
callq 0xc060
cvtsi2sd %eax, %xmm0
movsd 0x1fab0(%rip), %xmm1    # 0x272e8
divsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x6e4c
addq $0x18, %r15
jmp 0x7814
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rdi)
leaq 0x35056(%rip), %rsi     # 0x3c8c8
callq 0x94d2
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xb988
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x78d9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9210
movq %rbx, %rdi
callq 0xc060
cvtsi2sd %eax, %xmm0
movsd 0x1fa41(%rip), %xmm1    # 0x272f0
divsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x78f1
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6e4c
addq $0x18, %r15
jmp 0x788b
movq %r14, %rdi
callq 0xb988
movq 0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0x9210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
jmp 0x7912
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6e4c
movq %r14, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/GAUtils.cpp
// Function: GAUtils::generateNewPopulation(Population&)
Population GAUtils::generateNewPopulation(Population &pop) {
    if(Config::NEW_POP_TYPE==0){
        return crossOX(pop);
    }else if(Config::NEW_POP_TYPE==1){
        return crossAllxAllwithNBestAndReset(pop);
    }else if(Config::NEW_POP_TYPE==2){
        return crossGPX2WithAntColony(pop);
    }else{
        //default
        return crossAllxAllwithNBestAndReset(pop);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x34e7a(%rip), %rax     # 0x3c7a4
movl (%rax), %eax
cmpl $0x2, %eax
je 0x794e
cmpl $0x1, %eax
je 0x7944
testl %eax, %eax
jne 0x7944
movq %rbx, %rdi
callq 0x795b
jmp 0x7956
movq %rbx, %rdi
callq 0x7ae2
jmp 0x7956
movq %rbx, %rdi
callq 0x7d79
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/GAUtils.cpp
// Function: GAUtils::crossOX(Population&)
Population GAUtils::crossOX(Population &pop){
    Population newPop;
    for(vector<int> vec : elitsm(pop)){
        newPop.getPopulation().push_back(vec);
    }
    
    while(newPop.getPopulation().size()<Config::POP_SIZE){
        newPop.getPopulation().push_back(OX::crossover(roulete(pop),roulete(pop)));
    }

    return newPop;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xb97c
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x9506
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x87f1
leaq 0x18(%rsp), %rdi
callq 0x6dde
movq (%rsp), %r15
movq 0x8(%rsp), %r13
leaq 0x60(%rsp), %r12
cmpq %r13, %r15
je 0x79d7
movq %r12, %rdi
movq %r15, %rsi
callq 0x9210
movq %rbx, %rdi
callq 0xb988
movq %rax, %rdi
movq %r12, %rsi
callq 0x938a
movq %r12, %rdi
callq 0x6e4c
addq $0x18, %r15
jmp 0x79a6
movq %rsp, %r15
movq %r15, %rdi
callq 0x6dde
leaq 0x48(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %rbx, %rdi
callq 0xb988
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movq %rcx, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
leaq 0x34eb3(%rip), %rcx     # 0x3c8c0
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x7a68
movq %rbx, %rdi
callq 0xb988
movq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
callq 0x77dc
movq %r13, %rdi
movq %r14, %rsi
callq 0x77dc
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x26778
movq %rbp, %rdi
movq %r15, %rsi
callq 0x9b6a
movq %r15, %rdi
callq 0x6e4c
movq %r13, %rdi
callq 0x6e4c
movq %r12, %rdi
callq 0x6e4c
jmp 0x79ec
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
jmp 0x7ac8
jmp 0x7acf
movq %rax, %r14
movq %rsp, %rdi
callq 0x6e4c
jmp 0x7a96
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x6e4c
jmp 0x7aa7
jmp 0x7acf
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x6e4c
jmp 0x7ad2
movq %rax, %r14
jmp 0x7ac5
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x6e4c
movq %rsp, %rdi
callq 0x6dde
jmp 0x7ad2
movq %rax, %r14
movq %rbx, %rdi
callq 0x6dde
movq %r14, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/GAUtils.cpp
// Function: GAUtils::crossAllxAll(Population&)
Population GAUtils::crossAllxAll(Population &pop) {
    Population newPop;
    vector<int> currentTour;

    for (unsigned i = 0; i < Config::POP_SIZE; i++) {
        currentTour = pop.getPopulation()[i];
        for (unsigned j = 0; j < Config::POP_SIZE; j++) {
            if (i != j) {
                vector<int> t = GPX2::crossover(pop.getPopulation()[j], currentTour);
                if (getFitness(t) < getFitness(currentTour)) {
                    currentTour = t;
                }
            }
        }

        newPop.getPopulation().push_back(currentTour);
    }

    return newPop;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
callq 0xb97c
leaq 0x10(%rsp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
xorl %ebp, %ebp
leaq 0x58(%rsp), %rbx
leaq 0x40(%rsp), %r13
leaq 0x70(%rsp), %r14
xorl %r15d, %r15d
leaq 0x34819(%rip), %rax     # 0x3c8c0
movl (%rax), %eax
cmpq %rax, %r15
jae 0x81cc
movq 0x8(%rsp), %rdi
callq 0xb988
imulq $0x18, %r15, %rsi
addq (%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0x93b6
movq %r15, 0x28(%rsp)
leaq 0x347e7(%rip), %rax     # 0x3c8c0
movl (%rax), %eax
xorl %r12d, %r12d
xorl %edx, %edx
movq %rbp, 0x30(%rsp)
movl %eax, %ecx
cmpq %rcx, %rdx
jae 0x81a5
movq %rdx, %r15
cmpq %r12, %rbp
je 0x8196
movq 0x8(%rsp), %rdi
callq 0xb988
movq (%rax), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x9210
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
callq 0x9210
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1f198
movq %r12, 0x38(%rsp)
movq %r13, %rbp
movq %r13, %rdi
callq 0x6e4c
movq %rbx, %r13
movq %rbx, %rdi
callq 0x6e4c
movq %r14, %r12
movq %r14, %rdi
callq 0xc060
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0xc060
cmpl %eax, %ebx
jge 0x8172
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x93b6
movq %r12, %r14
movq %r12, %rdi
callq 0x6e4c
leaq 0x3473c(%rip), %rax     # 0x3c8c0
movl (%rax), %eax
movq %r13, %rbx
movq %rbp, %r13
movq 0x30(%rsp), %rbp
movq 0x38(%rsp), %r12
movq %r15, %rdx
incq %rdx
addq $0x18, %r12
jmp 0x80e5
movq (%rsp), %rdi
callq 0xb988
movq 0x28(%rsp), %r15
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x938a
incq %r15
addq $0x18, %rbp
jmp 0x80a0
leaq 0x10(%rsp), %rdi
callq 0x6e4c
movq (%rsp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8207
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x6e4c
jmp 0x8200
movq %rax, %r14
leaq 0x58(%rsp), %rdi
jmp 0x8214
movq %rax, %r14
jmp 0x8219
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x6e4c
leaq 0x10(%rsp), %rdi
callq 0x6e4c
movq (%rsp), %rdi
callq 0x6dde
movq %r14, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/GAUtils.cpp
// Function: GAUtils::crossNBestxAllwithReset(Population&)
Population GAUtils::crossNBestxAllwithReset(Population &pop) {
    Population newPop;

    sort(pop.getPopulation().begin(), pop.getPopulation().end(),sortPopulation);

    for (unsigned i = 0; i < Config::N_BEST; i++) {
        vector<int> savedTour = pop.getPopulation()[i];
        for (vector<int> t : pop.getPopulation()) {
            vector<int> tmp = GPX2::crossover(savedTour, t);
            savedTour = tmp;
        }
        newPop.getPopulation().push_back(savedTour);
    }

    fillPopulationWithReset(newPop, Config::POP_SIZE*Config::RESET_PERCENTAGE);

    fillPopulationWithRoulete(pop,newPop,Config::POP_SIZE-newPop.getPopulation().size());
    
    return (newPop);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
callq 0xb97c
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0xb988
movq (%rax), %rbx
movq 0x10(%rsp), %rdi
callq 0xb988
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x8442
xorl %ecx, %ecx
leaq 0x80(%rsp), %r12
leaq 0x50(%rsp), %r13
leaq 0x38(%rsp), %rbp
leaq 0x68(%rsp), %rbx
leaq 0x34508(%rip), %rax     # 0x3c7a0
movl (%rax), %eax
movq %rcx, 0x18(%rsp)
cmpq %rax, %rcx
jae 0x836e
movq 0x10(%rsp), %rdi
callq 0xb988
imulq $0x18, 0x18(%rsp), %rsi
addq (%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x9210
movq 0x10(%rsp), %rdi
callq 0xb988
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x833f
movq %r12, %rdi
movq %r14, %rsi
callq 0x9210
movq %r13, %rdi
leaq 0x20(%rsp), %rsi
callq 0x9210
movq %rbp, %rdi
movq %r12, %rsi
callq 0x9210
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1f198
movq %rbp, %rdi
callq 0x6e4c
movq %r13, %rdi
callq 0x6e4c
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x93b6
movq %rbx, %rdi
callq 0x6e4c
movq %r12, %rdi
callq 0x6e4c
addq $0x18, %r14
jmp 0x82d6
movq 0x8(%rsp), %rdi
callq 0xb988
leaq 0x20(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x938a
movq %r14, %rdi
callq 0x6e4c
movq 0x18(%rsp), %rcx
incq %rcx
jmp 0x8291
leaq 0x3454b(%rip), %rbx     # 0x3c8c0
movl (%rbx), %eax
cvtsi2sd %rax, %xmm0
leaq 0x3442d(%rip), %rax     # 0x3c7b0
mulsd (%rax), %xmm0
cvttsd2si %xmm0, %rsi
movq 0x8(%rsp), %rdi
callq 0x730d
movl (%rbx), %ebx
movq 0x8(%rsp), %rdi
callq 0xb988
movq 0x8(%rax), %rcx
subq (%rax), %rcx
pushq $-0x18
popq %rsi
movq %rcx, %rax
cqto
idivq %rsi
addl %eax, %ebx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %ebx, %edx
callq 0x776f
movq 0x8(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x83e4
jmp 0x8423
jmp 0x8423
movq %rax, %rbx
jmp 0x8430
movq %rax, %rbx
jmp 0x8414
movq %rax, %rbx
jmp 0x8400
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6e4c
leaq 0x50(%rsp), %rdi
jmp 0x840f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6e4c
leaq 0x80(%rsp), %rdi
callq 0x6e4c
jmp 0x8426
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6e4c
movq 0x8(%rsp), %rdi
callq 0x6dde
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/Log.cpp
// Function: Log::printTime(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
void Log::printTime(ostream &out, string txt, double milli){
    out << "\n"+txt+"\n";
    out << "\t" << milli << " milliseconds.\n";
    out << "\t" << (milli/=1000.0) << " seconds.\n";
    out << "\t" << (milli/=60.0) << " minutes.\n";
    out.flush();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x1d8bf(%rip), %r14     # 0x287d6
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb6ee
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb5c3
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5330
leaq 0x10(%rsp), %rdi
callq 0x56f8
leaq 0x30(%rsp), %rdi
callq 0x56f8
leaq 0x1d9e6(%rip), %r14     # 0x28945
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5370
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x5560
leaq 0x1c65b(%rip), %rsi     # 0x275da
movq %rax, %rdi
callq 0x5370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5370
movsd 0x8(%rsp), %xmm0
divsd 0x1c458(%rip), %xmm0    # 0x273f8
movsd %xmm0, 0x8(%rsp)
movq %rax, %rdi
callq 0x5560
leaq 0x1c635(%rip), %rsi     # 0x275ea
movq %rax, %rdi
callq 0x5370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5370
movsd 0x8(%rsp), %xmm0
divsd 0x1c42a(%rip), %xmm0    # 0x27400
movq %rax, %rdi
callq 0x5560
leaq 0x1c610(%rip), %rsi     # 0x275f5
movq %rax, %rdi
callq 0x5370
movq %rbx, %rdi
callq 0x5290
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x56f8
jmp 0xb011
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/Log.cpp
// Function: Log::printTourFile(std::vector<int, std::allocator<int>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::printTourFile(vector<int> &tour,string name){
    string fileName{name+".txt"};
    ofstream file(fileName);

    if(file.is_open()){
        printTour(tour,file);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x1c5c9(%rip), %rdx     # 0x27600
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xb764
leaq 0x28(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x56b0
leaq 0x98(%rsp), %rdi
callq 0x50c0
testb %al, %al
je 0xb072
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xc0f3
leaq 0x28(%rsp), %rdi
callq 0x5510
leaq 0x8(%rsp), %rdi
callq 0x56f8
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5510
jmp 0xb0a3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/Population.cpp
// Function: Population::getBestTour()
vector<int>& Population::getBestTour(){
    int min = numeric_limits<int>::max(), fitness{ 0 },index{-1};
    for(unsigned i=0;i<population.size();i++){
        fitness = getFitness(population[i]);
        if(min>fitness){
            min = fitness;
            index = i;
        }
    }
    return (population[index]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
pushq $-0x1
popq %rbp
movl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
pushq $0x18
popq %r15
movl %eax, %r12d
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r15
cmpq %r12, %rax
jbe 0xba3f
imulq $0x18, %r12, %rax
addq %rax, %rdi
callq 0xc060
cmpl %eax, %r14d
cmovgel %eax, %r14d
cmovgl %r12d, %ebp
leal 0x1(%r12), %eax
jmp 0xba0a
movslq %ebp, %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq %rdi, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/Population.cpp
// Function: operator<<(std::ostream&, Population&)
ostream& operator<<(ostream& output, Population& pop)
{ // Overload de operador para impressão da população
    int i{ 0 };
    for (vector<int> t : pop.getPopulation()) {
        // output << "Tour " << i << "\n";
        // printTour(t,output);
        output<<"Tour "<<i<<" "<<getFitness(t);
        output<<"\n";
        ++i;
    }
    return (output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
xorl %ebp, %ebp
movq %rsp, %r15
cmpq %r12, %r14
je 0xbade
movq %r15, %rdi
movq %r14, %rsi
callq 0x9210
movq %rbx, %rdi
leaq 0x1bc4d(%rip), %rsi     # 0x276d9
callq 0x5370
movq %rax, %rdi
movl %ebp, %esi
callq 0x55e0
movq %rax, %rdi
leaq 0x1b8c3(%rip), %rsi     # 0x27368
callq 0x5370
movq %rax, %r13
movq %r15, %rdi
callq 0xc060
movq %r13, %rdi
movl %eax, %esi
callq 0x55e0
movq %rbx, %rdi
leaq 0x1cd0d(%rip), %rsi     # 0x287d6
callq 0x5370
incl %ebp
movq %r15, %rdi
callq 0x6e4c
addq $0x18, %r14
jmp 0xba72
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6e4c
movq %rbx, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/Coordinates.cpp
// Function: Coordinates::getCityById(int)
City Coordinates::getCityById(const int id)
{
    auto it = find_if(cityList.begin(), cityList.end(), [&id](const City& obj) { return (obj.getId() == id); });
    if (it != cityList.end()) {
        return (*it);
    } else {
        return (City());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x24(%rsp), %rax
movl %edx, (%rax)
movq (%rsi), %rbx
movq 0x8(%rsi), %r13
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %r13, 0x18(%rsp)
subq %rbx, %r13
pushq $0x18
popq %rcx
movq %r13, %rax
cqto
idivq %rcx
movq %rax, %rbp
sarq $0x2, %rbp
testq %rbp, %rbp
jle 0xbc2b
movq %r12, %rdi
movq %rbx, %rsi
callq 0xbce0
testb %al, %al
jne 0xbc78
leaq 0x18(%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xbce0
testb %al, %al
jne 0xbc7b
leaq 0x30(%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xbce0
testb %al, %al
jne 0xbc7b
leaq 0x48(%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xbce0
testb %al, %al
jne 0xbc7b
addq $0x60, %rbx
decq %rbp
addq $-0x60, %r13
jmp 0xbbc9
movq %r13, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq $0x1, %rax
je 0xbcb4
cmpq $0x2, %rax
movq 0x8(%rsp), %r12
je 0xbc62
cmpq $0x3, %rax
jne 0xbcbb
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xbce0
testb %al, %al
jne 0xbc73
addq $0x18, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xbce0
testb %al, %al
je 0xbcc2
movq %rbx, %r15
jmp 0xbc80
movq %rbx, %r15
movq 0x8(%rsp), %r12
cmpq 0x8(%r14), %r15
je 0xbc9a
movq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movups (%r15), %xmm0
movups %xmm0, (%r12)
jmp 0xbca2
movq %r12, %rdi
callq 0xc5e4
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r12
jmp 0xbcc6
movq 0x18(%rsp), %r15
jmp 0xbc80
addq $0x18, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xbce0
testb %al, %al
movq 0x18(%rsp), %r15
cmovneq %rbx, %r15
jmp 0xbc80
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/Utils.cpp
// Function: getFitness(std::vector<int, std::allocator<int>> const&)
int getFitness(const vector<int> &t)
{ // Calculate fitness of tour
    int sum{0};
    unsigned size{(unsigned)t.size()};
    for(unsigned i=0; i<size; i++){
        sum += distance(t[i], t[(i+1)%size]);
    }
    return(sum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x2, %rax
movl %eax, %r15d
negq %r15
xorl %r14d, %r14d
pushq $0x1
popq %r12
leaq (%r15,%r12), %rax
cmpq $0x1, %rax
je 0xc0b7
movq (%rbx), %rax
movl -0x4(%rax,%r12,4), %edi
movq %r15, %rcx
addq %r12, %rcx
movl %r12d, %ecx
movl $0x0, %edx
cmovneq %rcx, %rdx
movl (%rax,%rdx,4), %esi
callq 0xc0c6
addl %eax, %r14d
incq %r12
jmp 0xc083
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/Utils.cpp
// Function: printTour(std::vector<int, std::allocator<int>> const&, std::ostream&)
ostream& printTour(const vector<int> &t, ostream &output){
    for (int cityId : t) {
        output << cityId << " " <<Globals::map.getCityById(cityId).getX()<<" "<<Globals::map.getCityById(cityId).getY()<<"\n";
    }
    output << "\nFitness: " << getFitness(t) << "\n";
    output.flush();
    return (output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, (%rsp)
movq (%rdi), %r15
movq %rdi, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
cmpq 0x10(%rsp), %r15
je 0xc1b8
movl (%r15), %r14d
movq (%rsp), %rdi
movl %r14d, %esi
callq 0x55e0
movq %rax, %rdi
leaq 0x1b22e(%rip), %r13     # 0x27368
movq %r13, %rsi
callq 0x5370
movq %rax, %rbx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
leaq 0x31afc(%rip), %r12     # 0x3dc50
movq %r12, %rsi
movl %r14d, %edx
callq 0xbb82
movq %rbp, %rdi
callq 0xc5fe
movq %rbx, %rdi
callq 0x5560
movq %rax, %rdi
movq %r13, %rsi
callq 0x5370
movq %rax, %rbx
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0xbb82
movq %r13, %rdi
callq 0xc604
movq %rbx, %rdi
callq 0x5560
movq %rax, %rdi
leaq 0x1c62c(%rip), %rsi     # 0x287d6
callq 0x5370
addq $0x4, %r15
jmp 0xc116
leaq 0x1b579(%rip), %rsi     # 0x27738
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x5370
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xc060
movq %r14, %rdi
movl %eax, %esi
callq 0x55e0
leaq 0x1c5ed(%rip), %rsi     # 0x287d6
movq %rax, %rdi
callq 0x5370
movq %rbx, %rdi
callq 0x5290
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/Utils.cpp
// Function: ATT(int, int)
int ATT(int p1,int p2){
    City c1{Globals::map.getCityById(p1)},c2{Globals::map.getCityById(p2)};
    double dX{c1.getX() - c2.getX()},dY{c1.getY()-c2.getY()},rij,tij;
    rij = sqrt((dX*dX + dY*dY)/10.0);
    tij = round(rij);

    return(tij<rij?(tij+1):tij);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movl %edi, %edx
leaq 0x31733(%rip), %r14     # 0x3dc50
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xbb82
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xbb82
movq %r15, %rdi
callq 0xc5fe
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0xc5fe
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
callq 0xc604
movsd %xmm0, 0x10(%rsp)
movq %r12, %rdi
callq 0xc604
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
divsd 0x1b191(%rip), %xmm0    # 0x27730
sqrtsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x5180
movsd 0x1ad32(%rip), %xmm1    # 0x272e8
addsd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpltsd 0x8(%rsp), %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/City.cpp
// Function: City::operator=(City const&)
const City& City::operator=(const City& c)
{ // Overload de atribuição city=city
    this->x = c.getX();
    this->y = c.getY();
    this->id = c.getId();
    return (c);
}

// Assembly:
movq %rsi, %rax
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
movl (%rsi), %ecx
movl %ecx, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::setEdge_Type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ImportData::setEdge_Type(string type){
    if(!type.compare("EUC_2D")){
        Config::TYPE = Config::type::EUC_2D;
    }else if(!type.compare("GEO")){
        Config::TYPE = Config::type::GEO;
    }else if(!type.compare("ATT")){
        Config::TYPE = Config::type::ATT;
    }else{
        cout<<"Unknown edge type."<<endl;
        exit(0);
    }

}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x1aa88(%rip), %rsi     # 0x2795d
movq %rbx, %rdi
callq 0x5110
testl %eax, %eax
je 0xcf0b
leaq 0x1aa7c(%rip), %rsi     # 0x27964
movq %rbx, %rdi
callq 0x5110
testl %eax, %eax
je 0xcf0f
leaq 0x1aa6d(%rip), %rsi     # 0x27968
movq %rbx, %rdi
callq 0x5110
testl %eax, %eax
jne 0xcf1d
pushq $0x2
jmp 0xcf11
xorl %eax, %eax
jmp 0xcf12
pushq $0x1
popq %rax
leaq 0x2f94f(%rip), %rcx     # 0x3c868
movl %eax, (%rcx)
popq %rbx
retq
movq 0x2f07c(%rip), %rdi     # 0x3bfa0
leaq 0x1aa41(%rip), %rsi     # 0x2796c
callq 0x5370
movq %rax, %rdi
callq 0x51c0
xorl %edi, %edi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::printInfos()
void ImportData::printInfos()
{
    cout << "Nome: " << gettspName() << endl;
    cout << "Tipo: " << getType() << endl;
    cout << "Comentário: " << getcomment() << endl;
    cout << "Tipo do Vértice: " << getedge_type() << endl;
    cout << "Comentário do tipo de node: " << getnode_comment() << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x2f04d(%rip), %rdi     # 0x3bfa0
leaq 0x1a9af(%rip), %rsi     # 0x27909
callq 0x5370
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x54a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5330
movq %rax, %rdi
callq 0x51c0
movq %rsp, %rdi
callq 0x56f8
movq 0x2f00e(%rip), %rdi     # 0x3bfa0
leaq 0x1a977(%rip), %rsi     # 0x27910
callq 0x5370
movq %rax, %r14
leaq 0x20(%rbx), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x54a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5330
movq %rax, %rdi
callq 0x51c0
movq %rsp, %rdi
callq 0x56f8
movq 0x2efce(%rip), %rdi     # 0x3bfa0
leaq 0x1a93e(%rip), %rsi     # 0x27917
callq 0x5370
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd0d2
movq %r14, %rdi
movq %r15, %rsi
callq 0x5330
movq %rax, %rdi
callq 0x51c0
movq %rsp, %rdi
callq 0x56f8
movq 0x2ef8f(%rip), %rdi     # 0x3bfa0
leaq 0x1a90d(%rip), %rsi     # 0x27925
callq 0x5370
movq %rax, %r14
leaq 0x60(%rbx), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x54a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5330
movq %rax, %rdi
callq 0x51c0
movq %rsp, %rdi
callq 0x56f8
movq 0x2ef4f(%rip), %rdi     # 0x3bfa0
leaq 0x1a8e0(%rip), %rsi     # 0x27938
callq 0x5370
movq %rax, %r14
subq $-0x80, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x54a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5330
movq %rax, %rdi
callq 0x51c0
movq %rsp, %rdi
callq 0x56f8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd09f
jmp 0xd09f
jmp 0xd09f
jmp 0xd09f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::explode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> ImportData::explode(std::string const & s, char delim)
{
    std::vector<std::string> result;
    std::istringstream iss(s);

    for (std::string token; std::getline(iss, token, delim); )
    {
        result.push_back(std::move(token));
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %ecx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rax
movq %rdx, %rsi
movl %eax, %edx
callq 0x55b0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5640
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xd8c6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1940c
jmp 0xd89e
leaq 0x8(%rsp), %rdi
callq 0x56f8
leaq 0x28(%rsp), %rdi
callq 0x51b0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xd907
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x56f8
leaq 0x28(%rsp), %rdi
callq 0x51b0
movq %rbx, %rdi
callq 0x709c
movq %r14, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
vector<string> Arg::split(const string s, char c) {
    vector<string> tokens;
    string token;
    istringstream tokenStream(s);
    while (getline(tokenStream, token, c)) {
        if (!token.empty()) {
            tokens.push_back(token);
        }
    }
    return tokens;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %ecx, %ebp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rax
movq %rdx, %rsi
movl %eax, %edx
callq 0x55b0
movsbl %bpl, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5640
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x196fa
cmpq $0x0, 0x10(%rsp)
je 0x196ca
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14efa
jmp 0x196ca
leaq 0x28(%rsp), %rdi
callq 0x51b0
leaq 0x8(%rsp), %rdi
callq 0x56f8
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x19731
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x51b0
leaq 0x8(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x709c
movq %r14, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::validateArguments()
void Arg::validateArguments(){
    //programmer error, name or alias repeated
    nameConflict();
    
    processInput();
    if(helpSetted && isSet("help")){
        throw std::runtime_error(help());
    }else{
        processRequired();
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
callq 0x19822
movq %r14, %rdi
callq 0x19aaa
cmpb $0x1, 0x48(%r14)
jne 0x1979c
leaq 0xf007(%rip), %rsi      # 0x28779
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x6cfa
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x19e2a
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x56f8
testb %bl, %bl
jne 0x197ad
movq %r14, %rdi
callq 0x19f9e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51d0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x19e82
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5570
xorl %ebp, %ebp
movq 0x22816(%rip), %rsi     # 0x3bff0
movq 0x227a7(%rip), %rdx     # 0x3bf88
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rsp, %rdi
callq 0x56f8
testb %bpl, %bpl
jne 0x197fe
jmp 0x1981a
movq %rax, %r14
movq %rbx, %rdi
callq 0x52c0
jmp 0x1981a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x56f8
jmp 0x1981a
movq %rax, %r14
movq %r14, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::isSet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Arg::isSet(string arg){
    Argument *a = getArgument(arg);
    if(a!=nullptr){
        return(a->isSet());
    }
    return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x54a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a192
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56f8
testq %rbx, %rbx
je 0x19e63
movb 0x39(%rbx), %al
jmp 0x19e65
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::help[abi:cxx11]()
string Arg::help(){
    string tmp{};

    tmp += programName+"\n\n";
    tmp += "Options:\n";

    for(Argument a : arguments){
        tmp += a.to_string();
        tmp += "\n\n";
    }

    return(tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
addq $0x28, %rsi
leaq 0xe921(%rip), %rdx      # 0x287d5
leaq 0x28(%rsp), %rdi
callq 0xb764
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x56c0
leaq 0x28(%rsp), %rdi
callq 0x56f8
leaq 0xe8fc(%rip), %rsi      # 0x287d8
movq %rbx, %rdi
callq 0x5690
movq (%r15), %r14
movq 0x8(%r15), %rbp
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0xe8d9(%rip), %r13      # 0x287d5
cmpq %rbp, %r14
je 0x19f43
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a4e2
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a542
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56c0
movq %r12, %rdi
callq 0x56f8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5690
movq %r15, %rdi
callq 0x707c
addq $0x60, %r14
jmp 0x19efc
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19f6b
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x56f8
jmp 0x19f8e
jmp 0x19f6b
movq %rax, %r14
jmp 0x19f8e
jmp 0x19f81
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x56f8
jmp 0x19f84
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x707c
movq %rbx, %rdi
callq 0x56f8
movq %r14, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::processRequired()
void Arg::processRequired(){
    bool error{false};
    string errorMsg{""};
    for(Argument a : arguments){
        if(a.getRequired() && a.getOption().empty()){
            if(error){
                errorMsg += "\n";
            }
            error = true;
            errorMsg += "Required argument: "+a.getArg()[0];
        }
    }
    throwException(errorMsg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
leaq 0xe98d(%rip), %rsi      # 0x28946
leaq 0x10(%rsp), %rdi
leaq 0x88(%rsp), %r15
movq %r15, %rdx
callq 0x6cfa
movq (%rbx), %r12
movq %rbx, 0x8(%rsp)
movq 0x8(%rbx), %r14
xorl %ebx, %ebx
leaq 0x68(%rsp), %rbp
cmpq %r14, %r12
je 0x1a08a
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a4e2
cmpb $0x1, 0xc0(%rsp)
jne 0x1a079
movq %rbp, %rdi
leaq 0xc8(%rsp), %rsi
callq 0x54a0
movq 0x70(%rsp), %r13
movq %rbp, %rdi
callq 0x56f8
testq %r13, %r13
jne 0x1a079
testb $0x1, %bl
je 0x1a037
leaq 0x10(%rsp), %rdi
leaq 0xe7a4(%rip), %rsi      # 0x287d6
callq 0x5690
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x12b1e
movq 0x30(%rsp), %rdx
movq %rbp, %rdi
leaq 0xe72b(%rip), %rsi      # 0x2877e
callq 0xb6ee
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x56c0
movq %rbp, %rdi
callq 0x56f8
leaq 0x30(%rsp), %rdi
callq 0x709c
movb $0x1, %bl
movq %r15, %rdi
callq 0x707c
addq $0x60, %r12
jmp 0x19fe1
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x54a0
leaq 0x48(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x1a128
leaq 0x48(%rsp), %rdi
callq 0x56f8
leaq 0x10(%rsp), %rdi
callq 0x56f8
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x56f8
jmp 0x1a116
jmp 0x1a113
jmp 0x1a101
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x56f8
jmp 0x1a0f3
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x709c
jmp 0x1a104
jmp 0x1a101
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x707c
jmp 0x1a116
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::getArgument(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Arg::Argument* Arg::getArgument(string arg){
    vector<string> argV = split(arg,'|');
    for(string s : argV){
        for(Argument &a : arguments){
            for(string name : a.getArg()){
                if(name == s){
                    return(&a);
                } 
            }
        }
    }
    
    return(nullptr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x54a0
leaq 0x40(%rsp), %rdi
pushq $0x7c
popq %rcx
movq %rbx, %rdx
callq 0x1967c
leaq 0x58(%rsp), %rdi
callq 0x56f8
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%rsp), %r12
leaq 0x98(%rsp), %rbp
cmpq 0x10(%rsp), %rsi
je 0x1a2a7
movq %r12, %rdi
movq %rsi, 0x18(%rsp)
callq 0x54a0
movq 0x8(%rsp), %rax
movq (%rax), %r15
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq 0x20(%rsp), %r15
je 0x1a286
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x12b1e
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %r13
movq %rax, %rbx
cmpq %r13, %rax
je 0x1a26e
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x54a0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x12711
movl %eax, %r14d
movq %rbp, %rdi
callq 0x56f8
leaq 0x20(%rbx), %rax
testb %r14b, %r14b
je 0x1a232
pushq $0x1
popq %r14
movq %r15, (%rsp)
jmp 0x1a271
xorl %r14d, %r14d
leaq 0x28(%rsp), %rdi
callq 0x709c
addq $0x60, %r15
cmpq %r13, %rbx
je 0x1a214
jmp 0x1a28a
pushq $0x4
popq %r14
movq %r12, %rdi
callq 0x56f8
movq 0x18(%rsp), %rsi
addq $0x20, %rsi
testb $0x3, %r14b
je 0x1a1eb
jmp 0x1a2af
movq $0x0, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x709c
movq (%rsp), %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x56f8
jmp 0x1a309
movq %rax, %rbx
jmp 0x1a2ff
movq %rax, %rbx
jmp 0x1a2f5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x709c
leaq 0x78(%rsp), %rdi
callq 0x56f8
leaq 0x40(%rsp), %rdi
callq 0x709c
movq %rbx, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::getOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Arg::getOption(string arg){
    Argument *a = getArgument(arg);
    if(a!=nullptr){
        return(a->getOption());
    }
    return {};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x54a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a192
movq %rax, %r14
movq %rsp, %rdi
callq 0x56f8
testq %r14, %r14
je 0x1a35b
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54a0
jmp 0x1a36b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/args/Arg.hpp
// Function: Arg::Argument::to_string[abi:cxx11]()
string to_string(){
                    string tmp{};
                    for(unsigned i=0;i<arg.size();i++){
                        tmp += arg[i];
                        if(i+1 != arg.size()){
                            tmp += "|";
                        }
                    }
                    tmp += ((required)?("\n\tRequired."):(""));
                    tmp += "\n\tDescription: "+((description.empty())?("no description."):(description));
                    return(tmp);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
pushq $0x1
popq %r12
leaq 0xd45f(%rip), %r15      # 0x279cd
leal -0x1(%r12), %eax
movq (%r14), %rsi
movq 0x8(%r14), %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
cmpq %rax, %rcx
jbe 0x1a5b8
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x56c0
movl %r12d, %eax
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x5, %rcx
cmpq %rax, %rcx
je 0x1a5b3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5690
incl %r12d
jmp 0x1a56e
leaq 0xe26e(%rip), %rax      # 0x2882d
leaq 0xe380(%rip), %rsi      # 0x28946
cmpb $0x0, 0x38(%r14)
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x5690
movq 0x20(%r14), %r15
testq %r15, %r15
je 0x1a5f3
addq $0x18, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x54a0
jmp 0x1a609
leaq 0xe24f(%rip), %rsi      # 0x28849
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6cfa
leaq 0xe229(%rip), %rsi      # 0x28839
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xb668
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x56c0
leaq 0x28(%rsp), %rdi
callq 0x56f8
leaq 0x8(%rsp), %rdi
callq 0x56f8
testq %r15, %r15
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x56f8
jmp 0x1a664
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x56f8
jmp 0x1a673
movq %rax, %r14
testq %r15, %r15
jmp 0x1a67d
jmp 0x1a67a
movq %rax, %r14
movq %rbx, %rdi
callq 0x56f8
movq %r14, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/opt/Opt.cpp
// Function: Opt::optimize(std::vector<int, std::allocator<int>>&)
vector<int> Opt::optimize(vector<int> &tour){
    Opt obj;

    bool run{false};
    long unsigned int routeSize{tour.size()};
    do{
        run = false;
        for(unsigned i=1;i<routeSize-2;i++){
            edge baseEdge(i-1,i);
            for(unsigned j=i+1;j<routeSize-1;j++){
                edge comparingEdge(j,j+1);
                if(!obj.adjacent(baseEdge,comparingEdge)){
                    if(obj.isBetter(baseEdge,comparingEdge,tour)){
                        reverse(tour.begin()+baseEdge.second,tour.begin()+comparingEdge.first+1);
                        run = true;
                        break;
                    }
                }
            }
            if(run){
                break;
            }
        }
    }while(run);

    return(tour);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
movq 0x8(%rsi), %r13
subq (%rsi), %r13
sarq $0x2, %r13
leaq -0x2(%r13), %rax
movq %rax, 0x20(%rsp)
decq %r13
pushq $0x1
popq %rax
movl %eax, %ebx
movl %ebx, %eax
cmpq %rax, 0x20(%rsp)
jbe 0x1af66
leal -0x1(%rbx), %eax
movl %eax, 0x10(%rsp)
movl %ebx, 0x14(%rsp)
leal 0x2(%rbx), %ebp
pushq $-0x1
popq %rax
leal -0x1(%rbp), %r15d
cmpq %r15, %r13
jbe 0x1af43
movl %r15d, 0x8(%rsp)
movl %ebp, 0xc(%rsp)
leal -0x1(%rax), %r12d
testl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
je 0x1af3c
testl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
je 0x1af3c
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rcx
callq 0x1afaa
testb %al, %al
jne 0x1af47
incl %ebp
movl %r12d, %eax
jmp 0x1af00
incl %ebx
jmp 0x1aee6
movq (%r14), %rax
movslq %ebx, %rcx
leaq (%rax,%rcx,4), %rdi
movslq %r15d, %rcx
leaq (%rax,%rcx,4), %rsi
addq $0x4, %rsi
callq 0x1b02a
jmp 0x1aee1
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/AntColony/Ant.cpp
// Function: Ant::calcChance(int)
double Ant::calcChance(int nextCity){
    double pheromoneNext = AntMap::getPheromoneLevel(path.back(),nextCity);
    double niNext = 1.0/distance(path.back(),nextCity);
    double top = ((pow(pheromoneNext,AntConstants::alfa))*(pow(niNext,AntConstants::beta)));

    double bottom = 0.0;
    {
        double pheromoneTmp = 0.0;
        double niTmp = 0.0;
        for(unsigned city : Globals::map.getCityList()){
            if(find(path.begin(),path.end(),city) == path.end()){
                pheromoneTmp = AntMap::getPheromoneLevel(path.back(),city);
                niTmp = 1.0/distance(path.back(),city);
                bottom += ((pow(pheromoneTmp,AntConstants::alfa))*(pow(niTmp,AntConstants::beta)));
            }
        }   
    }
    return top/bottom;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl -0x4(%rax), %edi
callq 0x1ba24
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rbx), %rax
movl -0x4(%rax), %edi
movl %ebp, %esi
callq 0xc0c6
cvtsi2sd %eax, %xmm0
movsd 0xc219(%rip), %xmm1     # 0x272e8
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x216e0(%rip), %r15     # 0x3c7c0
movsd (%r15), %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x55f0
movsd %xmm0, 0x18(%rsp)
leaq 0x216cb(%rip), %r12     # 0x3c7c8
movsd (%r12), %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x55f0
movsd %xmm0, 0x20(%rsp)
leaq 0x22b35(%rip), %rsi     # 0x3dc50
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0xbb16
movq (%r14), %r13
movq 0x8(%r14), %rbp
xorpd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x4(%rsp), %r14
cmpq %rbp, %r13
je 0x1b1e5
movl (%r13), %eax
movl %eax, 0x4(%rsp)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x1b7ad
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x1b1dc
movl -0x4(%rcx), %edi
movl 0x4(%rsp), %esi
callq 0x1ba24
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movl -0x4(%rax), %edi
movl 0x4(%rsp), %esi
callq 0xc0c6
cvtsi2sd %eax, %xmm0
movsd 0xc153(%rip), %xmm1     # 0x272e8
divsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
movsd (%r15), %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x55f0
movsd %xmm0, 0x8(%rsp)
movsd (%r12), %xmm1
movsd 0x28(%rsp), %xmm0
callq 0x55f0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
addq $0x4, %r13
jmp 0x1b13e
movsd 0x18(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6e4c
movsd 0x18(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b21e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6e4c
movq %rbx, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/AntColony/Ant.cpp
// Function: Ant::nextStep()
int Ant::nextStep(){
    vector<Choice> choices;
    double sum{0.0},rng{0.0};

    for(unsigned city : Globals::map.getCityList()){
        if(find(path.begin(),path.end(),city) == path.end()){
            choices.push_back(make_pair(city,calcChance(city)));   
        }
    }

    sort(choices.begin(),choices.end(),[](Choice& a, Choice& b){return a.second<b.second;});
    
    for(Choice c : choices){
        sum+=c.second;
    }
    
    uniform_real_distribution<double> dist(0.0,sum);
    
    rng = dist(Globals::urng);
    for(Choice c : choices){
        rng-=c.second;
        if(rng<=0){
            return c.first;
        }
    }
    return choices.back().first;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x229a6(%rip), %rsi     # 0x3dc50
leaq 0x30(%rsp), %rdi
callq 0xbb16
movq 0x30(%rsp), %r13
movq 0x38(%rsp), %rbp
leaq 0xc(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0x48(%rsp), %r12
cmpq %rbp, %r13
je 0x1b31a
movl (%r13), %eax
movl %eax, 0xc(%rsp)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x1b7ad
cmpq 0x8(%rbx), %rax
jne 0x1b314
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x1b090
movl 0xc(%rsp), %eax
movl %eax, 0x48(%rsp)
movsd %xmm0, 0x50(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b868
addq $0x4, %r13
jmp 0x1b2cd
leaq 0x30(%rsp), %rdi
callq 0x6e4c
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rbx
cmpq %rbx, %r14
je 0x1b391
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b445
cmpq $0x101, %r15            # imm = 0x101
jl 0x1b386
leaq 0x100(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b716
cmpq %rbx, %r15
je 0x1b391
movq %r15, %rdi
callq 0x1b783
addq $0x10, %r15
jmp 0x1b373
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b716
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x1b3af
addsd 0x8(%rax), %xmm0
addq $0x10, %rax
jmp 0x1b39f
leaq 0x30(%rsp), %rdi
andq $0x0, (%rdi)
movsd %xmm0, 0x8(%rdi)
leaq 0x21504(%rip), %rsi     # 0x3c8c8
callq 0x94d2
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
xorpd %xmm1, %xmm1
cmpq %rcx, %rax
je 0x1b3ed
subsd 0x8(%rax), %xmm0
ucomisd %xmm0, %xmm1
jae 0x1b3f4
addq $0x10, %rax
jmp 0x1b3d7
addq $-0x10, %rcx
movq %rcx, %rax
movl (%rax), %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b834
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b415
jmp 0x1b415
movq %rax, %rbx
jmp 0x1b429
jmp 0x1b41c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6e4c
leaq 0x10(%rsp), %rdi
callq 0x1b834
movq %rbx, %rdi
callq 0x5610
nop