// File: HQarroum[P]thread-pool/examples/many-producers-many-consumers/./../../includes/concurrent_queue.hpp
// Function: bool moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::enqueue_bulk<(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::AllocationMode)0, std::function<void ()> const*>(std::function<void ()> const*, unsigned long)
bool enqueue_bulk(It itemFirst, size_t count)
		{
			// First, we need to make sure we have enough room to enqueue all of the elements;
			// this means pre-allocating blocks and putting them in the block index (but only if
			// all the allocations succeeded).
			
			// Note that the tailBlock we start off with may not be owned by us any more;
			// this happens if it was filled up exactly to the top (setting tailIndex to
			// the first index of the next block which is not yet allocated), then dequeued
			// completely (putting it on the free list) before we enqueue again.
			
			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
			auto startBlock = this->tailBlock;
			Block* firstAllocatedBlock = nullptr;
			auto endBlock = this->tailBlock;
			
			// Figure out how many blocks we'll need to allocate, and do so
			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
			if (blockBaseDiff > 0) {
#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
				debug::DebugLock lock(mutex);
#endif
				do {
					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
					
					// Find out where we'll be inserting this block in the block index
					BlockIndexEntry* idxEntry = nullptr;  // initialization here unnecessary but compiler can't always tell
					Block* newBlock;
					bool indexInserted = false;
					auto head = this->headIndex.load(std::memory_order_relaxed);
					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
					bool full = !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));

					if (full || !(indexInserted = insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) || (newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>()) == nullptr) {
						// Index allocation or block allocation failed; revert any other allocations
						// and index insertions done so far for this operation
						if (indexInserted) {
							rewind_block_index_tail();
							idxEntry->value.store(nullptr, std::memory_order_relaxed);
						}
						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
							idxEntry = get_block_index_entry_for_index(currentTailIndex);
							idxEntry->value.store(nullptr, std::memory_order_relaxed);
							rewind_block_index_tail();
						}
						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
						this->tailBlock = startBlock;
						
						return false;
					}
					
#ifdef MCDBGQ_TRACKMEM
					newBlock->owner = this;
#endif
					newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
					newBlock->next = nullptr;
					
					// Insert the new block into the index
					idxEntry->value.store(newBlock, std::memory_order_relaxed);
					
					// Store the chain of blocks so that we can undo if later allocations fail,
					// and so that we can find the blocks when we do the actual enqueueing
					if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr) {
						assert(this->tailBlock != nullptr);
						this->tailBlock->next = newBlock;
					}
					this->tailBlock = newBlock;
					endBlock = newBlock;
					firstAllocatedBlock = firstAllocatedBlock == nullptr ? newBlock : firstAllocatedBlock;
				} while (blockBaseDiff > 0);
			}
			
			// Enqueue, one block at a time
			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
			currentTailIndex = startTailIndex;
			this->tailBlock = startBlock;
			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
				this->tailBlock = firstAllocatedBlock;
			}
			while (true) {
				index_t stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
					stopIndex = newTailIndex;
				}
				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
					while (currentTailIndex != stopIndex) {
						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
					}
				}
				else {
					MOODYCAMEL_TRY {
						while (currentTailIndex != stopIndex) {
							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
							++currentTailIndex;
							++itemFirst;
						}
					}
					MOODYCAMEL_CATCH (...) {
						auto constructedStopIndex = currentTailIndex;
						auto lastBlockEnqueued = this->tailBlock;
						
						if (!details::is_trivially_destructible<T>::value) {
							auto block = startBlock;
							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
								block = firstAllocatedBlock;
							}
							currentTailIndex = startTailIndex;
							while (true) {
								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
									stopIndex = constructedStopIndex;
								}
								while (currentTailIndex != stopIndex) {
									(*block)[currentTailIndex++]->~T();
								}
								if (block == lastBlockEnqueued) {
									break;
								}
								block = block->next;
							}
						}
						
						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
							auto idxEntry = get_block_index_entry_for_index(currentTailIndex);
							idxEntry->value.store(nullptr, std::memory_order_relaxed);
							rewind_block_index_tail();
						}
						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
						this->tailBlock = startBlock;
						MOODYCAMEL_RETHROW;
					}
				}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdx, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x130(%rbp)
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x128(%rbp)
movl -0x2c(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0xbb00
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x11c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x1747b
jmp 0x1745e
movl -0x11c(%rbp), %eax
subl $0x5, %eax
je 0x1748b
jmp 0x1746b
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x17499
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x17499
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x130(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x80(%rbp)
movq $0x0, -0x88(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x78(%rbp), %rax
addq -0x70(%rbp), %rax
subq $0x1, %rax
andq $-0x20, %rax
movq -0x78(%rbp), %rcx
subq $0x1, %rcx
andq $-0x20, %rcx
subq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
subq $0x1, %rax
andq $-0x20, %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0x98(%rbp)
jbe 0x17886
jmp 0x1750f
movq -0x130(%rbp), %rax
movq -0x98(%rbp), %rcx
addq $-0x20, %rcx
movq %rcx, -0x98(%rbp)
movq -0xa0(%rbp), %rcx
addq $0x20, %rcx
movq %rcx, -0xa0(%rbp)
movq $0x0, -0xa8(%rbp)
movb $0x0, -0xb1(%rbp)
addq $0x28, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x140(%rbp)
movl -0x44(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0xbb00
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x134(%rbp)
decl %eax
subl $0x2, %eax
jb 0x175a5
jmp 0x17588
movl -0x134(%rbp), %eax
subl $0x5, %eax
je 0x175b5
jmp 0x17595
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x175c3
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x175c3
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x3af0
xorb $-0x1, %al
testb $0x1, %al
jne 0x175e9
jmp 0x175eb
jmp 0x1760a
leaq 0x2345(%rip), %rdi      # 0x19937
leaq 0x1df2(%rip), %rsi      # 0x193eb
movl $0xa53, %edx            # imm = 0xA53
leaq 0x2d95(%rip), %rcx      # 0x1a39a
callq 0x3180
movq -0xc0(%rbp), %rdi
movq -0xa0(%rbp), %rsi
addq $0x20, %rsi
callq 0x3af0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x141(%rbp)
jne 0x17632
jmp 0x1763c
xorl %eax, %eax
movb %al, -0x141(%rbp)
jmp 0x1763c
movb -0x141(%rbp), %al
andb $0x1, %al
movb %al, -0xc1(%rbp)
testb $0x1, -0xc1(%rbp)
jne 0x1769f
movq -0x130(%rbp), %rdi
movq -0xa0(%rbp), %rdx
leaq -0xa8(%rbp), %rsi
callq 0xeb90
movb %al, %cl
andb $0x1, %cl
movb %cl, -0xb1(%rbp)
testb $0x1, %al
jne 0x1767e
jmp 0x1769f
movq -0x130(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xf1c0
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
jne 0x17789
testb $0x1, -0xb1(%rbp)
je 0x176ca
movq -0x130(%rbp), %rdi
callq 0xf220
movq -0xa8(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd920
movq -0x78(%rbp), %rax
subq $0x1, %rax
andq $-0x20, %rax
movq %rax, -0xa0(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, -0xd0(%rbp)
je 0x1775a
movq -0x130(%rbp), %rdi
movq -0xa0(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rsi
callq 0xe8a0
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd920
movq -0x130(%rbp), %rdi
callq 0xf220
movq -0xd0(%rbp), %rax
movq 0x400(%rax), %rax
movq %rax, -0xd0(%rbp)
jmp 0x176eb
movq -0x130(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x88(%rbp), %rsi
callq 0x17d30
movq -0x130(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0x40(%rax)
movb $0x0, -0x51(%rbp)
jmp 0x17d01
movq -0xb0(%rbp), %rdi
callq 0xf340
movq -0xb0(%rbp), %rax
movq $0x0, 0x400(%rax)
movq -0xa8(%rbp), %rdi
addq $0x8, %rdi
movq -0xb0(%rbp), %rsi
xorl %edx, %edx
callq 0xd920
movq -0x78(%rbp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0x177d8
cmpq $0x0, -0x88(%rbp)
je 0x17820
movq -0x130(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x177e8
jmp 0x17807
leaq 0x2cd0(%rip), %rdi      # 0x1a4bf
leaq 0x1bf5(%rip), %rsi      # 0x193eb
movl $0xa76, %edx            # imm = 0xA76
leaq 0x2b98(%rip), %rcx      # 0x1a39a
callq 0x3180
movq -0x130(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq 0x40(%rax), %rax
movq %rcx, 0x400(%rax)
movq -0x130(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0xb0(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0x1785a
movq -0xb0(%rbp), %rax
movq %rax, -0x150(%rbp)
jmp 0x17868
movq -0x88(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x150(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x98(%rbp)
ja 0x1750f
jmp 0x17886
movq -0x130(%rbp), %rax
movq -0x78(%rbp), %rcx
addq -0x70(%rbp), %rcx
movq %rcx, -0xd8(%rbp)
movq -0x78(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movq -0x80(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x78(%rbp), %rcx
andq $0x1f, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x151(%rbp)
jne 0x178e5
movb $0x1, %al
cmpq $0x0, -0x88(%rbp)
movb %al, -0x151(%rbp)
jne 0x178e5
cmpq $0x0, -0x70(%rbp)
sete %al
movb %al, -0x151(%rbp)
movb -0x151(%rbp), %al
testb $0x1, %al
jne 0x178f1
jmp 0x178f3
jmp 0x17912
leaq 0x2be0(%rip), %rdi      # 0x1a4da
leaq 0x1aea(%rip), %rsi      # 0x193eb
movl $0xa83, %edx            # imm = 0xA83
leaq 0x2a8d(%rip), %rcx      # 0x1a39a
callq 0x3180
movq -0x78(%rbp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0x1793c
cmpq $0x0, -0x88(%rbp)
je 0x1793c
movq -0x130(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0x40(%rax)
jmp 0x1793e
movq -0xa0(%rbp), %rax
andq $-0x20, %rax
addq $0x20, %rax
movq %rax, -0xe0(%rbp)
movq -0xd8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x3af0
testb $0x1, %al
jne 0x1796d
jmp 0x1797b
movq -0xd8(%rbp), %rax
movq %rax, -0xe0(%rbp)
jmp 0x1797d
movq -0xa0(%rbp), %rax
cmpq -0xe0(%rbp), %rax
je 0x17a5d
movq -0x130(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0xa0(%rbp), %rsi
callq 0xd580
movq %rax, -0x168(%rbp)
movq -0x68(%rbp), %rdi
callq 0x17d80
movq %rax, -0x160(%rbp)
jmp 0x179c1
movq -0x160(%rbp), %rsi
movq -0x168(%rbp), %rdi
callq 0x17d90
jmp 0x179d6
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x68(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x68(%rbp)
jmp 0x1797d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
movq -0xe8(%rbp), %rdi
callq 0x30e0
movq -0x130(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, -0xf8(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x100(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x78(%rbp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0x17a62
movq -0x88(%rbp), %rax
movq %rax, -0x108(%rbp)
jmp 0x17a62
jmp 0x17c0c
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x17a6f
movq -0xa0(%rbp), %rax
andq $-0x20, %rax
addq $0x20, %rax
movq %rax, -0xe0(%rbp)
movq -0xf8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x3af0
testb $0x1, %al
jne 0x17a9e
jmp 0x17aac
movq -0xf8(%rbp), %rax
movq %rax, -0xe0(%rbp)
jmp 0x17aae
movq -0xa0(%rbp), %rax
cmpq -0xe0(%rbp), %rax
je 0x17ae9
movq -0x108(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
callq 0xd580
movq %rax, %rdi
callq 0x42d0
jmp 0x17aae
movq -0x108(%rbp), %rax
cmpq -0x100(%rbp), %rax
jne 0x17afb
jmp 0x17b15
movq -0x108(%rbp), %rax
movq 0x400(%rax), %rax
movq %rax, -0x108(%rbp)
jmp 0x17a6d
movq -0x78(%rbp), %rax
subq $0x1, %rax
andq $-0x20, %rax
movq %rax, -0xa0(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x110(%rbp)
cmpq $0x0, -0x110(%rbp)
je 0x17bd5
movq -0x130(%rbp), %rdi
movq -0xa0(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rsi
callq 0xe8a0
movq %rax, -0x170(%rbp)
jmp 0x17b72
movq -0x170(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd920
movq -0x130(%rbp), %rdi
callq 0xf220
movq -0x110(%rbp), %rax
movq 0x400(%rax), %rax
movq %rax, -0x110(%rbp)
jmp 0x17b36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
callq 0x3320
jmp 0x17c07
movq -0x130(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x88(%rbp), %rsi
callq 0x17d30
jmp 0x17bee
movq -0x130(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0x40(%rax)
callq 0x32f0
jmp 0x17d23
jmp 0x17d0f
movq -0x130(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x90(%rbp), %rax
jne 0x17c53
movq -0xa0(%rbp), %rax
cmpq -0xd8(%rbp), %rax
jne 0x17c32
jmp 0x17c51
leaq 0x290e(%rip), %rdi      # 0x1a547
leaq 0x17ab(%rip), %rsi      # 0x193eb
movl $0xac0, %edx            # imm = 0xAC0
leaq 0x274e(%rip), %rcx      # 0x1a39a
callq 0x3180
jmp 0x17c6e
movq -0x130(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x400(%rcx), %rcx
movq %rcx, 0x40(%rax)
jmp 0x1793e
movq -0x130(%rbp), %rcx
addq $0x20, %rcx
movq -0xd8(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movl $0x3, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x180(%rbp)
movl -0x14(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0xbb00
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x174(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
je 0x17cdf
jmp 0x17cc2
movl -0x174(%rbp), %eax
subl $0x5, %eax
je 0x17cef
jmp 0x17ccf
movq -0x180(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x17cfd
movq -0x180(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x17cfd
movq -0x180(%rbp), %rcx
movq -0x20(%rbp), %rax
xchgq %rax, (%rcx)
movb $0x1, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0x3370
movq %rax, %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
nopl (%rax)