LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::LightweightSemaphore::waitMany(long, long)
ssize_t waitMany(ssize_t max, std::int64_t timeout_usecs)
	{
		assert(max >= 0);
		ssize_t result = tryWaitMany(max);
		if (result == 0 && max > 0)
			result = waitManyWithPartialSpinning(max, timeout_usecs);
		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
js 0x48a3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4a9a
testq %rax, %rax
setne %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x489d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4af0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2a27(%rip), %rdi      # 0x72d1
leaq 0x2865(%rip), %rsi      # 0x7116
leaq 0x2a22(%rip), %rcx      # 0x72da
movl $0x17b, %edx            # imm = 0x17B
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::LightweightSemaphore::tryWaitMany(long)
ssize_t tryWaitMany(ssize_t max)
	{
		assert(max >= 0);
		ssize_t oldCount = m_count.load(std::memory_order_relaxed);
		while (oldCount > 0)
		{
			ssize_t newCount = oldCount > max ? oldCount - max : 0;
			if (m_count.compare_exchange_weak(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
				return oldCount - newCount;
		}
		return 0;
	}

// Assembly:
testq %rsi, %rsi
js 0x4ad0
movq (%rdi), %rcx
testq %rcx, %rcx
jle 0x4ac5
xorl %edx, %edx
movq %rcx, %r8
subq %rsi, %r8
cmovleq %rdx, %r8
movq %rcx, %rax
lock
cmpxchgq %r8, (%rdi)
je 0x4ac9
movq %rax, %rcx
testq %rax, %rax
jg 0x4aa9
xorl %ecx, %ecx
jmp 0x4acc
subq %r8, %rcx
movq %rcx, %rax
retq
pushq %rax
leaq 0x27f9(%rip), %rdi      # 0x72d1
leaq 0x2637(%rip), %rsi      # 0x7116
leaq 0x283e(%rip), %rcx      # 0x7324
movl $0x16d, %edx            # imm = 0x16D
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::LightweightSemaphore::waitManyWithPartialSpinning(long, long)
ssize_t waitManyWithPartialSpinning(ssize_t max, std::int64_t timeout_usecs = -1)
	{
		assert(max > 0);
		ssize_t oldCount;
		int spin = m_maxSpins;
		while (--spin >= 0)
		{
			oldCount = m_count.load(std::memory_order_relaxed);
			if (oldCount > 0)
			{
				ssize_t newCount = oldCount > max ? oldCount - max : 0;
				if (m_count.compare_exchange_strong(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
					return oldCount - newCount;
			}
			std::atomic_signal_fence(std::memory_order_acquire);
		}
		oldCount = m_count.fetch_sub(1, std::memory_order_acquire);
		if (oldCount <= 0)
		{
			if ((timeout_usecs == 0) || (timeout_usecs < 0 && !m_sema.wait()) || (timeout_usecs > 0 && !m_sema.timed_wait((std::uint64_t)timeout_usecs)))
			{
				while (true)
				{
					oldCount = m_count.load(std::memory_order_acquire);
					if (oldCount >= 0 && m_sema.try_wait())
						break;
					if (oldCount < 0 && m_count.compare_exchange_strong(oldCount, oldCount + 1, std::memory_order_relaxed, std::memory_order_relaxed))
						return 0;
				}
			}
		}
		if (max > 1)
			return 1 + tryWaitMany(max - 1);
		return 1;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
jle 0x4bba
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rdi), %ecx
testl %ecx, %ecx
jle 0x4b35
incl %ecx
xorl %esi, %esi
movq (%r14), %r15
testq %r15, %r15
jle 0x4b2e
movq %r15, %rdi
subq %rbx, %rdi
cmovleq %rsi, %rdi
movq %r15, %rax
lock
cmpxchgq %rdi, (%r14)
je 0x4b75
decl %ecx
cmpl $0x1, %ecx
ja 0x4b12
lock
decq (%r14)
jl 0x4b5d
movl $0x1, %r15d
cmpq $0x1, %rbx
je 0x4bab
decq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4a9a
movq %rax, %r15
incq %r15
jmp 0x4bab
testq %rdx, %rdx
je 0x4b83
leaq 0x8(%r14), %rdi
testq %rdx, %rdx
js 0x4b7a
movq %rdx, %rsi
callq 0x4c06
jmp 0x4b7f
subq %rdi, %r15
jmp 0x4bab
callq 0x4bda
testb %al, %al
jne 0x4b3b
leaq 0x8(%r14), %r12
xorl %r15d, %r15d
movq (%r14), %rax
testq %rax, %rax
js 0x4ba0
movq %r12, %rdi
callq 0x4ca4
testb %al, %al
je 0x4b8a
jmp 0x4b3b
leaq 0x1(%rax), %rcx
lock
cmpxchgq %rcx, (%r14)
jne 0x4b8a
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x27a2(%rip), %rdi      # 0x7363
leaq 0x254e(%rip), %rsi      # 0x7116
leaq 0x279c(%rip), %rcx      # 0x736b
movl $0x12c, %edx            # imm = 0x12C
callq 0x3150
nop
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::LightweightSemaphore::signal(long)
void signal(ssize_t count = 1)
	{
		assert(count >= 0);
		ssize_t oldCount = m_count.fetch_add(count, std::memory_order_release);
		ssize_t toRelease = -oldCount < count ? -oldCount : count;
		if (toRelease > 0)
		{
			m_sema.signal((int)toRelease);
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x5f7c
movq %rdi, %rbx
movq %rsi, %r14
lock
xaddq %r14, (%rdi)
negq %r14
cmpq %rsi, %r14
cmovgeq %rsi, %r14
testq %r14, %r14
jle 0x5f74
testl %r14d, %r14d
jle 0x5f74
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x3360
cmpl $-0x1, %eax
je 0x5f5a
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
jg 0x5f5a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x202d(%rip), %rdi      # 0x7fb0
leaq 0x118c(%rip), %rsi      # 0x7116
leaq 0x202a(%rip), %rcx      # 0x7fbb
movl $0x18b, %edx            # imm = 0x18B
callq 0x3150
nop
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::recycle_or_create_producer(bool, bool&)
ProducerBase* recycle_or_create_producer(bool isExplicit, bool& recycled)
	{
#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
		debug::DebugLock lock(implicitProdMutex);
#endif
		// Try to re-use one first
		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
			if (ptr->inactive.load(std::memory_order_relaxed) && ptr->isExplicit == isExplicit) {
				bool expected = true;
				if (ptr->inactive.compare_exchange_strong(expected, /* desired */ false, std::memory_order_acquire, std::memory_order_relaxed)) {
					// We caught one! It's been marked as activated, the caller can have it
					recycled = true;
					return ptr;
				}
			}
		}
		
		recycled = false;
		return add_producer(isExplicit ? static_cast<ProducerBase*>(create<ExplicitProducer>(this)) : create<ImplicitProducer>(this));
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x63f6
xorl %ecx, %ecx
movb 0x10(%rbx), %al
testb $0x1, %al
je 0x63e9
cmpb %sil, 0x48(%rbx)
jne 0x63e9
movb $0x1, %al
lock
cmpxchgb %cl, 0x10(%rbx)
je 0x6490
movq 0x8(%rbx), %rax
leaq -0x8(%rax), %rbx
testq %rax, %rax
jne 0x63cf
movb $0x0, (%rdx)
testb %sil, %sil
je 0x641d
movl $0x88, %edi
callq 0x32c0
testq %rax, %rax
je 0x648c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x649e
jmp 0x646c
movl $0x68, %edi
callq 0x32c0
testq %rax, %rax
je 0x648c
movq %rax, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movb %al, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movb %al, 0x48(%rbx)
movq %r14, 0x50(%rbx)
leaq 0x58d3(%rip), %rcx      # 0xbd28
movq %rcx, (%rbx)
movq $0x20, 0x58(%rbx)
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0x6804
lock
incl 0x8(%r14)
movq (%r14), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x8(%rbx)
lock
cmpxchgq %rbx, (%r14)
jne 0x6474
jmp 0x6493
xorl %ebx, %ebx
jmp 0x6493
movb $0x1, (%rdx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ExplicitProducer::ExplicitProducer(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>*)
explicit ExplicitProducer(ConcurrentQueue* parent_) :
			ProducerBase(parent_, true),
			blockIndex(nullptr),
			pr_blockIndexSlotsUsed(0),
			pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1),
			pr_blockIndexFront(0),
			pr_blockIndexEntries(nullptr),
			pr_blockIndexRaw(nullptr)
		{
			size_t poolBasedIndexSize = details::ceil_to_pow_2(parent_->initialBlockPoolSize) >> 1;
			if (poolBasedIndexSize > pr_blockIndexSize) {
				pr_blockIndexSize = poolBasedIndexSize;
			}
			
			new_block_index(0);		// This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE
		}

// Assembly:
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movb $0x1, 0x48(%rdi)
movq %rsi, 0x50(%rdi)
leaq 0x57ee(%rip), %rcx      # 0xbcb8
movq %rcx, (%rdi)
movups %xmm0, 0x58(%rdi)
movq $0x10, 0x68(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
movq 0x20(%rsi), %rax
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
orq %rcx, %rax
incq %rax
cmpq $0x22, %rax
jb 0x6536
shrq %rax
movq %rax, 0x68(%rdi)
xorl %esi, %esi
jmp 0x653e
nop
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ExplicitProducer::new_block_index(unsigned long)
bool new_block_index(size_t numberOfFilledSlotsToExpose)
		{
			auto prevBlockSizeMask = pr_blockIndexSize - 1;
			
			// Create the new block
			pr_blockIndexSize <<= 1;
			auto newRawPtr = static_cast<char*>((Traits::malloc)(sizeof(BlockIndexHeader) + std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * pr_blockIndexSize));
			if (newRawPtr == nullptr) {
				pr_blockIndexSize >>= 1;		// Reset to allow graceful retry
				return false;
			}
			
			auto newBlockIndexEntries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(newRawPtr + sizeof(BlockIndexHeader)));
			
			// Copy in all the old indices, if any
			size_t j = 0;
			if (pr_blockIndexSlotsUsed != 0) {
				auto i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & prevBlockSizeMask;
				do {
					newBlockIndexEntries[j++] = pr_blockIndexEntries[i];
					i = (i + 1) & prevBlockSizeMask;
				} while (i != pr_blockIndexFront);
			}
			
			// Update everything
			auto header = new (newRawPtr) BlockIndexHeader;
			header->size = pr_blockIndexSize;
			header->front.store(numberOfFilledSlotsToExpose - 1, std::memory_order_relaxed);
			header->entries = newBlockIndexEntries;
			header->prev = pr_blockIndexRaw;		// we link the new block to the old one so we can free it later
			
			pr_blockIndexFront = j;
			pr_blockIndexEntries = newBlockIndexEntries;
			pr_blockIndexRaw = newRawPtr;
			blockIndex.store(header, std::memory_order_release);
			
			return true;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %r12
leaq (%r12,%r12), %r15
movq %r15, 0x68(%rdi)
movq %r12, %rdi
shlq $0x5, %rdi
addq $0x27, %rdi
callq 0x32c0
testq %rax, %rax
je 0x65c3
leaq 0x20(%rax), %rcx
negl %ecx
andl $0x7, %ecx
addq %rax, %rcx
addq $0x20, %rcx
movq 0x60(%rbx), %rdx
testq %rdx, %rdx
je 0x65ce
decq %r12
movq 0x70(%rbx), %rsi
movq 0x78(%rbx), %rdi
movq %rsi, %r8
subq %rdx, %r8
andq %r12, %r8
xorl %edx, %edx
movq %rcx, %r9
movq %r8, %r10
shlq $0x4, %r10
incq %rdx
movups (%rdi,%r10), %xmm0
movups %xmm0, (%r9)
incq %r8
andq %r12, %r8
addq $0x10, %r9
cmpq %rsi, %r8
jne 0x659f
jmp 0x65d0
btrq $0x3f, %r12
movq %r12, 0x68(%rbx)
jmp 0x65fc
xorl %edx, %edx
movq %r15, (%rax)
decq %r14
movq %r14, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq 0x80(%rbx), %rsi
movq %rsi, 0x18(%rax)
movq %rdx, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x58(%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
jae 0x6b8b
movl $0x1, %eax
lock
xaddq %rax, 0x10(%rdi)
cmpq %rcx, %rax
setae %dl
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
sete %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0x6c70
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0x6c2c
movq %rdx, %rcx
movq %rdx, %rsi
movl 0x430(%rcx), %eax
testl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x6c19
leal 0x1(%rax), %edx
lock
cmpxchgl %edx, 0x430(%rcx)
jne 0x6c19
movq 0x438(%rcx), %rdx
movq %rsi, %rax
lock
cmpxchgq %rdx, 0x28(%rdi)
je 0x6c7c
movq %rax, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
lock
xaddl %eax, 0x430(%rcx)
cmpl $0x80000001, %eax       # imm = 0x80000001
jne 0x6c1d
movq 0x28(%rdi), %rax
movq %rax, 0x438(%rcx)
movl $0x1, 0x430(%rcx)
lock
cmpxchgq %rsi, 0x28(%rdi)
je 0x6c1d
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
lock
xaddl %r8d, 0x430(%rcx)
cmpl $0x1, %r8d
je 0x6be9
jmp 0x6c1d
movq 0x28(%rdi), %rdx
movq %rdx, %rcx
movq %rdx, %rsi
testq %rdx, %rdx
jne 0x6b9e
movq %rdx, %rcx
testq %rdx, %rdx
jne 0x6c92
movl $0x448, %edi            # imm = 0x448
callq 0x32c0
testq %rax, %rax
je 0x6c90
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 0x6c92
imulq $0x448, %rax, %rax      # imm = 0x448
addq %rax, %rcx
jmp 0x6c92
movl 0x430(%rcx), %eax
testl %eax, %eax
js 0x6c97
lock
subl $0x2, 0x430(%rcx)
jmp 0x6c92
xorl %ecx, %ecx
movq %rcx, %rax
popq %rcx
retq
leaq 0x11a8(%rip), %rdi      # 0x7e46
leaq 0x439(%rip), %rsi       # 0x70de
leaq 0x11ec(%rip), %rcx      # 0x7e98
movl $0x5c0, %edx            # imm = 0x5C0
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8076
movq %r14, %rdi
callq 0x54e0
movl %eax, %ecx
leaq 0x3c75e(%rip), %rax     # 0x428d8
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 0x6182
movq $0x270, 0x1380(%rax) # imm = 0x270
movl %ebp, %edi
movq %rbx, %rsi
callq 0x61f4
callq 0x7c54
leaq 0x8(%rsp), %rdi
callq 0x5360
xorl %eax, %eax
addq $0x1390, %rsp           # imm = 0x1390
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x61ec
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5360
movq %rbx, %rdi
callq 0x5660
movq %rax, %rdi
callq 0x80f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3a4fe(%rip), %rsi     # 0x428a8
leaq 0x3a4d7(%rip), %r15     # 0x42888
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0xaf35
leaq 0x98(%rsp), %rdi
movq %r14, %rsi
callq 0xf8d8
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83ec
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53b0
leaq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1142a
leaq 0x3b85b(%rip), %rdi     # 0x43c60
leaq 0x8(%rsp), %rsi
callq 0xed74
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8426
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
leaq 0x3a4a3(%rip), %rax     # 0x428d0
movl (%rax), %r14d
cvtsi2sd %r14, %xmm0
leaq 0x3a48c(%rip), %rax     # 0x428c8
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %r12
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x84f1
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x82fa
leaq 0x60(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movl %r12d, %ecx
callq 0x11464
movq 0x10(%rbx), %rax
leaq 0x60(%rsp), %r15
movapd (%r15), %xmm0
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rbx)
movupd (%rbx), %xmm1
movupd %xmm0, (%rbx)
leaq 0x80(%rsp), %rdi
movapd %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorpd %xmm0, %xmm0
movapd %xmm0, (%r15)
movq $0x0, 0x10(%r15)
callq 0x8122
movq %r15, %rdi
callq 0x8122
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x84f1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53b0
subl %r12d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x858c
leaq 0x98(%rsp), %rdi
callq 0xaf90
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 0x8557
movq 0x30(%rsp), %rsi
incq %rsi
jmp 0x854d
jmp 0x8554
jmp 0x8554
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8557
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
jmp 0x8557
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xaf90
movq %rbx, %rdi
callq 0x5660
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8564
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53b0
jmp 0x8564
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8736
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3a21a(%rip), %r15     # 0x427c8
leaq 0x20(%rsp), %r12
leaq 0x3a31e(%rip), %r13     # 0x428d8
movq %rsp, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x1, (%r15)
ja 0x8646
movq %r12, %rdi
leaq 0x3b683(%rip), %rsi     # 0x43c60
callq 0xece6
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 0x8633
subq %rdi, %rsi
callq 0x53b0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8633
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0xb0f8
jmp 0x869f
movq %r12, %rdi
callq 0x8902
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 0x869f
subq %rdi, %rsi
callq 0x53b0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x869f
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movl (%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x8705
movq %r12, %rdi
movq %rbp, %rsi
callq 0x21ca8
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 0x8705
subq %rdi, %rsi
callq 0x53b0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8705
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq %r14, %rdi
callq 0xeabc
movq %rax, %rdi
movq %rbp, %rsi
callq 0xb26a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x872e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
decl %ebx
jne 0x85bd
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x874b
jmp 0x874b
jmp 0x874b
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8764
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5660
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xeabc
movq (%rax), %r15
movq %r14, 0x18(%rsp)
movq %r14, %rdi
callq 0xeabc
movq 0x8(%rax), %r14
xorpd %xmm0, %xmm0
cmpq %r14, %r15
je 0x8c72
movsd %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %r13
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xb078
movq %r12, %rdi
callq 0xf1cc
movl %eax, %ebp
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8c44
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd 0x286c5(%rip), %xmm1    # 0x31318
divsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x18, %r15
cmpq %r14, %r15
jne 0x8c18
jmp 0x8c78
movsd %xmm0, 0x10(%rsp)
leaq 0x39c59(%rip), %rdi     # 0x428d8
callq 0xbf8f
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xeabc
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x8d1e
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rbx), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb078
movq %rbx, %rdi
callq 0xf1cc
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x2863d(%rip), %xmm1    # 0x31320
divsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x8d36
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8d15
movq (%r13), %rsi
subq %rdi, %rsi
callq 0x53b0
addq $0x18, %r15
cmpq %r12, %r15
jne 0x8cc1
movq %r14, %rdi
callq 0xeabc
movq 0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0xb078
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
jmp 0x8d58
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8d69
movq (%r13), %rsi
subq %rdi, %rsi
callq 0x53b0
movq %r14, %rdi
callq 0x5660
// File: /workspace/github_cpp_makefile_star2_O3/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 0x39a38(%rip), %rax     # 0x427b4
movl (%rax), %eax
cmpl $0x2, %eax
je 0x8da0
cmpl $0x1, %eax
je 0x8d96
testl %eax, %eax
jne 0x8d96
movq %rbx, %rdi
callq 0x8dad
jmp 0x8da8
movq %rbx, %rdi
callq 0x8fb9
jmp 0x8da8
movq %rbx, %rdi
callq 0x9342
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeaac
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0xb3bc
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
callq 0xa202
leaq 0x60(%rsp), %rdi
callq 0x8122
movq (%rsp), %r15
movq 0x8(%rsp), %r13
cmpq %r13, %r15
je 0x8e3b
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xb078
movq %rbx, %rdi
callq 0xeabc
movq %rax, %rdi
movq %r12, %rsi
callq 0xb26a
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x8e32
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
addq $0x18, %r15
cmpq %r13, %r15
jne 0x8dfd
movq %rsp, %r15
movq %r15, %rdi
callq 0x8122
leaq 0x30(%rsp), %r12
leaq 0x18(%rsp), %r13
movq %rbx, %rdi
callq 0xeabc
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
leaq 0x39a58(%rip), %rax     # 0x428d0
movl (%rax), %eax
cmpq %rax, %rcx
jae 0x8f0a
movq %rbx, %rdi
callq 0xeabc
movq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
callq 0x8bcf
movq %r13, %rdi
movq %r14, %rsi
callq 0x8bcf
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x308b0
movq %rbp, %rdi
movq %r15, %rsi
callq 0xb99a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8ed3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8eea
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8e50
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
jmp 0x8e50
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 0x8f9f
jmp 0x8fa6
movq %rax, %r14
jmp 0x8f9c
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8f4b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
jmp 0x8f4b
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8f69
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
jmp 0x8f69
jmp 0x8fa6
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8fa9
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
jmp 0x8fa9
movq %rax, %r14
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x8f9c
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq %rsp, %rdi
callq 0x8122
jmp 0x8fa9
movq %rax, %r14
movq %rbx, %rdi
callq 0x8122
movq %r14, %rdi
callq 0x5660
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeaac
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x390e2(%rip), %rax     # 0x428d0
cmpl $0x0, (%rax)
je 0x9940
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
leaq 0x60(%rsp), %rbp
movq 0x8(%rsp), %rdi
callq 0xeabc
leaq (%r12,%r12,2), %rsi
shlq $0x3, %rsi
addq (%rax), %rsi
movq %r15, %rdi
callq 0xb296
leaq 0x390a8(%rip), %rax     # 0x428d0
movl (%rax), %eax
testl %eax, %eax
je 0x9900
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x98ee
movq 0x8(%rsp), %rdi
callq 0xeabc
movq (%rax), %rsi
addq %r13, %rsi
leaq 0x48(%rsp), %rdi
callq 0xb078
movq %rbp, %rbx
movq %rbp, %rdi
movq %r15, %rsi
callq 0xb078
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %rbx, %rdx
callq 0x26bf4
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x9892
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x98a9
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
leaq 0x30(%rsp), %rdi
callq 0xf1cc
movl %eax, %ebx
movq %r15, %rdi
callq 0xf1cc
cmpl %eax, %ebx
jge 0x98ce
movq %r15, %rdi
leaq 0x30(%rsp), %rsi
callq 0xb296
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x98e5
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
leaq 0x38fe4(%rip), %rax     # 0x428d0
movl (%rax), %eax
incq %r14
movl %eax, %ecx
addq $0x18, %r13
cmpq %rcx, %r14
jb 0x9838
movq (%rsp), %rdi
callq 0xeabc
movq %rax, %rdi
movq %r15, %rsi
callq 0xb26a
incq %r12
leaq 0x38fb2(%rip), %rax     # 0x428d0
movl (%rax), %eax
cmpq %rax, %r12
jb 0x9804
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9940
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9985
movq %rax, %r14
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x9974
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
jmp 0x9974
movq %rax, %r14
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x99a4
movq 0x58(%rsp), %rsi
jmp 0x999c
movq %rax, %r14
jmp 0x99a4
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x99a4
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x99bb
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq (%rsp), %rdi
callq 0x8122
movq %r14, %rdi
callq 0x5660
// File: /workspace/github_cpp_makefile_star2_O3/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 0x248df(%rip), %r14     # 0x32803
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xe906
movq %r15, %rdi
movq %r14, %rsi
callq 0x56f0
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xdf66
movq %rsi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0xdf70
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x5430
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xdfa7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53b0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdfc2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53b0
leaq 0x249a9(%rip), %r14     # 0x32972
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5430
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x55b0
leaq 0x2361c(%rip), %rsi     # 0x3160a
movl $0xf, %edx
movq %rax, %rdi
callq 0x5430
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5430
movsd 0x8(%rsp), %xmm0
divsd 0x2340f(%rip), %xmm0    # 0x31428
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x55b0
leaq 0x235ec(%rip), %rsi     # 0x3161a
movl $0xa, %edx
movq %rax, %rdi
callq 0x5430
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5430
movsd 0x8(%rsp), %xmm0
divsd 0x233d7(%rip), %xmm0    # 0x31430
movq %rbx, %rdi
callq 0x55b0
leaq 0x235bd(%rip), %rsi     # 0x31625
movl $0xa, %edx
movq %rax, %rdi
callq 0x5430
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 0xe0a6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53b0
jmp 0xe0a6
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe0c1
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5660
// File: /workspace/github_cpp_makefile_star2_O3/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 0x82fa
leaq 0x23530(%rip), %rsi     # 0x31630
movq %r14, %rdi
callq 0x56f0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x5700
leaq 0x90(%rsp), %rdi
callq 0x50d0
testb %al, %al
je 0xe138
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xf26d
movq 0x33e31(%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 0x5310
leaq 0x118(%rsp), %rdi
callq 0x5130
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe180
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53b0
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5560
jmp 0xe1a1
jmp 0xe19e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe1b7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5660
// File: /workspace/github_cpp_makefile_star2_O3/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 0xec9b
xorl %ebp, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb078
movl $0x5, %edx
movq %rbx, %rdi
leaq 0x22adf(%rip), %rsi     # 0x31709
callq 0x5430
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5630
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2274d(%rip), %rsi     # 0x31398
callq 0x5430
movq %r15, %rdi
callq 0xf1cc
movq %r13, %rdi
movl %eax, %esi
callq 0x5630
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x23b92(%rip), %rsi     # 0x32803
callq 0x5430
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xec8c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
addq $0x18, %r14
incl %ebp
cmpq %r12, %r14
jne 0xec10
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 0xecc6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5660
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
movq %rbx, 0x10(%rsp)
subq %r15, %rbx
movq %rbx, %r13
sarq $0x3, %r13
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
sarq $0x2, %r13
testq %r13, %r13
jle 0xee1b
incq %r13
movq %r15, %rdi
callq 0xf87c
cmpl %ebp, %eax
je 0xee56
leaq 0x18(%r15), %r12
movq %r12, %rdi
callq 0xf87c
cmpl %ebp, %eax
je 0xee7d
leaq 0x30(%r15), %r12
movq %r12, %rdi
callq 0xf87c
cmpl %ebp, %eax
je 0xee7d
leaq 0x48(%r15), %r12
movq %r12, %rdi
callq 0xf87c
cmpl %ebp, %eax
je 0xee7d
addq $0x60, %r15
decq %r13
addq $-0x60, %rbx
cmpq $0x1, %r13
jg 0xedc2
sarq $0x3, %rbx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbx
cmpq $0x1, %rbx
je 0xee71
cmpq $0x2, %rbx
je 0xee5b
cmpq $0x3, %rbx
jne 0xee78
movq %r15, %rdi
callq 0xf87c
cmpl %ebp, %eax
movq 0x8(%rsp), %rbx
je 0xee6c
addq $0x18, %r15
jmp 0xee60
movq %r15, %r12
jmp 0xee7d
movq 0x8(%rsp), %rbx
movq %r15, %rdi
callq 0xf87c
cmpl %ebp, %eax
jne 0xee84
movq %r15, %r12
jmp 0xee9b
movq 0x8(%rsp), %rbx
jmp 0xee88
movq 0x10(%rsp), %r12
movq 0x8(%rsp), %rbx
jmp 0xee9b
addq $0x18, %r15
movq %r15, %rdi
callq 0xf87c
cmpl %ebp, %eax
movq 0x10(%rsp), %r12
cmoveq %r15, %r12
cmpq 0x8(%r14), %r12
je 0xeeb4
movq 0x10(%r12), %rax
movq %rax, 0x10(%rbx)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
jmp 0xeebc
movq %rbx, %rdi
callq 0xf854
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf34f
movq %rax, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
movl (%r15), %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5630
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x220dc(%rip), %r12     # 0x31398
movq %r12, %rsi
callq 0x5430
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
leaq 0x3498d(%rip), %r13     # 0x43c60
movq %r13, %rsi
movl %r14d, %edx
callq 0xed7a
movq %rbp, %rdi
callq 0xf870
movq %rbx, %rdi
callq 0x55b0
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x5430
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0xed7a
movq %r12, %rdi
callq 0xf876
movq %rbx, %rdi
movq 0x8(%rsp), %rbx
callq 0x55b0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x234cb(%rip), %rsi     # 0x32803
callq 0x5430
movq 0x10(%rsp), %rax
addq $0x4, %r15
cmpq %rax, %r15
jne 0xf29c
leaq 0x22412(%rip), %rsi     # 0x31768
movl $0xa, %edx
movq %rbx, %rdi
callq 0x5430
movq (%rsp), %rdi
callq 0xf1cc
movq %rbx, %rdi
movl %eax, %esi
callq 0x5630
leaq 0x23486(%rip), %rsi     # 0x32803
movl $0x1, %edx
movq %rax, %rdi
callq 0x5430
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_O3/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 0x344d0(%rip), %r14     # 0x43c60
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xed7a
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xed7a
movq %r15, %rdi
callq 0xf870
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0xf870
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
callq 0xf876
movsd %xmm0, 0x10(%rsp)
movq %r12, %rdi
callq 0xf876
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
divsd 0x21f4e(%rip), %xmm0    # 0x31760
sqrtsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x5190
movsd 0x21aef(%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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x215ad(%rip), %rsi     # 0x318fe
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x11f54
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 0x1d4df
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1039d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
xorb $0x1, %bl
leaq 0x28(%rsp), %rdi
callq 0x12028
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x103cd
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
leaq 0x28(%rsp), %rdi
callq 0x12028
movq %rbx, %rdi
callq 0x5660
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21262(%rip), %rsi     # 0x3198d
movq %rbx, %rdi
callq 0x5100
testl %eax, %eax
je 0x10784
leaq 0x21256(%rip), %rsi     # 0x31994
movq %rbx, %rdi
callq 0x5100
testl %eax, %eax
je 0x10788
leaq 0x21247(%rip), %rsi     # 0x31998
movq %rbx, %rdi
callq 0x5100
movl $0x2, %ecx
testl %eax, %eax
je 0x1078d
movq 0x31837(%rip), %rdi     # 0x41fa0
leaq 0x2122c(%rip), %rsi     # 0x3199c
callq 0x5390
movq %rax, %rdi
callq 0x51b0
xorl %edi, %edi
callq 0x5470
xorl %ecx, %ecx
jmp 0x1078d
movl $0x1, %ecx
leaq 0x320e4(%rip), %rax     # 0x42878
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21e9c(%rip), %rsi     # 0x32973
callq 0x5100
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x10afc
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x82fa
jmp 0x10b12
leaq 0x20d55(%rip), %rsi     # 0x31858
leaq 0x20d51(%rip), %rdx     # 0x3185b
movq %rbx, %rdi
callq 0x8264
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5600
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 0x5690
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11ec0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f5dc
jmp 0x11e98
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x11ed6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53b0
movq 0x3009b(%rip), %rsi     # 0x41f78
leaq 0x20(%rsp), %rdi
callq 0x5530
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 0x11f43
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x11f25
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53b0
movq 0x3004c(%rip), %rsi     # 0x41f78
leaq 0x20(%rsp), %rdi
callq 0x5530
leaq 0x98(%rsp), %rdi
callq 0x5130
movq %rbx, %rdi
callq 0x8206
movq %r14, %rdi
callq 0x5660
nop