LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::Block* moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::requisition_block<(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::AllocationMode)0>()
Block* requisition_block()
	{
		auto block = try_get_block_from_initial_pool();
		if (block != nullptr) {
			return block;
		}
		
		block = try_get_block_from_free_list();
		if (block != nullptr) {
			return block;
		}
		
		MOODYCAMEL_CONSTEXPR_IF (canAlloc == CanAlloc) {
			return create<Block>();
		}
		else {
			return nullptr;
		}
	}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rcx
movq 0x20(%rdi), %rax
cmpq %rax, %rcx
jae 0x681d
movl $0x1, %edx
lock
xaddq %rdx, 0x10(%rdi)
imulq $0x448, %rdx, %rsi      # imm = 0x448
addq 0x18(%rdi), %rsi
xorl %ecx, %ecx
cmpq %rax, %rdx
cmovbq %rsi, %rcx
jmp 0x681f
xorl %ecx, %ecx
testq %rcx, %rcx
jne 0x6936
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0x68f1
movl 0x430(%rdx), %eax
testl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x688c
leal 0x1(%rax), %esi
lock
cmpxchgl %esi, 0x430(%rdx)
jne 0x688c
movq 0x438(%rdx), %rsi
movq %rdx, %rax
lock
cmpxchgq %rsi, 0x28(%rdi)
movq %rax, %rsi
cmoveq %rdx, %rsi
jne 0x68a3
movl 0x430(%rsi), %eax
testl %eax, %eax
js 0x693b
lock
subl $0x2, 0x430(%rsi)
movl $0x1, %r8d
movq %rsi, %rdx
movq %rsi, %rcx
jmp 0x6896
movq 0x28(%rdi), %rdx
movl $0x2, %r8d
testb $0x1, %r8b
jne 0x68f3
testq %rdx, %rdx
jne 0x6835
jmp 0x68f1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
lock
xaddl %eax, 0x430(%rdx)
xorl %r8d, %r8d
cmpl $0x80000001, %eax       # imm = 0x80000001
jne 0x68ec
movq 0x28(%rdi), %rax
movq %rax, 0x438(%rdx)
movl $0x1, 0x430(%rdx)
lock
cmpxchgq %rdx, 0x28(%rdi)
je 0x68ec
movl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
lock
xaddl %r9d, 0x430(%rdx)
cmpl $0x1, %r9d
je 0x68be
movq %rsi, %rdx
jmp 0x6896
xorl %ecx, %ecx
testq %rcx, %rcx
jne 0x6936
movl $0x448, %edi            # imm = 0x448
callq 0x32c0
testq %rax, %rax
je 0x6934
movq %rax, %rcx
movl $0x0, 0x430(%rax)
movq $0x0, 0x438(%rax)
movw $0x100, 0x440(%rax)     # imm = 0x100
xorps %xmm0, %xmm0
movups %xmm0, 0x400(%rax)
jmp 0x6936
xorl %ecx, %ecx
movq %rcx, %rax
popq %rcx
retq
leaq 0x1464(%rip), %rdi      # 0x7da6
leaq 0x6f5(%rip), %rsi       # 0x703e
leaq 0x14a8(%rip), %rcx      # 0x7df8
movl $0x5c0, %edx            # imm = 0x5C0
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O1/GAStudyGroup[P]GPX2/src/main.cpp
// Function: main
int main(int argc, char *argv[]) {
    random_device rng;
    Globals::urng.seed(rng());

    // vector<int> t1,t2;
    // t1.push_back(1);
    // t1.push_back(2);
    // t1.push_back(3);
    // t1.push_back(4);
    // t1.push_back(5);
    // t1.push_back(6);

    // t2.push_back(5);
    // t2.push_back(6);
    // t2.push_back(4);
    // t2.push_back(2);
    // t2.push_back(1);
    // t2.push_back(3);
    // Globals::TOUR_SIZE = t1.size();

    // cout<<"chegou aqui?"<<endl;

    // OX::crossover(t1,t2);

    // for(int i : t1){
    //     cout<<i<<" ";
    // }cout<<endl;

    // for(int i : t2){
    //     cout<<i<<" ";
    // }cout<<endl;

    initArgs(argc,argv);

    GA();

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1390, %rsp           # imm = 0x1390
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8056
movq %r14, %rdi
callq 0x54f0
movl %eax, %ecx
leaq 0x3c79e(%rip), %rax     # 0x428e8
movq %rcx, (%rax)
movl $0x1, %edx
movq %rcx, %rsi
shrq $0x1e, %rsi
xorl %ecx, %esi
imull $0x6c078965, %esi, %ecx # imm = 0x6C078965
addl %edx, %ecx
movq %rcx, (%rax,%rdx,8)
incq %rdx
cmpq $0x270, %rdx            # imm = 0x270
jne 0x6152
movq $0x270, 0x1380(%rax) # imm = 0x270
movl %ebp, %edi
movq %rbx, %rsi
callq 0x61c4
callq 0x7c24
leaq 0x8(%rsp), %rdi
callq 0x5370
xorl %eax, %eax
addq $0x1390, %rsp           # imm = 0x1390
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x61bc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5370
movq %rbx, %rdi
callq 0x5670
movq %rax, %rdi
callq 0x80d0
// File: /workspace/github_cpp_makefile_star2_O1/GAStudyGroup[P]GPX2/src/base/sources/GAUtils.cpp
// Function: GAUtils::init(Population&)
void GAUtils::init(Population &pop){
    //Import the map
    ImportData dataFile(Config::LIB_PATH+Config::NAME);
    Globals::map.setCityList(dataFile.getCitiesCoord());

    //Import the first population from LK
    unsigned lkPop = Config::POP_SIZE * Config::LK_PERCENTAGE; 
    unsigned fillPop = Config::POP_SIZE - lkPop;
    if (Config::LK_PERCENTAGE > 0) { 
        pop = dataFile.importFirstPopulation(Config::NAME, lkPop);
    }

    //fill the rest of the population with 2-opt
    GAUtils::fillPopulationWithReset(pop, fillPop);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3a0, %rsp            # imm = 0x3A0
movq %rdi, %rbx
leaq 0x3a542(%rip), %rsi     # 0x428b8
leaq 0x3a51b(%rip), %r15     # 0x42898
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0xaf19
leaq 0x98(%rsp), %rdi
movq %r14, %rsi
callq 0xf8e0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83b8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1143a
leaq 0x3b89f(%rip), %rdi     # 0x43c70
leaq 0x8(%rsp), %rsi
callq 0xed8c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x83f2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
leaq 0x3a4e7(%rip), %rax     # 0x428e0
movl (%rax), %r14d
cvtsi2sd %r14, %xmm0
leaq 0x3a4d0(%rip), %rax     # 0x428d8
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %r12
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x84cb
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x82cc
leaq 0x60(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movl %r12d, %ecx
callq 0x11474
xorpd %xmm0, %xmm0
leaq 0x80(%rsp), %rdi
movapd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movupd (%rbx), %xmm0
movq 0x10(%rbx), %rax
leaq 0x60(%rsp), %r15
movaps (%r15), %xmm1
movups %xmm1, (%rbx)
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rbx)
movq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movapd (%rdi), %xmm1
movapd %xmm0, (%rdi)
movapd %xmm1, (%r15)
movq %rcx, 0x10(%r15)
callq 0x8102
movq %r15, %rdi
callq 0x8102
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x84cb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
subl %r12d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8566
leaq 0x98(%rsp), %rdi
callq 0xaf74
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x8531
movq 0x30(%rsp), %rsi
incq %rsi
jmp 0x8527
jmp 0x852e
jmp 0x852e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8531
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
jmp 0x8531
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xaf74
movq %rbx, %rdi
callq 0x5670
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x853e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53c0
jmp 0x853e
// File: /workspace/github_cpp_makefile_star2_O1/GAStudyGroup[P]GPX2/src/base/sources/GAUtils.cpp
// Function: GAUtils::fillPopulationWithReset(Population&, unsigned int)
void GAUtils::fillPopulationWithReset(Population &pop, unsigned popToFill) {
    for (unsigned i = 0; i < popToFill; i++) {
        vector<int> t;
        //random
        if(Config::NEW_TOUR_MODE==0 || Config::NEW_TOUR_MODE==1){
            t = Globals::map.getCityList();
            shuffle(t.begin(), t.end(),Globals::urng);
        }else{
            t = nearestNeighbor();
        }
        //apply 2-opt
        if(Config::NEW_TOUR_MODE==1 || Config::NEW_TOUR_MODE==2){
            t = Opt::optimize(t); 
        }
        
        pop.getPopulation().push_back(t);
    } 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testl %esi, %esi
je 0x8710
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3a250(%rip), %r15     # 0x427d8
leaq 0x20(%rsp), %r12
leaq 0x3a354(%rip), %r13     # 0x428e8
movq %rsp, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x1, (%r15)
ja 0x8620
movq %r12, %rdi
leaq 0x3b6b9(%rip), %rsi     # 0x43c70
callq 0xecfe
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movaps 0x20(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testq %rdi, %rdi
je 0x85f6
subq %rdi, %rsi
callq 0x53c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x860d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0xb0dc
jmp 0x8679
movq %r12, %rdi
callq 0x88de
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movaps 0x20(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testq %rdi, %rdi
je 0x8662
subq %rdi, %rsi
callq 0x53c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8679
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movl (%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x86df
movq %r12, %rdi
movq %rbp, %rsi
callq 0x21bdc
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movaps 0x20(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testq %rdi, %rdi
je 0x86c8
subq %rdi, %rsi
callq 0x53c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x86df
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq %r14, %rdi
callq 0xead4
movq %rax, %rdi
movq %rbp, %rsi
callq 0xb24e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8708
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
decl %ebx
jne 0x8597
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8725
jmp 0x8725
jmp 0x8725
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x873e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xead4
movq (%rax), %r15
movq %r14, %rdi
callq 0xead4
movq 0x8(%rax), %r13
xorpd %xmm0, %xmm0
cmpq %r13, %r15
je 0x8c87
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xb05c
movq %r12, %rdi
callq 0xf1c0
movl %eax, %ebp
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8c59
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd 0x286b0(%rip), %xmm1    # 0x31318
divsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x18, %r15
cmpq %r13, %r15
jne 0x8c2d
jmp 0x8c8d
movsd %xmm0, 0x8(%rsp)
leaq 0x39c54(%rip), %rdi     # 0x428e8
callq 0xbf67
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xead4
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x8d25
movsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb05c
movq %rbx, %rdi
callq 0xf1c0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x28634(%rip), %xmm1    # 0x31320
divsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x8d3d
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8d1c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x53c0
addq $0x18, %r15
cmpq %r12, %r15
jne 0x8cca
movq %r14, %rdi
callq 0xead4
movq 0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0xb05c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8d80
addq $0x10, %rbx
movq %rbx, (%rsp)
jmp 0x8d71
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8d80
movq (%rsp), %rax
movq (%rax), %rsi
subq %rdi, %rsi
callq 0x53c0
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39a31(%rip), %rax     # 0x427c4
movl (%rax), %eax
cmpl $0x2, %eax
je 0x8db7
cmpl $0x1, %eax
je 0x8dad
testl %eax, %eax
jne 0x8dad
movq %rbx, %rdi
callq 0x8dc4
jmp 0x8dbf
movq %rbx, %rdi
callq 0x8fd0
jmp 0x8dbf
movq %rbx, %rdi
callq 0x9356
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xeac4
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0xb392
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
callq 0xa220
leaq 0x60(%rsp), %rdi
callq 0x8102
movq (%rsp), %r15
movq 0x8(%rsp), %r13
cmpq %r13, %r15
je 0x8e52
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xb05c
movq %rbx, %rdi
callq 0xead4
movq %rax, %rdi
movq %r12, %rsi
callq 0xb24e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x8e49
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
addq $0x18, %r15
cmpq %r13, %r15
jne 0x8e14
movq %rsp, %r15
movq %r15, %rdi
callq 0x8102
leaq 0x30(%rsp), %r12
leaq 0x18(%rsp), %r13
movq %rbx, %rdi
callq 0xead4
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
leaq 0x39a51(%rip), %rax     # 0x428e0
movl (%rax), %eax
cmpq %rax, %rcx
jae 0x8f21
movq %rbx, %rdi
callq 0xead4
movq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
callq 0x8be5
movq %r13, %rdi
movq %r14, %rsi
callq 0x8be5
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x30628
movq %rbp, %rdi
movq %r15, %rsi
callq 0xb97c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8eea
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8f01
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8e67
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
jmp 0x8e67
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x60(%rsp), %rdi
jmp 0x8fb6
jmp 0x8fbd
movq %rax, %r14
jmp 0x8fb3
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8f62
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
jmp 0x8f62
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8f80
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
jmp 0x8f80
jmp 0x8fbd
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8fc0
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
jmp 0x8fc0
movq %rax, %r14
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x8fb3
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq %rsp, %rdi
callq 0x8102
jmp 0x8fc0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8102
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
callq 0xeac4
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x390db(%rip), %rax     # 0x428e0
cmpl $0x0, (%rax)
je 0x9944
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0x60(%rsp), %rbp
movq 0x8(%rsp), %rdi
callq 0xead4
leaq (,%r13,2), %rsi
addq %r13, %rsi
shlq $0x3, %rsi
addq (%rax), %rsi
movq %r15, %rdi
callq 0xb27a
leaq 0x3909a(%rip), %rax     # 0x428e0
cmpl $0x0, (%rax)
je 0x991b
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x9902
movq 0x8(%rsp), %rdi
callq 0xead4
movq (%rax), %rsi
addq %r14, %rsi
leaq 0x48(%rsp), %rdi
callq 0xb05c
movq %rbp, %rbx
movq %rbp, %rdi
movq %r15, %rsi
callq 0xb05c
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %rbx, %rdx
callq 0x26a04
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x98af
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x98c6
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
leaq 0x30(%rsp), %rdi
callq 0xf1c0
movl %eax, %ebx
movq %r15, %rdi
callq 0xf1c0
cmpl %eax, %ebx
jge 0x98eb
movq %r15, %rdi
leaq 0x30(%rsp), %rsi
callq 0xb27a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9902
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
incq %r12
leaq 0x38fd4(%rip), %rax     # 0x428e0
movl (%rax), %eax
addq $0x18, %r14
cmpq %rax, %r12
jb 0x9855
movq (%rsp), %rdi
callq 0xead4
movq %rax, %rdi
movq %r15, %rsi
callq 0xb24e
incq %r13
leaq 0x38fa7(%rip), %rax     # 0x428e0
movl (%rax), %eax
cmpq %rax, %r13
jb 0x981b
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x995b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x99a0
movq %rax, %r14
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x998f
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
jmp 0x998f
movq %rax, %r14
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x99bf
movq 0x58(%rsp), %rsi
jmp 0x99b7
movq %rax, %r14
jmp 0x99bf
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x99bf
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x99d6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq (%rsp), %rdi
callq 0x8102
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2487f(%rip), %r14     # 0x32803
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xe91d
movq %r15, %rdi
movq %r14, %rsi
callq 0x5700
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xdfc6
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0xdfcd
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x5440
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xe00e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe029
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x24942(%rip), %r14     # 0x32972
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5440
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x55c0
leaq 0x235b5(%rip), %rsi     # 0x3160a
movl $0xf, %edx
movq %rax, %rdi
callq 0x5440
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5440
movsd 0x8(%rsp), %xmm0
divsd 0x233a8(%rip), %xmm0    # 0x31428
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x55c0
leaq 0x23585(%rip), %rsi     # 0x3161a
movl $0xa, %edx
movq %rax, %rdi
callq 0x5440
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5440
movsd 0x8(%rsp), %xmm0
divsd 0x23370(%rip), %xmm0    # 0x31430
movq %rbx, %rdi
callq 0x55c0
leaq 0x23556(%rip), %rsi     # 0x31625
movl $0xa, %edx
movq %rax, %rdi
callq 0x5440
movq %rbx, %rdi
callq 0x5290
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xe10d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53c0
jmp 0xe10d
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe128
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x82cc
leaq 0x234c9(%rip), %rsi     # 0x31630
movq %r14, %rdi
callq 0x5700
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x5710
leaq 0x90(%rsp), %rdi
callq 0x50d0
testb %al, %al
je 0xe19f
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xf261
movq 0x33dca(%rip), %rax     # 0x41f70
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rsp,%rcx)
callq 0x5320
leaq 0x118(%rsp), %rdi
callq 0x5130
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe1e7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5570
jmp 0xe208
jmp 0xe205
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe21e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %r12, %r14
je 0xecb3
xorl %ebp, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb05c
movl $0x5, %edx
movq %rbx, %rdi
leaq 0x22ac7(%rip), %rsi     # 0x31709
callq 0x5440
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5640
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x22735(%rip), %rsi     # 0x31398
callq 0x5440
movq %r15, %rdi
callq 0xf1c0
movq %r13, %rdi
movl %eax, %esi
callq 0x5640
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x23b7a(%rip), %rsi     # 0x32803
callq 0x5440
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xeca4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
addq $0x18, %r14
incl %ebp
cmpq %r12, %r14
jne 0xec28
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
testq %rdi, %rdi
je 0xecde
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, (%rsp)
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
movq %rbx, %r13
subq %r15, %r13
sarq $0x3, %r13
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
sarq $0x2, %r13
testq %r13, %r13
jle 0xee1e
incq %r13
movq %r15, %rdi
callq 0xf884
cmpl %ebp, %eax
je 0xee6d
leaq 0x18(%r15), %r12
movq %r12, %rdi
callq 0xf884
cmpl %ebp, %eax
je 0xee70
leaq 0x30(%r15), %r12
movq %r12, %rdi
callq 0xf884
cmpl %ebp, %eax
je 0xee70
leaq 0x48(%r15), %r12
movq %r12, %rdi
callq 0xf884
cmpl %ebp, %eax
je 0xee70
addq $0x60, %r15
decq %r13
cmpq $0x1, %r13
jg 0xedd1
movq %rbx, %rax
subq %r15, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq $0x1, %rax
je 0xee76
cmpq $0x2, %rax
movq (%rsp), %r13
je 0xee5c
cmpq $0x3, %rax
jne 0xee8e
movq %r15, %rdi
callq 0xf884
cmpl %ebp, %eax
je 0xee68
addq $0x18, %r15
movq %r15, %rdi
callq 0xf884
cmpl %ebp, %eax
jne 0xee7c
movq %r15, %r12
jmp 0xee91
movq %r15, %r12
movq (%rsp), %r13
jmp 0xee91
movq (%rsp), %r13
jmp 0xee80
addq $0x18, %r15
movq %r15, %rdi
callq 0xf884
cmpl %ebp, %eax
cmoveq %r15, %rbx
movq %rbx, %r12
cmpq 0x8(%r14), %r12
je 0xeeac
movq 0x10(%r12), %rax
movq %rax, 0x10(%r13)
movups (%r12), %xmm0
movups %xmm0, (%r13)
jmp 0xeeb4
movq %r13, %rdi
callq 0xf85c
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq (%rdi), %r15
movq %rdi, (%rsp)
movq 0x8(%rdi), %rax
cmpq %rax, %r15
je 0xf343
movq %rax, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
movl (%r15), %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5640
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x220e8(%rip), %r12     # 0x31398
movq %r12, %rsi
callq 0x5440
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
leaq 0x349a9(%rip), %r13     # 0x43c70
movq %r13, %rsi
movl %r14d, %edx
callq 0xed92
movq %rbp, %rdi
callq 0xf878
movq %rbx, %rdi
callq 0x55c0
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x5440
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0xed92
movq %r12, %rdi
callq 0xf87e
movq %rbx, %rdi
movq 0x8(%rsp), %rbx
callq 0x55c0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x234d7(%rip), %rsi     # 0x32803
callq 0x5440
movq 0x10(%rsp), %rax
addq $0x4, %r15
cmpq %rax, %r15
jne 0xf290
leaq 0x2241e(%rip), %rsi     # 0x31768
movl $0xa, %edx
movq %rbx, %rdi
callq 0x5440
movq (%rsp), %rdi
callq 0xf1c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x5640
leaq 0x23492(%rip), %rsi     # 0x32803
movl $0x1, %edx
movq %rax, %rdi
callq 0x5440
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_O1/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 0x344f3(%rip), %r14     # 0x43c70
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xed92
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xed92
movq %r15, %rdi
callq 0xf878
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0xf878
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
callq 0xf87e
movsd %xmm0, 0x10(%rsp)
movq %r12, %rdi
callq 0xf87e
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movapd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
divsd 0x21f5d(%rip), %xmm1    # 0x31760
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0xf817
sqrtsd %xmm0, %xmm0
jmp 0xf81c
callq 0x5300
movsd %xmm0, 0x8(%rsp)
callq 0x5190
movsd 0x21ae9(%rip), %xmm1    # 0x31318
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
// File: /workspace/github_cpp_makefile_star2_O1/GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::findIgnoredWords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ImportData::findIgnoredWords(string input)
{
    regex ignore(":|NAME(.*)|TYPE(.*)|COMMENT(.*)|DIMENSION(.*)|EDGE(.*)|EOF");
    if (regex_match(input, ignore)) {
        return false;
    }
    //  cout << input;
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x215a5(%rip), %rsi     # 0x318fe
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x11f38
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x1d447
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x103a5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
xorb $0x1, %bl
leaq 0x28(%rsp), %rdi
callq 0x1200c
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x103d5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
leaq 0x28(%rsp), %rdi
callq 0x1200c
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2125a(%rip), %rsi     # 0x3198d
movq %rbx, %rdi
callq 0x5100
testl %eax, %eax
je 0x1078c
leaq 0x2124e(%rip), %rsi     # 0x31994
movq %rbx, %rdi
callq 0x5100
testl %eax, %eax
je 0x10790
leaq 0x2123f(%rip), %rsi     # 0x31998
movq %rbx, %rdi
callq 0x5100
movl $0x2, %ecx
testl %eax, %eax
je 0x10795
movq 0x3182f(%rip), %rdi     # 0x41fa0
leaq 0x21224(%rip), %rsi     # 0x3199c
callq 0x53a0
movq %rax, %rdi
callq 0x51b0
xorl %edi, %edi
callq 0x5480
xorl %ecx, %ecx
jmp 0x10795
movl $0x1, %ecx
leaq 0x320ec(%rip), %rax     # 0x42888
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::getcomment[abi:cxx11]()
string ImportData::getcomment()
{
    if (comment == "") {
        return "N/A";
    } else {
        return comment;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsi), %rdi
leaq 0x21e94(%rip), %rsi     # 0x32973
callq 0x5100
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x10b04
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x82cc
jmp 0x10b1a
leaq 0x20d4d(%rip), %rsi     # 0x31858
leaq 0x20d49(%rip), %rdx     # 0x3185b
movq %rbx, %rdi
callq 0x823c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %ecx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x5610
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movsbl %bpl, %ebp
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x56a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11ea4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f51c
jmp 0x11e7c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x11eba
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x300b7(%rip), %rsi     # 0x41f78
leaq 0x20(%rsp), %rdi
callq 0x5540
leaq 0x98(%rsp), %rdi
callq 0x5130
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x11f27
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x11f09
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x30068(%rip), %rsi     # 0x41f78
leaq 0x20(%rsp), %rdi
callq 0x5540
leaq 0x98(%rsp), %rdi
callq 0x5130
movq %rbx, %rdi
callq 0x81e0
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %ecx, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x5610
movsbl %bpl, %ebp
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x56a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1f9e2
cmpq $0x0, 0x8(%rsp)
je 0x1f9b2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a992
jmp 0x1f9b2
movq 0x2258f(%rip), %rsi     # 0x41f78
leaq 0x20(%rsp), %rdi
callq 0x5540
leaq 0x98(%rsp), %rdi
callq 0x5130
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1fa16
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1fa4f
movq %rax, %r14
movq 0x22540(%rip), %rsi     # 0x41f78
leaq 0x20(%rsp), %rdi
callq 0x5540
leaq 0x98(%rsp), %rdi
callq 0x5130
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1fa65
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x81e0
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x1fba2
movq %rbx, %rdi
callq 0x1ff68
movb 0x48(%rbx), %r15b
cmpb $0x1, %r15b
jne 0x1face
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x12cf9(%rip), %rsi     # 0x327a6
leaq 0x12cf6(%rip), %rdx     # 0x327aa
movq %rsp, %r14
movq %r14, %rdi
callq 0x823c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x204e0
movl %eax, %ebp
jmp 0x1fad0
xorl %ebp, %ebp
testb %r15b, %r15b
je 0x1faf0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1faf0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
testb %bpl, %bpl
jne 0x1fb0a
movq %rbx, %rdi
callq 0x207ac
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51c0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x20568
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x55d0
xorl %ebp, %ebp
movq 0x224ab(%rip), %rsi     # 0x41fe8
movq 0x2243c(%rip), %rdx     # 0x41f80
movq %r14, %rdi
callq 0x5630
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fb72
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
jmp 0x1fb72
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1fb9a
movq %r14, %rdi
callq 0x52c0
jmp 0x1fb9a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1fb9a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x82cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20b70
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x20531
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
testq %rbx, %rbx
je 0x2053b
movb 0x39(%rbx), %al
jmp 0x2053d
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x20560
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x80(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rsi), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x82cc
leaq 0x12242(%rip), %rsi     # 0x32802
leaq 0x20(%rsp), %rdi
callq 0x5700
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x5110
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x205f3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x1220b(%rip), %rsi     # 0x32805
movq %rbx, %rdi
callq 0x5700
movq (%r15), %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
je 0x206f3
leaq 0x48(%rsp), %rbp
leaq 0x70(%rsp), %r15
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x17d56
movq %rbp, 0x38(%rsp)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x82cc
movzwl 0x38(%r14), %eax
movw %ax, 0x58(%rsp)
movq %r15, 0x60(%rsp)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x82cc
movq %rsp, %rdi
movq %r13, %rsi
callq 0x210e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5110
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x206a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
leaq 0x12157(%rip), %rsi     # 0x32802
callq 0x5700
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x206c7
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x206de
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %r13, %rdi
callq 0x81e0
addq $0x60, %r14
cmpq %r12, %r14
jne 0x20621
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2072a
jmp 0x2070c
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x20789
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
jmp 0x20789
jmp 0x2072a
movq %rax, %r14
jmp 0x20789
movq %rax, %r14
jmp 0x2074e
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2074e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x20(%rsp), %rdi
callq 0x81e0
jmp 0x20789
jmp 0x2077c
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2077f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
jmp 0x2077f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x21064
movq (%rbx), %rdi
movq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x207a4
movq (%rax), %rsi
incq %rsi
callq 0x53c0
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x30(%rsp)
leaq 0xa8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x98(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x82cc
leaq 0x80(%rsp), %rdi
movq %r14, %rdx
movl $0x7c, %ecx
callq 0x1f960
movq 0x98(%rsp), %rdi
cmpq %r15, %rdi
je 0x20be1
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x80(%rsp), %rax
movq 0x88(%rsp), %rcx
movq %rcx, 0x28(%rsp)
cmpq %rcx, %rax
je 0x20d48
leaq 0x18(%rsp), %r15
leaq 0x68(%rsp), %r13
movq %r15, 0x8(%rsp)
movq (%rax), %rsi
movq %rax, 0x38(%rsp)
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x82cc
movq 0x30(%rsp), %rax
movq (%rax), %rbp
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %rbp
je 0x20d12
movq %r13, %rdi
movq %rbp, %rsi
callq 0x17d56
movq 0x68(%rsp), %r15
movq 0x70(%rsp), %r13
cmpq %r13, %r15
sete %r12b
je 0x20cd6
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x82cc
movq 0x50(%rsp), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x20ca4
testq %rdx, %rdx
je 0x20ca8
movq 0x8(%rsp), %rsi
movq 0x48(%rsp), %rdi
callq 0x53e0
testl %eax, %eax
sete %bl
jmp 0x20caa
xorl %ebx, %ebx
jmp 0x20caa
movb $0x1, %bl
testb %bl, %bl
cmovneq %rbp, %r14
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x20ccc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53c0
testb %bl, %bl
jne 0x20cdb
addq $0x20, %r15
jmp 0x20c56
xorl %r15d, %r15d
jmp 0x20ce1
movl $0x1, %r15d
leaq 0x68(%rsp), %r13
movq %r13, %rdi
callq 0x81e0
testb $0x1, %r12b
je 0x20d09
addq $0x60, %rbp
cmpq 0x40(%rsp), %rbp
jne 0x20c41
movl $0x4, %r15d
testb $0x3, %r15b
sete %bl
jmp 0x20d14
movb $0x1, %bl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %r15
cmpq %r15, %rdi
je 0x20d30
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
testb %bl, %bl
je 0x20d4b
movq 0x38(%rsp), %rax
addq $0x20, %rax
cmpq 0x28(%rsp), %rax
jne 0x20c09
xorl %r14d, %r14d
leaq 0x80(%rsp), %rdi
callq 0x81e0
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x98(%rsp), %rdi
cmpq %r15, %rdi
je 0x20dcf
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x53c0
jmp 0x20dcf
movq %rax, %rbx
jmp 0x20dc2
movq %rax, %rbx
jmp 0x20da6
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x81e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x20dc2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x80(%rsp), %rdi
callq 0x81e0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x82cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x20b70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x20e2f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x10(%rbx), %rax
testq %r14, %r14
je 0x20e50
movq %rax, (%rbx)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x82cc
jmp 0x20e5f
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x20e88
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x5670