// File: HQarroum[P]thread-pool/examples/working-with-tokens/./../../includes/concurrent_queue.hpp
// Function: bool moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ExplicitProducer::enqueue_bulk<(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::AllocationMode)0, std::function<void ()> const*>(std::function<void ()> const*, unsigned long)
bool MOODYCAMEL_NO_TSAN 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).
			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
			auto startBlock = this->tailBlock;
			auto originalBlockIndexFront = pr_blockIndexFront;
			auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
			
			Block* firstAllocatedBlock = nullptr;
			
			// 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) {
				// Allocate as many blocks as possible from ahead
				while (blockBaseDiff > 0 && this->tailBlock != nullptr && this->tailBlock->next != firstAllocatedBlock && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
					
					this->tailBlock = this->tailBlock->next;
					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
					
					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
					entry.base = currentTailIndex;
					entry.block = this->tailBlock;
					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
				}
				
				// Now allocate as many blocks as necessary from the block pool
				while (blockBaseDiff > 0) {
					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
					
					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 (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize || full) {
						MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
							// Failed to allocate, undo changes (but keep injected blocks)
							pr_blockIndexFront = originalBlockIndexFront;
							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
							return false;
						}
						else if (full || !new_block_index(originalBlockIndexSlotsUsed)) {
							// Failed to allocate, undo changes (but keep injected blocks)
							pr_blockIndexFront = originalBlockIndexFront;
							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
							return false;
						}
						
						// pr_blockIndexFront is updated inside new_block_index, so we need to
						// update our fallback value too (since we keep the new index even if we
						// later fail)
						originalBlockIndexFront = originalBlockIndexSlotsUsed;
					}
					
					// Insert a new block in the circular linked list
					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
					if (newBlock == nullptr) {
						pr_blockIndexFront = originalBlockIndexFront;
						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
						return false;
					}
					
#ifdef MCDBGQ_TRACKMEM
					newBlock->owner = this;
#endif
					newBlock->ConcurrentQueue::Block::template set_all_empty<explicit_context>();
					if (this->tailBlock == nullptr) {
						newBlock->next = newBlock;
					}
					else {
						newBlock->next = this->tailBlock->next;
						this->tailBlock->next = newBlock;
					}
					this->tailBlock = newBlock;
					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
					
					++pr_blockIndexSlotsUsed;
					
					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
					entry.base = currentTailIndex;
					entry.block = this->tailBlock;
					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
				}
				
				// Excellent, all allocations succeeded. Reset each block's emptiness before we fill them up, and
				// publish the new block index front
				auto block = firstAllocatedBlock;
				while (true) {
					block->ConcurrentQueue::Block::template reset_empty<explicit_context>();
					if (block == this->tailBlock) {
						break;
					}
					block = block->next;
				}
				
				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
					blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
				}
			}
			
			// Enqueue, one block at a time
			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
			currentTailIndex = startTailIndex;
			auto endBlock = this->tailBlock;
			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) {
							// Must use copy constructor even if move constructor is available
							// because we may have to revert if there's an exception.
							// Sorry about the horrible templated next line, but it was the only way
							// to disable moving *at compile time*, which is important because a type
							// may only define a (noexcept) move constructor, and so calls to the
							// cctor will not compile, even if they are in an if branch that will never
							// be executed
							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 (...) {
						// Oh dear, an exception's been thrown -- destroy the elements that
						// were enqueued so far and revert the entire bulk operation (we'll keep
						// any allocated blocks in our linked list for later, though).
						auto constructedStopIndex = currentTailIndex;
						auto lastBlockEnqueued = this->tailBlock;
						
						pr_blockIndexFront = originalBlockIndexFront;
						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
						
						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;
							}
						}
						MOODYCAMEL_RETHROW;
					}
				}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x150(%rbp)
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x2cf0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x13c(%rbp)
decl %eax
subl $0x2, %eax
jb 0xd631
jmp 0xd614
movl -0x13c(%rbp), %eax
subl $0x5, %eax
je 0xd641
jmp 0xd621
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd64f
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd64f
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x150(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movq 0x70(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x60(%rax), %rax
movq %rax, -0xb0(%rbp)
movq $0x0, -0xb8(%rbp)
movq -0x98(%rbp), %rax
addq -0x90(%rbp), %rax
subq $0x1, %rax
andq $-0x20, %rax
movq -0x98(%rbp), %rcx
subq $0x1, %rcx
andq $-0x20, %rcx
subq %rcx, %rax
movq %rax, -0xc0(%rbp)
movq -0x98(%rbp), %rax
subq $0x1, %rax
andq $-0x20, %rax
movq %rax, -0xc8(%rbp)
cmpq $0x0, -0xc0(%rbp)
jbe 0xdc25
jmp 0xd6e2
xorl %eax, %eax
cmpq $0x0, -0xc0(%rbp)
movb %al, -0x151(%rbp)
jbe 0xd74a
movq -0x150(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
movb %al, -0x151(%rbp)
je 0xd74a
movq -0x150(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x400(%rax), %rcx
xorl %eax, %eax
cmpq -0xb8(%rbp), %rcx
movb %al, -0x151(%rbp)
je 0xd74a
movq -0x150(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x400(%rax), %rdi
callq 0xc260
movb %al, -0x151(%rbp)
movb -0x151(%rbp), %al
testb $0x1, %al
jne 0xd759
jmp 0xd83b
movq -0x150(%rbp), %rax
movq -0xc0(%rbp), %rcx
subq $0x20, %rcx
movq %rcx, -0xc0(%rbp)
movq -0xc8(%rbp), %rcx
addq $0x20, %rcx
movq %rcx, -0xc8(%rbp)
movq 0x40(%rax), %rcx
movq 0x400(%rcx), %rcx
movq %rcx, 0x40(%rax)
cmpq $0x0, -0xb8(%rbp)
jne 0xd7b1
movq -0x150(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x160(%rbp)
jmp 0xd7bf
movq -0xb8(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x150(%rbp), %rdi
movq -0x160(%rbp), %rax
movq %rax, -0xb8(%rbp)
addq $0x58, %rdi
xorl %esi, %esi
callq 0x8d20
movq %rax, %rcx
movq -0x150(%rbp), %rax
movq 0x10(%rcx), %rcx
movq 0x70(%rax), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, -0xd0(%rbp)
movq -0xc8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x40(%rax), %rdx
movq -0xd0(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x70(%rax), %rcx
addq $0x1, %rcx
movq 0x68(%rax), %rdx
subq $0x1, %rdx
andq %rdx, %rcx
movq %rcx, 0x70(%rax)
jmp 0xd6e2
jmp 0xd83d
cmpq $0x0, -0xc0(%rbp)
jbe 0xdbdc
movq -0x150(%rbp), %rax
movq -0xc0(%rbp), %rcx
addq $-0x20, %rcx
movq %rcx, -0xc0(%rbp)
movq -0xc8(%rbp), %rcx
addq $0x20, %rcx
movq %rcx, -0xc8(%rbp)
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x170(%rbp)
movl -0x24(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x2cf0
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x164(%rbp)
decl %eax
subl $0x2, %eax
jb 0xd8cf
jmp 0xd8b2
movl -0x164(%rbp), %eax
subl $0x5, %eax
je 0xd8df
jmp 0xd8bf
movq -0x170(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xd8ed
movq -0x170(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xd8ed
movq -0x170(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xc8(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x2660
xorb $-0x1, %al
testb $0x1, %al
jne 0xd913
jmp 0xd915
jmp 0xd934
leaq 0x244a(%rip), %rdi      # 0xfd66
leaq 0x19b0(%rip), %rsi      # 0xf2d3
movl $0x81c, %edx            # imm = 0x81C
leaq 0x2475(%rip), %rcx      # 0xfda4
callq 0x20f0
movq -0xd8(%rbp), %rdi
movq -0xc8(%rbp), %rsi
addq $0x20, %rsi
callq 0x2660
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x171(%rbp)
jne 0xd95c
jmp 0xd966
xorl %eax, %eax
movb %al, -0x171(%rbp)
jmp 0xd966
movq -0x150(%rbp), %rax
movb -0x171(%rbp), %cl
andb $0x1, %cl
movb %cl, -0xd9(%rbp)
cmpq $0x0, 0x80(%rax)
je 0xd9a4
movq -0x150(%rbp), %rcx
movq 0x60(%rcx), %rax
cmpq 0x68(%rcx), %rax
je 0xd9a4
testb $0x1, -0xd9(%rbp)
je 0xda32
testb $0x1, -0xd9(%rbp)
jne 0xd9c4
movq -0x150(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xb850
testb $0x1, %al
jne 0xda24
movq -0x150(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0xb0(%rbp), %rcx
movq %rcx, 0x60(%rax)
cmpq $0x0, -0xa0(%rbp)
jne 0xd9fb
movq -0xb8(%rbp), %rax
movq %rax, -0x180(%rbp)
jmp 0xda09
movq -0xa0(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x150(%rbp), %rax
movq -0x180(%rbp), %rcx
movq %rcx, 0x40(%rax)
movb $0x0, -0x71(%rbp)
jmp 0xe114
movq -0xb0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x150(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xe140
movq %rax, -0xe8(%rbp)
cmpq $0x0, -0xe8(%rbp)
jne 0xdab3
movq -0x150(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0xb0(%rbp), %rcx
movq %rcx, 0x60(%rax)
cmpq $0x0, -0xa0(%rbp)
jne 0xda8a
movq -0xb8(%rbp), %rax
movq %rax, -0x188(%rbp)
jmp 0xda98
movq -0xa0(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x150(%rbp), %rax
movq -0x188(%rbp), %rcx
movq %rcx, 0x40(%rax)
movb $0x0, -0x71(%rbp)
jmp 0xe114
movq -0xe8(%rbp), %rdi
callq 0xe1a0
movq -0x150(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xdae4
movq -0xe8(%rbp), %rcx
movq -0xe8(%rbp), %rax
movq %rcx, 0x400(%rax)
jmp 0xdb16
movq -0x150(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x400(%rcx), %rdx
movq -0xe8(%rbp), %rcx
movq %rdx, 0x400(%rcx)
movq -0xe8(%rbp), %rcx
movq 0x40(%rax), %rax
movq %rcx, 0x400(%rax)
movq -0x150(%rbp), %rax
movq -0xe8(%rbp), %rcx
movq %rcx, 0x40(%rax)
cmpq $0x0, -0xb8(%rbp)
jne 0xdb46
movq -0x150(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x190(%rbp)
jmp 0xdb54
movq -0xb8(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x150(%rbp), %rdi
movq -0x190(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq 0x60(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x60(%rdi)
addq $0x58, %rdi
xorl %esi, %esi
callq 0x8d20
movq %rax, %rcx
movq -0x150(%rbp), %rax
movq 0x10(%rcx), %rcx
movq 0x70(%rax), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, -0xf0(%rbp)
movq -0xc8(%rbp), %rdx
movq -0xf0(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x40(%rax), %rdx
movq -0xf0(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x70(%rax), %rcx
addq $0x1, %rcx
movq 0x68(%rax), %rdx
subq $0x1, %rdx
andq %rdx, %rcx
movq %rcx, 0x70(%rax)
jmp 0xd83d
movq -0xb8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rdi
callq 0xe200
movq -0x150(%rbp), %rcx
movq -0xf8(%rbp), %rax
cmpq 0x40(%rcx), %rax
jne 0xdc0c
jmp 0xdc23
movq -0xf8(%rbp), %rax
movq 0x400(%rax), %rax
movq %rax, -0xf8(%rbp)
jmp 0xdbea
jmp 0xdc25
movq -0x150(%rbp), %rax
movq -0x98(%rbp), %rcx
addq -0x90(%rbp), %rcx
movq %rcx, -0x100(%rbp)
movq -0x98(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x108(%rbp)
movq -0xa0(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x98(%rbp), %rcx
andq $0x1f, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x191(%rbp)
jne 0xdca1
movb $0x1, %al
cmpq $0x0, -0xb8(%rbp)
movb %al, -0x191(%rbp)
jne 0xdca1
cmpq $0x0, -0x90(%rbp)
sete %al
movb %al, -0x191(%rbp)
movb -0x191(%rbp), %al
testb $0x1, %al
jne 0xdcad
jmp 0xdcaf
jmp 0xdcce
leaq 0x2213(%rip), %rdi      # 0xfec9
leaq 0x1616(%rip), %rsi      # 0xf2d3
movl $0x868, %edx            # imm = 0x868
leaq 0x20db(%rip), %rcx      # 0xfda4
callq 0x20f0
movq -0x98(%rbp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0xdcfb
cmpq $0x0, -0xb8(%rbp)
je 0xdcfb
movq -0x150(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq %rcx, 0x40(%rax)
jmp 0xdcfd
movq -0xc8(%rbp), %rax
andq $-0x20, %rax
addq $0x20, %rax
movq %rax, -0x110(%rbp)
movq -0x100(%rbp), %rdi
movq -0x110(%rbp), %rsi
callq 0x2660
testb $0x1, %al
jne 0xdd2c
jmp 0xdd3a
movq -0x100(%rbp), %rax
movq %rax, -0x110(%rbp)
jmp 0xdd3c
movq -0xc8(%rbp), %rax
cmpq -0x110(%rbp), %rax
je 0xde7e
movq -0x150(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0xc8(%rbp), %rsi
callq 0x8da0
movq %rax, -0x1a8(%rbp)
movq -0x88(%rbp), %rdi
callq 0xe250
movq %rax, -0x1a0(%rbp)
jmp 0xdd83
movq -0x1a0(%rbp), %rsi
movq -0x1a8(%rbp), %rdi
callq 0xe260
jmp 0xdd98
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
movq -0x88(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x88(%rbp)
jmp 0xdd3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
movq -0x118(%rbp), %rdi
callq 0x2090
movq -0x150(%rbp), %rax
movq -0xc8(%rbp), %rcx
movq %rcx, -0x128(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x130(%rbp)
movq -0xa8(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0xb0(%rbp), %rcx
movq %rcx, 0x60(%rax)
cmpq $0x0, -0xa0(%rbp)
jne 0xde2f
movq -0xb8(%rbp), %rax
movq %rax, -0x1b0(%rbp)
jmp 0xde3d
movq -0xa0(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq -0x150(%rbp), %rax
movq -0x1b0(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0xa0(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x98(%rbp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0xde83
movq -0xb8(%rbp), %rax
movq %rax, -0x138(%rbp)
jmp 0xde83
jmp 0xdf61
movq -0x98(%rbp), %rax
movq %rax, -0xc8(%rbp)
jmp 0xde93
movq -0xc8(%rbp), %rax
andq $-0x20, %rax
addq $0x20, %rax
movq %rax, -0x110(%rbp)
movq -0x128(%rbp), %rdi
movq -0x110(%rbp), %rsi
callq 0x2660
testb $0x1, %al
jne 0xdec2
jmp 0xded0
movq -0x128(%rbp), %rax
movq %rax, -0x110(%rbp)
jmp 0xded2
movq -0xc8(%rbp), %rax
cmpq -0x110(%rbp), %rax
je 0xdf0d
movq -0x138(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
callq 0x8da0
movq %rax, %rdi
callq 0x2810
jmp 0xded2
movq -0x138(%rbp), %rax
cmpq -0x130(%rbp), %rax
jne 0xdf1f
jmp 0xdf39
movq -0x138(%rbp), %rax
movq 0x400(%rax), %rax
movq %rax, -0x138(%rbp)
jmp 0xde91
callq 0x21c0
jmp 0xe136
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
callq 0x21f0
jmp 0xdf5c
jmp 0xe122
movq -0x150(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x108(%rbp), %rax
jne 0xdfa8
movq -0xc8(%rbp), %rax
cmpq -0x100(%rbp), %rax
jne 0xdf87
jmp 0xdfa6
leaq 0x1fa8(%rip), %rdi      # 0xff36
leaq 0x133e(%rip), %rsi      # 0xf2d3
movl $0x8a9, %edx            # imm = 0x8A9
leaq 0x1e03(%rip), %rcx      # 0xfda4
callq 0x20f0
jmp 0xdfc3
movq -0x150(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x400(%rcx), %rcx
movq %rcx, 0x40(%rax)
jmp 0xdcfd
cmpq $0x0, -0xb8(%rbp)
je 0xe081
movq -0x150(%rbp), %rdi
addq $0x58, %rdi
xorl %esi, %esi
callq 0x8d20
movq %rax, %rcx
movq -0x150(%rbp), %rax
addq $0x8, %rcx
movq 0x68(%rax), %rdx
movq 0x70(%rax), %rax
decq %rax
decq %rdx
andq %rdx, %rax
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movl $0x3, -0x44(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl -0x44(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x2cf0
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x1b4(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, -0x50(%rbp)
subl $0x3, %eax
je 0xe061
jmp 0xe044
movl -0x1b4(%rbp), %eax
subl $0x5, %eax
je 0xe071
jmp 0xe051
movq -0x1c0(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xe07f
movq -0x1c0(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xe07f
movq -0x1c0(%rbp), %rcx
movq -0x50(%rbp), %rax
xchgq %rax, (%rcx)
jmp 0xe081
movq -0x150(%rbp), %rcx
addq $0x20, %rcx
movq -0x100(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movl $0x3, -0x64(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movl -0x64(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x2cf0
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x1c4(%rbp)
movq -0x60(%rbp), %rcx
movq %rcx, -0x70(%rbp)
subl $0x3, %eax
je 0xe0f2
jmp 0xe0d5
movl -0x1c4(%rbp), %eax
subl $0x5, %eax
je 0xe102
jmp 0xe0e2
movq -0x1d0(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xe110
movq -0x1d0(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xe110
movq -0x1d0(%rbp), %rcx
movq -0x70(%rbp), %rax
xchgq %rax, (%rcx)
movb $0x1, -0x71(%rbp)
movb -0x71(%rbp), %al
andb $0x1, %al
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2c40
nopw %cs:(%rax,%rax)