LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: verifyFastCommits(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>, std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>)
vector<int> verifyFastCommits(vector<int> cancels, vector<int> choices, vector<vector<pair<int, int>>> selections)
{
    int N = choices.size();
    int f = (N - 1) / 3;
    vector<int> fast(N, -2);
    for (unsigned i = 0; i < N; i++)
    {
        int sum_zeros = 0;
        int sum_ones = 0;
        if (choices[i] != -2) // exists
        {
            if (cancels[i] == 0)
                sum_zeros++;
            if (cancels[i] == 1)
                sum_ones++;
            for (unsigned k = 0; k < selections[i].size(); k++)
            {
                if (selections[i][k].second == 0)
                    sum_zeros++;
                if (selections[i][k].second == 1)
                    sum_ones++;
            }
        }
        // compute fast commits
        if (sum_ones >= 2 * f + 1) // fast
            fast[i] = 1;
        if (sum_zeros >= f + 1) // fast
            fast[i] = 0;
    }
    return fast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
shrq $0x2, %rcx
leal -0x1(%rcx), %eax
pushq $0x3
popq %rsi
cltd
idivl %esi
movl %eax, %r13d
movslq %ecx, %r15
leaq -0x44(%rbp), %rdx
movl $0xfffffffe, (%rdx)     # imm = 0xFFFFFFFE
leaq -0x29(%rbp), %rcx
movq %r15, %rsi
callq 0x2ebe
leal (,%r13,2), %eax
movq %rbx, -0x38(%rbp)
movq (%rbx), %rcx
movl %r15d, %edx
xorl %esi, %esi
cmpq %rdx, %rsi
je 0x1b3a
movq (%r14), %r8
xorl %edi, %edi
cmpl $-0x2, (%r8,%rsi,4)
movl $0x0, %r8d
jne 0x1adb
cmpl %eax, %r8d
jle 0x1acd
movl $0x1, (%rcx,%rsi,4)
cmpl %r13d, %edi
jle 0x1ad6
andl $0x0, (%rcx,%rsi,4)
incq %rsi
jmp 0x1aa6
movq (%r12), %rdi
movl (%rdi,%rsi,4), %r9d
xorl %edi, %edi
testl %r9d, %r9d
sete %dil
xorl %r8d, %r8d
cmpl $0x1, %r9d
sete %r8b
movq -0x40(%rbp), %r9
movq (%r9), %r10
imulq $0x18, %rsi, %r11
movq (%r10,%r11), %r9
movq 0x8(%r10,%r11), %r10
subq %r9, %r10
sarq $0x3, %r10
xorl %r11d, %r11d
movl %r11d, %r11d
cmpq %r11, %r10
jbe 0x1ac1
movl 0x4(%r9,%r11,8), %r15d
cmpl $0x1, %r15d
adcl $0x0, %edi
xorl %ebx, %ebx
cmpl $0x1, %r15d
sete %bl
addl %ebx, %r8d
incl %r11d
jmp 0x1b15
movq -0x38(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Naomi1745698[P]BigPrac/test.cpp
// Function: test::test()
test::test(){
	spaceshipName = "Callum";
	//Declaring testing objects
	planet1 = new planet(planetResourceName,startResources,1,1);	
	playerShip = new gunship(spaceshipName,health,100);
	playerShip1 = new racer(spaceshipName,health+50,150);
	meteor1 = new meteor(meteorSize,1,1);
	std::cout << "testing class has been created" << std::endl << std::endl << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x40(%rdi), %r14
leaq 0x233f(%rip), %rsi      # 0x8820
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7896
movaps 0x230b(%rip), %xmm0     # 0x8800
movups %xmm0, 0x60(%rbx)
movq $0x14, 0x70(%rbx)
movl $0x19, 0x78(%rbx)
leaq 0x2314(%rip), %rsi      # 0x8823
movq %rbx, %rdi
callq 0x22d0
pushq $0x40
popq %rdi
callq 0x21b0
movq %rax, %r12
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x2220
movl 0x60(%rbx), %edx
leaq 0x48(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r12, %rdi
movl %ecx, %r8d
callq 0x3390
movq %r12, 0x30(%rbx)
leaq 0x48(%rsp), %rdi
callq 0x20d0
pushq $0x40
popq %rdi
callq 0x21b0
movq %rax, %r12
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x2220
movl 0x64(%rbx), %edx
leaq 0x28(%rsp), %rsi
pushq $0x64
popq %rcx
movq %r12, %rdi
callq 0x3626
movq %r12, 0x20(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x20d0
pushq $0x40
popq %rdi
callq 0x21b0
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2220
movl 0x64(%rbx), %edx
addl $0x32, %edx
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movl $0x96, %ecx
callq 0x37ea
movq %r12, 0x28(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x20d0
pushq $0x38
popq %rdi
callq 0x21b0
movq %rax, %r12
movl 0x78(%rbx), %esi
pushq $0x1
popq %rcx
movq %rax, %rdi
movl %ecx, %edx
callq 0x31c0
movq %r12, 0x38(%rbx)
movq 0x59e8(%rip), %rdi      # 0xbfd8
leaq 0x2233(%rip), %rsi      # 0x882a
callq 0x21a0
movq %rax, %rdi
callq 0x22f8
movq %rax, %rdi
callq 0x22f8
movq %rax, %rdi
callq 0x22f8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
pushq $0x38
jmp 0x6653
movq %rax, %r15
leaq 0x8(%rsp), %rdi
jmp 0x6647
jmp 0x664e
movq %rax, %r15
leaq 0x28(%rsp), %rdi
jmp 0x6647
jmp 0x664e
movq %rax, %r15
leaq 0x48(%rsp), %rdi
callq 0x20d0
jmp 0x6651
movq %rax, %r15
pushq $0x40
popq %rsi
movq %r12, %rdi
callq 0x21c0
jmp 0x6666
movq %rax, %r15
jmp 0x666e
movq %rax, %r15
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/Naomi1745698[P]BigPrac/test.cpp
// Function: test::meteorTesting()
void test::meteorTesting(){
	PASS = 0;
	std::cout << "the meteor size is: " << meteor1->getHealth() << std::endl;
	if(meteor1->getHealth() == 25){
		PASS++;
	}else{
		PASS--;
		std::cout << "ERROR meteorsize" << std::endl;
	};
	std::cout << "set meteor size to original + 20" << std::endl;
	meteor1->setHealth(20); //adds 20 to size
	std::cout << "the meteor size is: " << meteor1->getHealth() << std::endl;
	if(meteor1->getHealth() == 45){
		PASS++;
	}else{
		PASS--;
		std::cout << "ERROR set meteorsize" << std::endl;
	}
	if(PASS == 2){
		std::cout << "<---------------------PASS---------------->" << std::endl;		
	};
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x74(%rdi)
movq 0x48f6(%rip), %rdi      # 0xbfd8
leaq 0x13cf(%rip), %rsi      # 0x8ab8
callq 0x21a0
movq %rax, %r14
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %rdi
callq 0x22f8
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl 0x74(%rbx), %ecx
cmpl $0x19, %eax
jne 0x7724
incl %ecx
movl %ecx, 0x74(%rbx)
jmp 0x7744
decl %ecx
movl %ecx, 0x74(%rbx)
movq 0x48a8(%rip), %rdi      # 0xbfd8
leaq 0x1396(%rip), %rsi      # 0x8acd
callq 0x21a0
movq %rax, %rdi
callq 0x22f8
movq 0x488d(%rip), %r14      # 0xbfd8
leaq 0x138c(%rip), %rsi      # 0x8ade
movq %r14, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x22f8
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
pushq $0x14
popq %rsi
callq *0x10(%rax)
leaq 0x1342(%rip), %rsi      # 0x8ab8
movq %r14, %rdi
callq 0x21a0
movq %rax, %r14
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %rdi
callq 0x22f8
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl 0x74(%rbx), %ecx
cmpl $0x2d, %eax
jne 0x77b4
incl %ecx
movl %ecx, 0x74(%rbx)
jmp 0x77d7
decl %ecx
movl %ecx, 0x74(%rbx)
movq 0x4818(%rip), %rdi      # 0xbfd8
leaq 0x1338(%rip), %rsi      # 0x8aff
callq 0x21a0
movq %rax, %rdi
callq 0x22f8
movl 0x74(%rbx), %ecx
cmpl $0x2, %ecx
jne 0x77fe
movq 0x47f5(%rip), %rdi      # 0xbfd8
leaq 0x123f(%rip), %rsi      # 0x8a29
callq 0x21a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22f8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Naomi1745698[P]BigPrac/test.cpp
// Function: test::~test()
test::~test(){
	delete playerShip;
	delete playerShip1;	
	delete planet1;
	delete meteor1;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x781e
movq %r14, %rdi
callq 0x35d2
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x21c0
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x783a
movq %r14, %rdi
callq 0x35d2
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x21c0
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x7856
movq %r14, %rdi
callq 0x30c2
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x21c0
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x7872
movq %r14, %rdi
callq 0x30c2
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x21c0
leaq 0x40(%rbx), %rdi
callq 0x20d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/equiv-istream-iter.cc
// Function: main
int main() {
	// use istream_iterator to initialize a vector
	istream_iterator<int> in_iter(cin), eof;  
	vector<int> vec(in_iter, eof);  

	for (auto it : vec)
		cout << it << " ";
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq 0x2d4e(%rip), %rsi      # 0x3fe0
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x1344
movq (%rbx), %rax
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%rsi)
movb 0xc(%rbx), %al
movb %al, 0xc(%rsi)
leaq -0x50(%rbp), %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movb $0x0, 0xc(%rdx)
leaq -0x40(%rbp), %rbx
leaq -0x21(%rbp), %rcx
movq %rbx, %rdi
callq 0x1356
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movq 0x2cee(%rip), %rbx      # 0x3fd0
leaq 0xd1b(%rip), %r14       # 0x2004
cmpq %r12, %r15
je 0x130a
movl (%r15), %esi
movq %rbx, %rdi
callq 0x1120
movq %rax, %rdi
movq %r14, %rsi
callq 0x10b0
addq $0x4, %r15
jmp 0x12e9
movq 0x2cbf(%rip), %rdi      # 0x3fd0
callq 0x1060
leaq -0x40(%rbp), %rdi
callq 0x1478
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1330
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1478
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/main.cpp
// Function: main
int main() {

  // A list of futures.
  std::list<std::future<void>> list;

  // Producer and consumer thread pools.
  thread::pool::parameterized_pool_t<1, 0> pool_of_consumers(std::thread::hardware_concurrency() + 1);

  // Scheduling the producers.
  for (size_t i = 0; i < work_to_spawn; ++i) {
    list.push_back(pool_of_consumers.schedule(static_void_function));
  }
  
  // Counting the start time.
  auto start = std::chrono::high_resolution_clock::now();

  // Waiting for the consumers to complete.
  for (std::future<void>& future : list) {
    future.wait();
  }

  // Measuring and dumping the elapsed time.
  auto end = std::chrono::high_resolution_clock::now();
  std::chrono::duration<double, std::milli> diff = end - start;
  std::cout << "Elasped time : " << diff.count() << " ms" << std::endl;

  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
callq 0x32d0
leal 0x1(%rax), %esi
leaq 0x30(%rsp), %rdi
callq 0x368c
movl $0x2710, %ebp           # imm = 0x2710
leaq 0x28(%rsp), %r14
leaq 0xfd(%rip), %r15        # 0x363e
leaq 0x20(%rsp), %r12
leaq 0x30(%rsp), %r13
leaq 0x8(%rsp), %rbx
subq $0x1, %rbp
jb 0x3579
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x375a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x374e
movq %r14, %rdi
callq 0x3920
jmp 0x3550
callq 0x3040
movq %rax, %r14
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x3597
leaq 0x10(%r15), %rdi
callq 0x386e
jmp 0x3584
callq 0x3040
movq %rax, %rbx
movq 0x9a12(%rip), %rdi      # 0xcfb8
leaq 0x3a73(%rip), %rsi      # 0x7020
callq 0x3240
subq %r14, %rbx
cvtsi2sd %rbx, %xmm0
divsd 0x3a46(%rip), %xmm0     # 0x7008
movq %rax, %rdi
callq 0x3310
leaq 0x3a5f(%rip), %rsi      # 0x7030
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
callq 0x3110
leaq 0x30(%rsp), %rdi
callq 0x3880
leaq 0x8(%rsp), %rdi
callq 0x399c
xorl %eax, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x362c
jmp 0x3612
jmp 0x3612
movq %rax, %rbx
jmp 0x3622
movq %rax, %rbx
movq %r14, %rdi
callq 0x3920
leaq 0x30(%rsp), %rdi
callq 0x3880
leaq 0x8(%rsp), %rdi
callq 0x399c
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/thread_pool.hpp
// Function: std::future<std::result_of<void (& ())()>::type> thread::pool::parameterized_pool_t<1ul, 0l>::schedule<void (&)()>(void (&)())
std::future<typename std::result_of<F(Args...)>::type> schedule(F&& f, Args&&... args) {
        using return_type = typename std::result_of<F(Args...)>::type;
        auto task = std::make_shared<std::packaged_task<return_type()>>(
          std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        std::future<return_type> future = task->get_future();
        if (!tasks_.enqueue([task] () { (*task)(); })) {
          throw std::length_error("Couldn't enqueue the given callable object");
        }
        return (future);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
movq %rdx, (%rsi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4b8d
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x4bac
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x675c
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x4c24
addq $0x18, %r14
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x4bf8
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x5276
leaq 0x20(%rsp), %rdi
callq 0x3920
testb %bpl, %bpl
je 0x37ed
leaq 0x10(%rsp), %rdi
callq 0x3920
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %r15
leaq 0x3ffe(%rip), %rsi      # 0x77fd
movq %rax, %rdi
callq 0x3280
movq 0x97c2(%rip), %rsi      # 0xcfd0
movq 0x978b(%rip), %rdx      # 0xcfa0
movq %r15, %rdi
callq 0x3380
movq %rax, %r14
jmp 0x384b
movq %rax, %r14
movq %r15, %rdi
callq 0x3190
jmp 0x384b
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5276
jmp 0x3841
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3920
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x3920
jmp 0x385c
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3920
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/thread_pool.hpp
// Function: thread::pool::parameterized_pool_t<1ul, 0l>::worker()
void worker() {
        auto token = create_token_of<thread::pool::consumer_token_t>();
        while (!done_) {
          consumer_t runnable[BULK_MAX_ITEMS] = {};
          auto available = tasks_.wait_dequeue_bulk_timed(token, runnable, BULK_MAX_ITEMS, std::chrono::milliseconds(DEQUEUE_TIMEOUT));
          for (size_t i = 0; i < available; ++i) {
            runnable[i]();
          }
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x38(%rsp), %rcx
andl $0x0, 0x8(%rcx)
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
pushq $0x1
popq %rax
lock
xaddl %eax, 0x274(%rdi)
movl %eax, (%rcx)
orl $-0x1, 0x4(%rcx)
leaq 0x18(%rdi), %r15
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movb 0x290(%r14), %al
testb $0x1, %al
jne 0x3b16
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
movq %r13, %rdx
pushq $0x1
popq %rcx
movq %rbp, %r8
callq 0x4160
movq %rax, %rbx
movq %r13, %r12
subq $0x1, %rbx
jb 0x3b0c
movq %r12, %rdi
callq 0x4178
addq $0x20, %r12
jmp 0x3af8
movq %r13, %rdi
callq 0x5276
jmp 0x3abe
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b27
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5276
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ConcurrentQueue(unsigned long)
explicit ConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
		: producerListTail(nullptr),
		producerCount(0),
		initialBlockPoolIndex(0),
		nextExplicitConsumerId(0),
		globalExplicitConsumerOffset(0)
	{
		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
		populate_initial_implicit_producer_hash();
		populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
		
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
		// Track all the producers using a fully-resolved typed list for
		// each kind; this makes it possible to debug them starting from
		// the root queue object (otherwise wacky casts are needed that
		// don't compile in the debugger's expression evaluator).
		explicitProducers.store(nullptr, std::memory_order_relaxed);
		implicitProducers.store(nullptr, std::memory_order_relaxed);
#endif
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, (%rdi)
andl $0x0, 0x8(%rdi)
movq %rsi, %r14
andq $0x0, 0x10(%rdi)
andq $0x0, 0x28(%rdi)
addq $0x58, %rdi
callq 0x3d5e
andq $0x0, 0x25c(%rbx)
movb $0x0, 0x258(%rbx)
movq %rbx, %rdi
callq 0x3d74
movq %r14, %rsi
shrq $0x5, %rsi
andl $0x1f, %r14d
cmpq $0x1, %r14
sbbq $-0x1, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3db4
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::~ConcurrentQueue()
~ConcurrentQueue()
	{
		// Destroy producers
		auto ptr = producerListTail.load(std::memory_order_relaxed);
		while (ptr != nullptr) {
			auto next = ptr->next_prod();
			if (ptr->token != nullptr) {
				ptr->token->producer = nullptr;
			}
			destroy(ptr);
			ptr = next;
		}
		
		// Destroy implicit producer hash tables
		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
			auto hash = implicitProducerHash.load(std::memory_order_relaxed);
			while (hash != nullptr) {
				auto prev = hash->prev;
				if (prev != nullptr) {		// The last hash is part of this object and was not allocated dynamically
					for (size_t i = 0; i != hash->capacity; ++i) {
						hash->entries[i].~ImplicitProducerKVP();
					}
					hash->~ImplicitProducerHash();
					(Traits::free)(hash);
				}
				hash = prev;
			}
		}
		
		// Destroy global free list
		auto block = freeList.head_unsafe();
		while (block != nullptr) {
			auto next = block->freeListNext.load(std::memory_order_relaxed);
			if (block->dynamicallyAllocated) {
				destroy(block);
			}
			block = next;
		}
		
		// Destroy initial free list
		destroy_array(initialBlockPool, initialBlockPoolSize);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3d03
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rax
leaq -0x8(%rcx), %r14
testq %rcx, %rcx
cmoveq %rcx, %r14
testq %rax, %rax
je 0x3cf9
andq $0x0, (%rax)
callq 0x3f26
movq %r14, %rdi
jmp 0x3cd8
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x3d1f
movq %r14, %rdi
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x3d07
callq 0x3290
jmp 0x3d07
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x3d42
movq %r14, %rdi
movq 0x438(%r14), %r14
cmpb $0x1, 0x441(%rdi)
jne 0x3d23
callq 0x3290
jmp 0x3d23
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3f40
movq %rax, %rdi
callq 0x3914
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::populate_initial_block_list(unsigned long)
void populate_initial_block_list(size_t blockCount)
	{
		initialBlockPoolSize = blockCount;
		if (initialBlockPoolSize == 0) {
			initialBlockPool = nullptr;
			return;
		}
		
		initialBlockPool = create_array<Block>(blockCount);
		if (initialBlockPool == nullptr) {
			initialBlockPoolSize = 0;
		}
		for (size_t i = 0; i < initialBlockPoolSize; ++i) {
			initialBlockPool[i].dynamicallyAllocated = false;
		}
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x20(%rdi)
testq %rsi, %rsi
je 0x3dd8
movq %rsi, %rdi
callq 0x3dfe
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3ddf
movq 0x20(%rbx), %rcx
jmp 0x3de6
andq $0x0, 0x18(%rbx)
popq %rbx
retq
andq $0x0, 0x20(%rbx)
xorl %ecx, %ecx
addq $0x441, %rax            # imm = 0x441
subq $0x1, %rcx
jb 0x3ddd
movb $0x0, (%rax)
addq $0x448, %rax            # imm = 0x448
jmp 0x3dec
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>::create_array<moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::Block>(unsigned long)
static inline U* create_array(size_t count)
	{
		assert(count > 0);
		U* p = static_cast<U*>(aligned_malloc<U>(sizeof(U) * count));
		if (p == nullptr)
			return nullptr;

		for (size_t i = 0; i != count; ++i)
			new (p + i) U();
		return p;
	}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3e49
movq %rdi, %rbx
imulq $0x448, %rdi, %rdi      # imm = 0x448
callq 0x32c0
testq %rax, %rax
je 0x3e47
movq %rax, %rcx
addq $0x441, %rcx            # imm = 0x441
xorps %xmm0, %xmm0
subq $0x1, %rbx
jb 0x3e47
andl $0x0, -0x11(%rcx)
andq $0x0, -0x9(%rcx)
movw $0x100, -0x1(%rcx)      # imm = 0x100
movups %xmm0, -0x41(%rcx)
addq $0x448, %rcx            # imm = 0x448
jmp 0x3e25
popq %rbx
retq
leaq 0x31e4(%rip), %rdi      # 0x7034
leaq 0x31e7(%rip), %rsi      # 0x703e
leaq 0x3206(%rip), %rcx      # 0x7064
movl $0xe11, %edx            # imm = 0xE11
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::details::Semaphore::Semaphore(int)
Semaphore(int initialCount = 0)
	{
		assert(initialCount >= 0);
		int rc = sem_init(&m_sema, 0, static_cast<unsigned int>(initialCount));
		assert(rc == 0);
		(void)rc;
	}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x3ee8
movl %esi, %edx
xorl %esi, %esi
callq 0x31d0
testl %eax, %eax
jne 0x3f07
popq %rax
retq
leaq 0x3259(%rip), %rdi      # 0x7148
leaq 0x3264(%rip), %rsi      # 0x715a
leaq 0x32db(%rip), %rcx      # 0x71d8
movl $0xb1, %edx
callq 0x3170
leaq 0x32f9(%rip), %rdi      # 0x7207
leaq 0x3245(%rip), %rsi      # 0x715a
leaq 0x32bc(%rip), %rcx      # 0x71d8
movl $0xb3, %edx
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/blocking_concurrent_queue.hpp
// Function: unsigned long moodycamel::BlockingConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::wait_dequeue_bulk_timed<std::function<void ()>*&>(moodycamel::ConsumerToken&, std::function<void ()>*&, unsigned long, long)
inline size_t wait_dequeue_bulk_timed(consumer_token_t& token, It itemFirst, size_t max, std::int64_t timeout_usecs)
	{
		size_t count = 0;
		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs);
		while (count != max) {
			count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
		}
		return count;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x270(%rdi), %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x41da
movq %rax, %r12
xorl %r13d, %r13d
movq %r12, %rcx
subq %r13, %rcx
je 0x41cd
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x423a
addq %rax, %r13
jmp 0x41b2
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x421b
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x432a
testq %rax, %rax
setne %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x4215
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x437c
popq %rbx
popq %r14
popq %r15
retq
leaq 0x30f3(%rip), %rdi      # 0x7315
leaq 0x2f31(%rip), %rsi      # 0x715a
leaq 0x30ee(%rip), %rcx      # 0x731e
movl $0x17b, %edx            # imm = 0x17B
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: unsigned long moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::try_dequeue_bulk<std::function<void ()>*&>(moodycamel::ConsumerToken&, std::function<void ()>*&, unsigned long)
size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
	{
		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
			if (!update_current_producer_after_rotation(token)) {
				return 0;
			}
		}
		
		size_t count = static_cast<ProducerBase*>(token.currentProducer)->dequeue_bulk(itemFirst, max);
		if (count == max) {
			if ((token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(max)) >= EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
			}
			return max;
		}
		token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(count);
		max -= count;
		
		auto tail = producerListTail.load(std::memory_order_acquire);
		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
		if (ptr == nullptr) {
			ptr = tail;
		}
		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
			auto dequeued = ptr->dequeue_bulk(itemFirst, max);
			count += dequeued;
			if (dequeued != 0) {
				token.currentProducer = ptr;
				token.itemsConsumedFromCurrent = static_cast<std::uint32_t>(dequeued);
			}
			if (dequeued == max) {
				break;
			}
			max -= dequeued;
			ptr = ptr->next_prod();
			if (ptr == nullptr) {
				ptr = tail;
			}
		}
		return count;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
cmpq $0x0, 0x18(%rsi)
je 0x4265
movl 0x260(%r13), %eax
cmpl %eax, 0x4(%r14)
je 0x4274
movq %r13, %rdi
movq %r14, %rsi
callq 0x4548
testb %al, %al
je 0x42ab
movq 0x10(%r14), %rdi
addq $-0x8, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x45fa
movq %rbx, %r12
movl 0x8(%r14), %ecx
subq %rax, %r12
jne 0x42bf
addl %ebx, %ecx
movl %ecx, 0x8(%r14)
cmpl $0x100, %ecx            # imm = 0x100
jb 0x42ad
lock
incl 0x260(%r13)
jmp 0x42ad
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl %eax, %ecx
movl %ecx, 0x8(%r14)
movq (%r13), %rbp
movq 0x10(%r14), %rcx
movq (%rcx), %rdx
leaq -0x8(%rdx), %r13
testq %rdx, %rdx
cmoveq %rbp, %r13
movq %rax, %rbx
leaq -0x8(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
cmpq %rax, %r13
je 0x42ad
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x45fa
testq %rax, %rax
je 0x430d
leaq 0x8(%r13), %rcx
movq %rcx, 0x10(%r14)
movl %eax, 0x8(%r14)
addq %rax, %rbx
subq %rax, %r12
je 0x42ad
movq 0x8(%r13), %rax
leaq -0x8(%rax), %r13
testq %rax, %rax
cmoveq %rbp, %r13
movq 0x10(%r14), %rcx
jmp 0x42de
// File: /workspace/github_cpp_makefile_star2_O2/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 0x435c
movq (%rdi), %rdx
xorl %ecx, %ecx
testq %rdx, %rdx
jle 0x4358
movq %rdx, %r8
subq %rsi, %r8
cmovleq %rcx, %r8
movq %rdx, %rax
lock
cmpxchgq %r8, (%rdi)
je 0x4352
movq %rax, %rdx
jmp 0x4334
subq %r8, %rdx
movq %rdx, %rcx
movq %rcx, %rax
retq
pushq %rax
leaq 0x2fb1(%rip), %rdi      # 0x7315
leaq 0x2def(%rip), %rsi      # 0x715a
leaq 0x2ff6(%rip), %rcx      # 0x7368
movl $0x16d, %edx            # imm = 0x16D
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4441
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rdi), %ecx
xorl %esi, %esi
testl %ecx, %ecx
jle 0x43bc
movq (%r14), %r15
testq %r15, %r15
jle 0x43b8
movq %r15, %rdi
subq %rbx, %rdi
cmovleq %rsi, %rdi
movq %r15, %rax
lock
cmpxchgq %rdi, (%r14)
je 0x43ce
decl %ecx
jmp 0x4398
lock
decq (%r14)
jl 0x43f6
cmpq $0x1, %rbx
jne 0x43d3
pushq $0x1
popq %r15
jmp 0x43e7
subq %rdi, %r15
jmp 0x43e7
decq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x432a
movq %rax, %r15
incq %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rdx, %rdx
je 0x4417
leaq 0x8(%r14), %rdi
testq %rdx, %rdx
js 0x440e
movq %rdx, %rsi
callq 0x448c
jmp 0x4413
callq 0x4460
testb %al, %al
jne 0x43c2
leaq 0x8(%r14), %r12
xorl %r15d, %r15d
movq (%r14), %rax
testq %rax, %rax
js 0x4434
movq %r12, %rdi
callq 0x451c
testb %al, %al
je 0x441e
jmp 0x43c2
leaq 0x1(%rax), %rcx
lock
cmpxchgq %rcx, (%r14)
jne 0x441e
jmp 0x43e7
leaq 0x2f5f(%rip), %rdi      # 0x73a7
leaq 0x2d0b(%rip), %rsi      # 0x715a
leaq 0x2f59(%rip), %rcx      # 0x73af
movl $0x12c, %edx            # imm = 0x12C
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::details::Semaphore::timed_wait(unsigned long)
bool timed_wait(std::uint64_t usecs)
	{
		struct timespec ts;
		const int usecs_in_1_sec = 1000000;
		const int nsecs_in_1_sec = 1000000000;
		clock_gettime(CLOCK_REALTIME, &ts);
		ts.tv_sec += (time_t)(usecs / usecs_in_1_sec);
		ts.tv_nsec += (long)(usecs % usecs_in_1_sec) * 1000;
		// sem_timedwait bombs if you have more than 1e9 in tv_nsec
		// so we have to clean things up before passing it in
		if (ts.tv_nsec >= nsecs_in_1_sec) {
			ts.tv_nsec -= nsecs_in_1_sec;
			++ts.tv_sec;
		}

		int rc;
		do {
			rc = sem_timedwait(&m_sema, &ts);
		} while (rc == -1 && errno == EINTR);
		return rc == 0;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x3200
movl $0xf4240, %ecx          # imm = 0xF4240
movq %r14, %rax
xorl %edx, %edx
divq %rcx
addq (%r15), %rax
movq %rax, (%r15)
imulq $0x3e8, %rdx, %rcx      # imm = 0x3E8
addq 0x8(%r15), %rcx
movq %rcx, 0x8(%r15)
cmpq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
jl 0x44ea
addq $-0x3b9aca00, %rcx      # imm = 0xC4653600
movq %rcx, 0x10(%rsp)
incq %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3320
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x450b
callq 0x3030
cmpl $0x4, (%rax)
je 0x44ef
testl %ebp, %ebp
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::get_block_index_index_for_index(unsigned long, moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::BlockIndexHeader*&) const
inline size_t get_block_index_index_for_index(index_t index, BlockIndexHeader*& localBlockIndex) const
		{
#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
			debug::DebugLock lock(mutex);
#endif
			index &= ~static_cast<index_t>(BLOCK_SIZE - 1);
			localBlockIndex = blockIndex.load(std::memory_order_acquire);
			auto tail = localBlockIndex->tail.load(std::memory_order_acquire);
			auto tailBase = localBlockIndex->index[tail]->key.load(std::memory_order_relaxed);
			assert(tailBase != INVALID_BLOCK_BASE);
			// Note: Must use division instead of shift because the index may wrap around, causing a negative
			// offset, whose negativity we want to preserve
			auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(index - tailBase) / BLOCK_SIZE);
			size_t idx = (tail + offset) & (localBlockIndex->capacity - 1);
			assert(localBlockIndex->index[idx]->key.load(std::memory_order_relaxed) == index && localBlockIndex->index[idx]->value.load(std::memory_order_relaxed) != nullptr);
			return idx;
		}

// Assembly:
pushq %rax
movq 0x60(%rdi), %rax
movq %rax, (%rdx)
movq 0x8(%rax), %rax
movq (%rdx), %rdx
movq 0x18(%rdx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rdi
cmpq $0x1, %rdi
je 0x4a34
andq $-0x20, %rsi
movq %rsi, %r8
subq %rdi, %r8
shrq $0x5, %r8
addq %rax, %r8
movq (%rdx), %rax
decq %rax
andq %r8, %rax
movq (%rcx,%rax,8), %rcx
movq (%rcx), %rdx
cmpq %rsi, %rdx
jne 0x4a15
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x4a15
popq %rcx
retq
leaq 0x2c26(%rip), %rdi      # 0x7642
leaq 0x261b(%rip), %rsi      # 0x703e
leaq 0x2b36(%rip), %rcx      # 0x7560
movl $0xb81, %edx            # imm = 0xB81
callq 0x3170
leaq 0x2b06(%rip), %rdi      # 0x7541
leaq 0x25fc(%rip), %rsi      # 0x703e
leaq 0x2b17(%rip), %rcx      # 0x7560
movl $0xb7c, %edx            # imm = 0xB7C
callq 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/blocking_concurrent_queue.hpp
// Function: moodycamel::BlockingConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::enqueue(std::function<void ()>&&)
inline bool enqueue(T&& item)
	{
		if ((details::likely)(inner.enqueue(std::move(item)))) {
			sema->signal();
			return true;
		}
		return false;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5af2
movl %eax, %ebx
testb %al, %al
je 0x4c19
movq 0x270(%r14), %rdi
pushq $0x1
popq %rsi
callq 0x5aac
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
js 0x5ad2
movq %rsi, %rax
lock
xaddq %rsi, (%rdi)
negq %rsi
cmpq %rax, %rsi
cmovgeq %rax, %rsi
testq %rsi, %rsi
jle 0x5ad1
addq $0x8, %rdi
jmp 0x6736
retq
pushq %rax
leaq 0x251a(%rip), %rdi      # 0x7ff4
leaq 0x1679(%rip), %rsi      # 0x715a
leaq 0x2517(%rip), %rcx      # 0x7fff
movl $0x18b, %edx            # imm = 0x18B
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rcx
xorl %edi, %edi
testq %rcx, %rcx
je 0x5e88
movb 0x10(%rcx), %al
testb $0x1, %al
je 0x5e77
cmpb %sil, 0x48(%rcx)
jne 0x5e77
movb $0x1, %al
lock
cmpxchgb %dil, 0x10(%rcx)
je 0x5ebe
movq 0x8(%rcx), %rax
leaq -0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
jmp 0x5e5b
movb $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
testb %sil, %sil
je 0x5e9f
movq %rbx, (%rdi)
callq 0x5f26
jmp 0x5ea7
movq %rbx, (%rdi)
callq 0x5f56
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5f00
movq %rax, %rcx
movq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq
movb $0x1, (%rdx)
jmp 0x5eb5
nop
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::details::_hash_32_or_64<true>::hash(unsigned long)
static inline std::uint64_t hash(std::uint64_t h)
		{
			h ^= h >> 33;
			h *= 0xff51afd7ed558ccd;
			h ^= h >> 33;
			h *= 0xc4ceb9fe1a85ec53;
			return h ^ (h >> 33);
		}

// Assembly:
movq %rdi, %rax
shrq $0x21, %rax
xorq %rdi, %rax
movabsq $-0xae502812aa7333, %rcx # imm = 0xFF51AFD7ED558CCD
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movabsq $-0x3b314601e57a13ad, %rcx # imm = 0xC4CEB9FE1A85EC53
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: bool moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::insert_block_index_entry<(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::AllocationMode)0>(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::BlockIndexEntry*&, unsigned long)
ConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
		: producerListTail(nullptr),
		producerCount(0),
		initialBlockPoolIndex(0),
		nextExplicitConsumerId(0),
		globalExplicitConsumerOffset(0)
	{
		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
		populate_initial_implicit_producer_hash();
		size_t blocks = (((minCapacity + BLOCK_SIZE - 1) / BLOCK_SIZE) - 1) * (maxExplicitProducers + 1) + 2 * (maxExplicitProducers + maxImplicitProducers);
		populate_initial_block_list(blocks);
		
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
		explicitProducers.store(nullptr, std::memory_order_relaxed);
		implicitProducers.store(nullptr, std::memory_order_relaxed);
#endif
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x65e8
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rax), %rdx
incq %rdx
movq (%rax), %rcx
movq 0x18(%rax), %rsi
decq %rcx
andq %rdx, %rcx
movq (%rsi,%rcx,8), %rdx
movq %rdx, (%r14)
movq (%rdx), %rsi
cmpq $0x1, %rsi
je 0x65dd
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x65dd
movq %rdi, %r15
callq 0x62e8
testb %al, %al
je 0x65e8
movq 0x60(%r15), %rax
movq 0x8(%rax), %rdx
incq %rdx
movq (%rax), %rcx
movq 0x18(%rax), %rsi
decq %rcx
andq %rdx, %rcx
movq (%rsi,%rcx,8), %rdx
movq %rdx, (%r14)
movq (%rdx), %rsi
cmpq $0x1, %rsi
jne 0x65f0
movq %rbx, (%rdx)
movq %rcx, 0x8(%rax)
movb $0x1, %al
jmp 0x65ea
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1732(%rip), %rdi      # 0x7d29
leaq 0xa40(%rip), %rsi       # 0x703e
leaq 0x1768(%rip), %rcx      # 0x7d6d
movl $0xb60, %edx            # imm = 0xB60
callq 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O2/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::FreeList<moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::Block>::try_get()
inline N* try_get()
		{
#ifdef MCDBGQ_NOLOCKFREE_FREELIST
			debug::DebugLock lock(mutex);
#endif		
			auto head = freeListHead.load(std::memory_order_acquire);
			while (head != nullptr) {
				auto prevHead = head;
				auto refs = head->freeListRefs.load(std::memory_order_relaxed);
				if ((refs & REFS_MASK) == 0 || !head->freeListRefs.compare_exchange_strong(refs, refs + 1, std::memory_order_acquire, std::memory_order_relaxed)) {
					head = freeListHead.load(std::memory_order_acquire);
					continue;
				}
				
				// Good, reference count has been incremented (it wasn't at zero), which means we can read the
				// next and not worry about it changing between now and the time we do the CAS
				auto next = head->freeListNext.load(std::memory_order_relaxed);
				if (freeListHead.compare_exchange_strong(head, next, std::memory_order_acquire, std::memory_order_relaxed)) {
					// Yay, got the node. This means it was on the list, which means shouldBeOnFreeList must be false no
					// matter the refcount (because nobody else knows it's been taken off yet, it can't have been put back on).
					assert((head->freeListRefs.load(std::memory_order_relaxed) & SHOULD_BE_ON_FREELIST) == 0);
					
					// Decrease refcount twice, once for our ref, and once for the list's ref
					head->freeListRefs.fetch_sub(2, std::memory_order_release);
					return head;
				}
				
				// OK, the head must have changed on us, but we still need to decrease the refcount we increased.
				// Note that we don't need to release any memory effects, but we do need to ensure that the reference
				// count decrement happens-after the CAS on the head.
				refs = prevHead->freeListRefs.fetch_sub(1, std::memory_order_acq_rel);
				if (refs == SHOULD_BE_ON_FREELIST + 1) {
					add_knowing_refcount_is_zero(prevHead);
				}
			}
			
			return nullptr;
		}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
pushq $-0x1
popq %rbp
movq %r14, %rsi
testq %r14, %r14
je 0x670f
movl 0x430(%rsi), %eax
testl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x66f8
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x430(%rsi)
jne 0x66f8
movq 0x438(%rsi), %rcx
movq %rsi, %rax
lock
cmpxchgq %rcx, (%rbx)
je 0x66fd
movq %rax, %r14
movl %ebp, %eax
lock
xaddl %eax, 0x430(%rsi)
cmpl $0x80000001, %eax       # imm = 0x80000001
jne 0x66a7
movq %rbx, %rdi
callq 0x4aa8
jmp 0x66a7
movq (%rbx), %r14
jmp 0x66a7
movl 0x430(%rsi), %eax
testl %eax, %eax
js 0x6717
lock
subl $0x2, 0x430(%rsi)
movq %rsi, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x176c(%rip), %rdi      # 0x7e8a
leaq 0x919(%rip), %rsi       # 0x703e
leaq 0x17b0(%rip), %rcx      # 0x7edc
movl $0x5c0, %edx            # imm = 0x5C0
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x378, %rsp            # imm = 0x378
movq %rdi, %rbx
leaq 0x356bc(%rip), %rsi     # 0x3c898
leaq 0x35695(%rip), %rdx     # 0x3c878
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x9173
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
callq 0xc668
leaq 0x38(%rsp), %rdi
callq 0x56f8
movq %rsp, %rdi
leaq 0x70(%rsp), %rsi
callq 0xd450
leaq 0x36a35(%rip), %rdi     # 0x3dc50
movq %rsp, %rsi
callq 0xbb7c
movq %rsp, %rdi
callq 0x9640
leaq 0x3568e(%rip), %rax     # 0x3c8c0
movl (%rax), %r14d
cvtsi2sd %r14, %xmm0
leaq 0x35677(%rip), %rax     # 0x3c8b8
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %r15
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x72a2
leaq 0x35619(%rip), %rsi     # 0x3c878
leaq 0x18(%rsp), %rdi
callq 0x54a0
leaq 0x58(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movl %r15d, %ecx
callq 0xd484
leaq 0x58(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6d8c
movq %r12, %rdi
callq 0x6dde
leaq 0x18(%rsp), %rdi
callq 0x56f8
subl %r15d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x730d
leaq 0x70(%rsp), %rdi
callq 0x91ac
addq $0x378, %rsp            # imm = 0x378
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x56f8
jmp 0x72ec
jmp 0x72e9
jmp 0x72e9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9640
jmp 0x72ec
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x91ac
jmp 0x7305
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r14
leaq 0x35491(%rip), %r15     # 0x3c7b8
leaq 0x20(%rsp), %r12
movq %rsp, %r13
leaq 0x35592(%rip), %rbp     # 0x3c8c8
subl $0x1, %ebx
jb 0x73ea
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
cmpl $0x1, (%r15)
ja 0x7387
movq %r12, %rdi
leaq 0x368f4(%rip), %rsi     # 0x3dc50
callq 0xbb16
movq %r13, %rdi
movq %r12, %rsi
callq 0x96de
movq %r12, %rdi
callq 0x6e4c
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbp, %rdx
callq 0x925d
jmp 0x73a2
movq %r12, %rdi
callq 0x7560
movq %r13, %rdi
movq %r12, %rsi
callq 0x96de
movq %r12, %rdi
callq 0x6e4c
movl (%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x73ca
movq %r12, %rdi
movq %r13, %rsi
callq 0x1aeb4
movq %r13, %rdi
movq %r12, %rsi
callq 0x96de
movq %r12, %rdi
callq 0x6e4c
movq %r14, %rdi
callq 0xb988
movq %rax, %rdi
movq %r13, %rsi
callq 0x938a
movq %r13, %rdi
callq 0x6e4c
jmp 0x7336
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x73ff
jmp 0x73ff
jmp 0x73ff
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6e4c
movq %rbx, %rdi
callq 0x5610