// 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::enqueue<(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::AllocationMode)0, std::function<void ()>>(std::function<void ()>&&)
inline bool enqueue(U&& element)
		{
			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
			index_t newTailIndex = 1 + currentTailIndex;
			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
				// We reached the end of a block, start a new one
				auto head = this->headIndex.load(std::memory_order_relaxed);
				assert(!details::circular_less_than<index_t>(currentTailIndex, head));
				if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
					return false;
				}
#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
				debug::DebugLock lock(mutex);
#endif
				// Find out where we'll be inserting this block in the block index
				BlockIndexEntry* idxEntry;
				if (!insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) {
					return false;
				}
				
				// Get ahold of a new block
				auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
				if (newBlock == nullptr) {
					rewind_block_index_tail();
					idxEntry->value.store(nullptr, std::memory_order_relaxed);
					return false;
				}
#ifdef MCDBGQ_TRACKMEM
				newBlock->owner = this;
#endif
				newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();

				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
					// May throw, try to insert now before we publish the fact that we have this new block
					MOODYCAMEL_TRY {
						new ((*newBlock)[currentTailIndex]) T(std::forward<U>(element));
					}
					MOODYCAMEL_CATCH (...) {
						rewind_block_index_tail();
						idxEntry->value.store(nullptr, std::memory_order_relaxed);
						this->parent->add_block_to_free_list(newBlock);
						MOODYCAMEL_RETHROW;
					}
				}
				
				// Insert the new block into the index
				idxEntry->value.store(newBlock, std::memory_order_relaxed);
				
				this->tailBlock = newBlock;
				
				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
					this->tailIndex.store(newTailIndex, std::memory_order_release);
					return true;
				}
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq %r14, %r12
andq $0x1f, %r12
je 0x5d95
movq 0x40(%rbx), %rax
incq %r14
shll $0x5, %r12d
addq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4994
movq %r14, 0x20(%rbx)
movb $0x1, %al
jmp 0x5e23
movabsq $0x7fffffffffffffdf, %rax # imm = 0x7FFFFFFFFFFFFFDF
movq 0x28(%rbx), %rcx
movq %r14, %rdx
subq %rcx, %rdx
leaq 0x21(%rax), %rsi
cmpq %rsi, %rdx
ja 0x5e2f
subq %r14, %rcx
addq %rax, %rcx
addq $0x20, %rax
cmpq %rax, %rcx
jae 0x5e21
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6568
testb %al, %al
je 0x5e21
movq 0x50(%rbx), %rdi
callq 0x6610
testq %rax, %rax
je 0x5dfd
movq $0x0, 0x408(%rax)
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movq %rax, 0x40(%rbx)
jmp 0x5d75
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rcx
decq %rcx
movq (%rax), %rdx
decq %rdx
andq %rcx, %rdx
movq %rdx, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1da4(%rip), %rdi      # 0x7bda
leaq 0x1201(%rip), %rsi      # 0x703e
leaq 0x1dd4(%rip), %rcx      # 0x7c18
movl $0x9af, %edx            # imm = 0x9AF
callq 0x3170