LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::handle_data::tag_sub(unsigned long, std::memory_order)
GC::handle_data::tag_t GC::handle_data::tag_sub(tag_t v, std::memory_order order)
{
	const auto prev = tag.fetch_sub(v, order);

	#if DRAGAZO_GARBAGE_COLLECT_DISJUNCTION_HANDLE_DATA_UND_SAFETY

	const auto cur = prev - v; // compute current value from previous

	// make sure we didn't overflow any of the fields
	assert((cur & strong_mask) <= (prev & strong_mask));
	assert((cur & weak_mask) <= (prev & weak_mask));
	assert((cur & lock_mask) <= (prev & lock_mask));

	#endif

	return prev;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x38(%rsp), %rdx
addq $0x1e8, %rdx            # imm = 0x1E8
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %eax
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x54(%rsp), %eax
movq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0x8630
movq 0x10(%rsp), %rax
leaq 0x5b9f1(%rip), %rcx     # 0x64018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x40(%rsp)
jmp 0x86ab
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x40(%rsp)
jmp 0x86ab
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x40(%rsp)
jmp 0x86ab
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x40(%rsp)
jmp 0x86ab
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
subq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
andq 0x18(%rsp), %rax
movabsq $0xffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFF
andq 0x20(%rsp), %rcx
cmpq %rcx, %rax
ja 0x86e9
jmp 0x8708
leaq 0x5bf01(%rip), %rdi     # 0x645f1
leaq 0x5ba66(%rip), %rsi     # 0x6415d
movl $0x3ac, %edx            # imm = 0x3AC
leaq 0x5bf1a(%rip), %rcx     # 0x6461d
callq 0x51e0
movabsq $0xf00000000000000, %rax # imm = 0xF00000000000000
andq 0x18(%rsp), %rax
movabsq $0xf00000000000000, %rcx # imm = 0xF00000000000000
andq 0x20(%rsp), %rcx
cmpq %rcx, %rax
ja 0x872d
jmp 0x874c
leaq 0x5bf33(%rip), %rdi     # 0x64667
leaq 0x5ba22(%rip), %rsi     # 0x6415d
movl $0x3ad, %edx            # imm = 0x3AD
leaq 0x5bed6(%rip), %rcx     # 0x6461d
callq 0x51e0
movabsq $-0x1000000000000000, %rax # imm = 0xF000000000000000
andq 0x18(%rsp), %rax
movabsq $-0x1000000000000000, %rcx # imm = 0xF000000000000000
andq 0x20(%rsp), %rcx
cmpq %rcx, %rax
ja 0x8771
jmp 0x8790
leaq 0x5bf17(%rip), %rdi     # 0x6468f
leaq 0x5b9de(%rip), %rsi     # 0x6415d
movl $0x3ae, %edx            # imm = 0x3AE
leaq 0x5be92(%rip), %rcx     # 0x6461d
callq 0x51e0
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::shared_disjoint_handle::lock(GC::handle_data*)
void GC::shared_disjoint_handle::lock(handle_data *other)
{
	// we need to start out null
	reset();

	// if the relock target is non-null
	if (other)
	{
		// bump up the strong and lock counts
		auto prev = other->tag_add(handle_data::lock_1 | handle_data::strong_1, std::memory_order_acq_rel);

		// if there was at least 1 non-lock strong reference, the lock is successful and the object is still alive.
		// we exclude lock strong refs because otherwise 2 locks back-to-back from 2 threads could trick the latter into thinking it succeeded.
		if (handle_data::non_lock_strongs(prev) != 0)
		{
			// unmark the lock ref (success keeps only the strong ref because we're a non-lock strong owner type)
			other->tag_sub(handle_data::lock_1, std::memory_order_acq_rel);

			// we now own a reference - do the raw repoint
			data = other;
			__module = other->get();
		}
		// otherwise the object is expired
		else
		{
			// unmark the lock ref and strong ref (failure to lock a strong ref)
			other->tag_sub(handle_data::lock_1 | handle_data::strong_1, std::memory_order_acq_rel);
		}
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x7ea0
cmpq $0x0, 0x18(%rsp)
je 0x8854
movq 0x18(%rsp), %rdi
movabsq $0x1000000000000001, %rsi # imm = 0x1000000000000001
movl $0x4, %edx
callq 0x83f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa2a0
cmpq $0x0, %rax
je 0x8839
movq 0x18(%rsp), %rdi
movabsq $0x1000000000000000, %rsi # imm = 0x1000000000000000
movl $0x4, %edx
callq 0x85c0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x9e20
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x8852
movq 0x18(%rsp), %rdi
movabsq $0x1000000000000001, %rsi # imm = 0x1000000000000001
movl $0x4, %edx
callq 0x85c0
jmp 0x8854
addq $0x28, %rsp
retq
nopl (%rax)
// File: dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::shared_disjoint_handle::shared_disjoint_handle(GC::shared_disjoint_handle const&)
GC::shared_disjoint_handle::shared_disjoint_handle(const shared_disjoint_handle &other)
{
	// alias the same disjunction
	data = other.data;
	__module = other.__module;

	// bump up the strong ref count to account for our aliasing
	if (data) data->tag_add(handle_data::strong_1, std::memory_order_acq_rel);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x88ed
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x83f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::shared_disjoint_handle::operator=(GC::shared_disjoint_handle&&)
GC::shared_disjoint_handle &GC::shared_disjoint_handle::operator=(shared_disjoint_handle &&other)
{
	if (&other != this)
	{
		// repoint to null with the ref count logic
		reset();

		// then steal disjunction ownership - ref count change is net zero
		data = std::exchange(other.data, nullptr);
		__module = std::exchange(other.__module, nullptr);
	}

	return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq %rax, 0x18(%rsp)
je 0x8a24
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7ea0
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movq $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0xa2e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
movq $0x0, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0xa310
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::weak_disjoint_handle::reset(GC::handle_data*)
void GC::weak_disjoint_handle::reset(handle_data *other)
{
	// handle redundant assignment as no-op
	if (data == other) return;

	// if we pointed at something
	if (data)
	{
		// drop a weak ref and get the previous tag
		auto prev = data->tag_sub(handle_data::weak_1, std::memory_order_acq_rel);

		// if we were the last weak ref and there were no strong refs, the object is already destroyed and needs to be deleted.
		// being the last weak ref implies there are no locks at the moment because without unsynchronized read/write to the same variable from several threads that's impossible.
		// therefore we don't need to bother about strong vs. non-lock strong references in this context because strong == non-lock strong
		if ((prev & handle_data::weak_mask) == handle_data::weak_1 && (prev & handle_data::strong_mask) == 0)
		{
			// in this case the strong count fell to zero, so the object is potentially being destroyed by the strong ref count logic.
			// however, that strong ref count logic won't delete the data block because our existence proves there was a weak reference prior to the strong ref dec logic.
			// therefore we just need to wait until the object is destroyed so we can delete the data block
			while (!data->destroyed_flag.load(std::memory_order_acquire));
			delete data;
		}
	}

	// repoint - if non-null bump up weak ref count
	data = other;
	if (data) data->tag_add(handle_data::weak_1, std::memory_order_acq_rel);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x8a57
jmp 0x8b32
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x8b03
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movabsq $0x100000000000000, %rsi # imm = 0x100000000000000
movl $0x4, %edx
callq 0x85c0
movq %rax, 0x10(%rsp)
movabsq $0xf00000000000000, %rax # imm = 0xF00000000000000
andq 0x10(%rsp), %rax
movabsq $0x100000000000000, %rcx # imm = 0x100000000000000
cmpq %rcx, %rax
jne 0x8b01
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
andq 0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0x8b01
jmp 0x8abc
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
movl $0x2, %esi
callq 0xa340
xorb $-0x1, %al
testb $0x1, %al
jne 0x8add
jmp 0x8adf
jmp 0x8abc
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x8aff
movq (%rsp), %rdi
movl $0x1f8, %esi            # imm = 0x1F8
callq 0x5310
jmp 0x8b01
jmp 0x8b03
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x8b32
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movabsq $0x100000000000000, %rsi # imm = 0x100000000000000
movl $0x4, %edx
callq 0x83f0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::weak_disjoint_handle::operator=(GC::weak_disjoint_handle&&)
GC::weak_disjoint_handle &GC::weak_disjoint_handle::operator=(weak_disjoint_handle &&other)
{
	if (&other != this)
	{
		reset(); // repoint to null with the ref count logic
		data = std::exchange(other.data, nullptr); // then unsafe repoint to other and disconnect other - the ref count change is net zero
	}
	return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, 0x18(%rsp)
je 0x8ca0
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8a30
movq 0x18(%rsp), %rdi
movq $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0xa2e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: dragazo[P]cpp-gc/test.cpp
// Function: foo()
void foo()
{
	{
		//GC::collect();
		
		// create the first node
		GC::ptr<ListNode> root = GC::make<ListNode>();

		// we'll make 10 links in the chain
		GC::ptr<ListNode> *prev = &root;
		for (int i = 0; i < 10; ++i)
		{
			(*prev)->next = GC::make<ListNode>();
			(*prev)->next->prev = *prev;

			prev = &(*prev)->next;
		}

		// then we'll merege the ends into a cycle
		root->prev = *prev;
		(*prev)->next = root;

		using std::swap;

		root.swap(*prev);
		swap(root, *prev);

		//GC::collect();
		//std::cerr << "\n\n";
	}
}

// Assembly:
subq $0x68, %rsp
leaq 0x50(%rsp), %rdi
callq 0x240e0
leaq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
cmpl $0xa, 0x44(%rsp)
jge 0x10c58
leaq 0x28(%rsp), %rdi
callq 0x240e0
jmp 0x10bb7
movq 0x48(%rsp), %rdi
callq 0x242e0
movq %rax, %rdi
addq $0x18, %rdi
leaq 0x28(%rsp), %rsi
callq 0x242f0
jmp 0x10bd4
leaq 0x28(%rsp), %rdi
callq 0x24330
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x242e0
movq %rax, %rdi
addq $0x18, %rdi
callq 0x242e0
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x242f0
jmp 0x10c08
movq 0x48(%rsp), %rdi
callq 0x242e0
addq $0x18, %rax
movq %rax, 0x48(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x10ba0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x10cc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x24330
jmp 0x10cc9
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x242e0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x242f0
jmp 0x10c7b
movq 0x48(%rsp), %rdi
callq 0x242e0
movq %rax, %rdi
addq $0x18, %rdi
leaq 0x50(%rsp), %rsi
callq 0x242f0
jmp 0x10c98
movq 0x48(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x24350
jmp 0x10ca9
movq 0x48(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x24390
jmp 0x10cba
leaq 0x50(%rsp), %rdi
callq 0x24330
addq $0x68, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x24330
movq 0x20(%rsp), %rdi
callq 0x5510
nopl (%rax)
// File: dragazo[P]cpp-gc/./GarbageCollection.h
// Function: _gc_variant<std::recursive_mutex, SymbolTable>::operator=(__gc_variant<std::recursive_mutex, SymbolTable>&&)
__gc_variant &operator=(__gc_variant &&other)
	{
		if (this != &other)
		{
			std::scoped_lock locks(this->mutex, other.mutex);
			wrapped() = std::move(other.wrapped());
		}
		return *this;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x38(%rsp), %rax
je 0x2a91f
movq 0x10(%rsp), %rsi
addq $0xc8, %rsi
movq 0x38(%rsp), %rdx
addq $0xc8, %rdx
leaq 0x28(%rsp), %rdi
callq 0x51180
movq 0x38(%rsp), %rdi
callq 0x52020
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x52020
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x53920
jmp 0x2a8f9
leaq 0x28(%rsp), %rdi
callq 0x511c0
jmp 0x2a91f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x511c0
jmp 0x2a929
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5510
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dragazo[P]cpp-gc/./GarbageCollection.h
// Function: GC::checked_allocator<GC::raw_aligned_allocator<8ul>>::alloc(unsigned long)
static void *alloc(std::size_t size)
		{
			// allocate the space
			void *buf = allocator_t::alloc(size);

			// if that failed but we have allocfail collect mode enabled
			if (!buf && (int)strategy() & (int)strategies::allocfail)
			{
				// collect and retry the allocation
				GC::collect();
				buf = allocator_t::alloc(size);
			}

			// if that failed, throw bad alloc
			if (!buf) throw std::bad_alloc();

			return buf;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x39b90
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x398d1
callq 0x8d90
andl $0x2, %eax
cmpl $0x0, %eax
je 0x398d1
callq 0x8d60
movq 0x10(%rsp), %rdi
callq 0x39b90
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x39906
movl $0x8, %edi
callq 0x5160
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0x39ba0
movq (%rsp), %rdi
movq 0x606c6(%rip), %rsi     # 0x99fc0
movq 0x6068f(%rip), %rdx     # 0x99f90
callq 0x54d0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: dragazo[P]cpp-gc/test.cpp
// Function: GC::router<ptr_set>::route(ptr_set const&, GC::router_fn)
static void route(const ptr_set &set, GC::router_fn func)
	{
		GC::route(set.a, func);
		GC::route(set.b, func);
		GC::route(set.c, func);
		GC::route(set.d, func);
		GC::route(set.e, func);
		GC::route(set.f, func);
		GC::route(set.g, func);
		GC::route(set.h, func);

		GC::route(set.val, func);

		GC::route(set.thingy, func);

		GC::route(set.tuple_thing, func);

		GC::route(set.mapydoo1, func);
		GC::route(set.mapydoo2, func);

		GC::route(set.doodle_dud_0, func);
		GC::route(set.doodle_dud_1, func);

		//GC::route(set.a, set.a);
	}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x80(%rsp)
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rsi
callq 0x3c2e0
movq 0x78(%rsp), %rdi
addq $0x18, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
callq 0x3c2e0
movq 0x78(%rsp), %rdi
addq $0x30, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rsi
callq 0x3c2e0
movq 0x78(%rsp), %rdi
addq $0x48, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
callq 0x3c2e0
movq 0x78(%rsp), %rdi
addq $0x60, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
callq 0x3c2e0
movq 0x78(%rsp), %rdi
addq $0x78, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
callq 0x3c2e0
movq 0x78(%rsp), %rdi
addq $0x90, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
callq 0x3c2e0
movq 0x78(%rsp), %rdi
addq $0xa8, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
callq 0x3c2e0
movq 0x78(%rsp), %rdi
addq $0xc0, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
callq 0x39fc0
movq 0x78(%rsp), %rdi
addq $0xc8, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x3c310
movq 0x78(%rsp), %rdi
addq $0xd8, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x3c320
movq 0x78(%rsp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x3c350
movq 0x78(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x3c350
movq 0x78(%rsp), %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x3c380
movq 0x78(%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
movq 0x80(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
callq 0x3c380
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dragazo[P]cpp-gc/test.cpp
// Function: void GC::router<router_allocator>::route<GC::router_fn>(router_allocator const&, GC::router_fn)
static void route(const router_allocator &r, F func)
	{
		// simulate router locking a mutex and a mutator in the class locking and allocating
		r.p = GC::make<int>(45);

		GC::route(r.p, func);
		GC::route(r.self, func);
	}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movl $0x2d, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x2dcc0
movq (%rsp), %rsi
movq 0x48(%rsp), %rdi
callq 0x2de90
jmp 0x3d669
leaq 0x30(%rsp), %rdi
callq 0x27860
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x3c2e0
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x3d6d0
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x27860
movq 0x20(%rsp), %rdi
callq 0x5510
// File: dragazo[P]cpp-gc/test.cpp
// Function: void GC::router<atomic_container>::route<GC::router_fn>(atomic_container const&, GC::router_fn)
static void route(const atomic_container &atomic, F func)
	{
		GC::route(atomic.atomic_1, func);
		GC::route(atomic.atomic_2, func);
		GC::route(atomic.atomic_3, func);
		GC::route(atomic.atomic_4, func);
	}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x42670
movq 0x28(%rsp), %rdi
addq $0x40, %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x42670
movq 0x28(%rsp), %rdi
addq $0x80, %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x42670
movq 0x28(%rsp), %rdi
addq $0xc0, %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x42670
addq $0x38, %rsp
retq
nopl (%rax)
// File: dragazo[P]cpp-gc/test.cpp
// Function: SymbolTable::operator=(SymbolTable const&)
SymbolTable &operator=(const SymbolTable &other)
	{
		if (this != &other)
		{
			{
				std::lock_guard lock(symbols_mutex);
				symbols = other.symbols;
			}
			better_symbols = other.better_symbols;
		}
		return *this;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq 0x28(%rsp), %rax
je 0x4f9c0
movq 0x8(%rsp), %rsi
addq $0x38, %rsi
leaq 0x20(%rsp), %rdi
callq 0x95b0
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4fa30
jmp 0x4f983
leaq 0x20(%rsp), %rdi
callq 0x96d0
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x60, %rsi
addq $0x60, %rdi
callq 0x4fa60
jmp 0x4f9c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x96d0
jmp 0x4f9ca
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x5510
nopw %cs:(%rax,%rax)
nop
// File: dragazo[P]cpp-gc/test.cpp
// Function: SymbolTable::operator=(SymbolTable&&)
SymbolTable &operator=(SymbolTable &&other)
	{
		if (this != &other)
		{
			{
				std::scoped_lock locks(symbols_mutex, other.symbols_mutex);
				symbols = std::move(other.symbols);
			}
			better_symbols = std::move(other.better_symbols);
		}
		return *this;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x18(%rsp), %rax
je 0x50897
movq (%rsp), %rsi
addq $0x38, %rsi
movq 0x18(%rsp), %rdx
addq $0x38, %rdx
leaq 0x8(%rsp), %rdi
callq 0x508e0
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x50920
leaq 0x8(%rsp), %rdi
callq 0x50950
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x60, %rsi
addq $0x60, %rdi
callq 0x50980
movq (%rsp), %rax
addq $0x28, %rsp
retq
// File: dragazo[P]cpp-gc/./GarbageCollection.h
// Function: _gc_unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, GC::ptr<TreeNode>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, GC::ptr<TreeNode>>>, std::recursive_mutex>::operator=(__gc_unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, GC::ptr<TreeNode>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, GC::ptr<TreeNode>>>, std::recursive_mutex>&&)
__gc_unordered_map &operator=(__gc_unordered_map &&other)
	{
		if (this != &other)
		{
			std::scoped_lock locks(this->mutex, other.mutex);
			wrapped() = std::move(other.wrapped());
		}
		return *this;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x28(%rsp), %rax
je 0x509eb
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
movq 0x28(%rsp), %rdx
addq $0x38, %rdx
leaq 0x18(%rsp), %rdi
callq 0x51180
movq 0x28(%rsp), %rdi
callq 0x320e0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x320e0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x50920
leaq 0x18(%rsp), %rdi
callq 0x511c0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: vividvilla[P]hackerrank/src/insertionsort1.cpp
// Function: outputSteps(std::vector<int, std::allocator<int>>)
void outputSteps(vector<int> ar) {
    int N = ar.size();
    int el = ar[N - 1];

    for (int i = N - 1; i >= 0; i--) {
        if (i > 0 && ar[i - 1] > el)
            ar[i] = ar[i - 1];
        else
            ar[i] = el;

        for (int j = 0; j < N; j++) {
            cout << ar[j];
            if (j + 1 < N)
                cout << " ";
            else
                cout << endl;
        }

        if (ar[i] <= el)
            break;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
callq 0x14a0
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x14c0
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x13b4
cmpl $0x0, 0x14(%rsp)
jle 0x12fb
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x14c0
movl (%rax), %eax
cmpl 0x18(%rsp), %eax
jle 0x12fb
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x14c0
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movslq 0x14(%rsp), %rsi
callq 0x14c0
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x1316
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, (%rsp)
movslq 0x14(%rsp), %rsi
callq 0x14c0
movl (%rsp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x1389
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x14c0
movl (%rax), %esi
movq 0x3c90(%rip), %rdi      # 0x4fd0
callq 0x1100
movl 0x10(%rsp), %eax
addl $0x1, %eax
cmpl 0x1c(%rsp), %eax
jge 0x1367
movq 0x3c77(%rip), %rdi      # 0x4fd0
leaq 0x1ca4(%rip), %rsi      # 0x3004
callq 0x10a0
jmp 0x137a
movq 0x3c62(%rip), %rdi      # 0x4fd0
movq 0x3c4b(%rip), %rsi      # 0x4fc0
callq 0x10d0
jmp 0x137c
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x131e
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x14c0
movl (%rax), %eax
cmpl 0x18(%rsp), %eax
jg 0x13a2
jmp 0x13b4
jmp 0x13a4
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x129c
addq $0x28, %rsp
retq
nopl (%rax)
// File: chrischute[P]are-you-the-one/src/ayto.cpp
// Function: getRandomPerfectMatching[abi:cxx11]()
Pm getRandomPerfectMatching() {
    Pm p = DIGITS;
    int last = (int) p.size();
    while (--last > 0) {
        int i = rand() % last;
        char tmp = p[last];
        p[last] = p[i];
        p[i] = tmp;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x34e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xe9ee(%rip), %rsi      # 0x14025
callq 0x6e80
jmp 0x563e
leaq -0xa(%rbp), %rdi
callq 0x3340
movq -0x38(%rbp), %rdi
callq 0x31e0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jle 0x571c
callq 0x30b0
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %ecx
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x3520
movq %rax, -0x48(%rbp)
jmp 0x5686
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
movb (%rax), %al
movb %al, -0x25(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x3520
movq %rax, -0x50(%rbp)
jmp 0x56a2
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x59(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x3520
movq %rax, -0x58(%rbp)
jmp 0x56be
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rax
movb -0x59(%rbp), %cl
movb %cl, (%rax)
movb -0x25(%rbp), %al
movb %al, -0x69(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x3520
movq %rax, -0x68(%rbp)
jmp 0x56e0
movq -0x68(%rbp), %rax
movb -0x69(%rbp), %cl
movb %cl, (%rax)
jmp 0x5653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x3340
jmp 0x5739
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3190
jmp 0x5739
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x572f
movq -0x38(%rbp), %rdi
callq 0x3190
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
// File: chrischute[P]are-you-the-one/src/ayto.cpp
// Function: getNextPerfectMatchingGuess[abi:cxx11](PerfectMatchingSet const*, PerfectMatchingSet const*)
Pm getNextPerfectMatchingGuess(const PmSet* possibleAnswers, const PmSet* guessesAlreadyMade)
{
    if (possibleAnswers->size() == 1) {
        return possibleAnswers->get(0);
    }

    switch (guessesAlreadyMade->size()) {
        case 0:
            return DIGITS;
        case 1:
            return GUESS;
        default:
            return getNextGuessUsingMinimax(possibleAnswers, guessesAlreadyMade);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x107a0
cmpq $0x1, %rax
jne 0x579a
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x10580
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x30f0
jmp 0x585b
movq -0x18(%rbp), %rdi
callq 0x107a0
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
testq %rax, %rax
je 0x57c0
jmp 0x57b1
movq -0x48(%rbp), %rax
subq $0x1, %rax
je 0x5805
jmp 0x584a
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x34e0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xe849(%rip), %rsi      # 0x14025
callq 0x6e80
jmp 0x57e3
leaq -0x19(%rbp), %rdi
callq 0x3340
jmp 0x585b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x3340
jmp 0x5865
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34e0
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xe9ce(%rip), %rsi      # 0x141ef
callq 0x6e80
jmp 0x5828
leaq -0x2d(%rbp), %rdi
callq 0x3340
jmp 0x585b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x3340
jmp 0x5865
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5870
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34d0
nop
// File: chrischute[P]are-you-the-one/src/ayto.cpp
// Function: getPrintableNames(TruthBooth const&, std::map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const*, std::map<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<char>, std::allocator<std::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const*)
string getPrintableNames(const TruthBooth& truthBooth,
                         const map<int, string>* femaleNames,
                         const map<char, string>* maleNames) {
    stringstream printableNamesBuilder;

    printableNamesBuilder << "(" << femaleNames->at(truthBooth.index) << ", "
                          << maleNames->at(truthBooth.charAtIndex) << ")";

    return printableNamesBuilder.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x31f0
leaq -0x198(%rbp), %rdi
leaq 0xd78d(%rip), %rsi      # 0x14243
callq 0x32e0
movq %rax, -0x1c0(%rbp)
jmp 0x6ac4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8530
movq %rax, -0x1d8(%rbp)
jmp 0x6ada
movq -0x1d8(%rbp), %rsi
movq -0x1c0(%rbp), %rdi
callq 0x3280
movq %rax, -0x1e0(%rbp)
jmp 0x6af6
movq -0x1e0(%rbp), %rdi
leaq 0xd741(%rip), %rsi      # 0x14245
callq 0x32e0
movq %rax, -0x1e8(%rbp)
jmp 0x6b12
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x85d0
movq %rax, -0x1f0(%rbp)
jmp 0x6b2c
movq -0x1f0(%rbp), %rsi
movq -0x1e8(%rbp), %rdi
callq 0x3280
movq %rax, -0x1f8(%rbp)
jmp 0x6b48
movq -0x1f8(%rbp), %rdi
leaq 0xd90b(%rip), %rsi      # 0x14461
callq 0x32e0
jmp 0x6b5d
movq -0x1d0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x32d0
jmp 0x6b72
leaq -0x1a8(%rbp), %rdi
callq 0x3210
movq -0x1c8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x3210
movq -0x1b0(%rbp), %rdi
callq 0x34d0
nopl (%rax,%rax)
// File: chrischute[P]are-you-the-one/src/ayto.cpp
// Function: getPrintableNumbers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string getPrintableNumbers(const PerfectMatching& p) {
    stringstream printableNumbersBuilder;

    printableNumbersBuilder << "(";
    for (PerfectMatching::const_iterator i = p.begin(); i != p.end(); i++) {
        printableNumbersBuilder << *i;
        if (i != p.end() - 1)
            printableNumbersBuilder << ", ";
    }
    printableNumbersBuilder << ")";

    return printableNumbersBuilder.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31f0
leaq -0x188(%rbp), %rdi
leaq 0xd645(%rip), %rsi      # 0x14243
callq 0x32e0
jmp 0x6c05
movq -0x10(%rbp), %rdi
callq 0x32b0
movq %rax, -0x1b0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3500
movq %rax, -0x1b8(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x7980
testb $0x1, %al
jne 0x6c41
jmp 0x6d00
leaq -0x188(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x7aa0
movq -0x1e8(%rbp), %rdi
movsbl (%rax), %esi
callq 0x33b0
jmp 0x6c6c
movq -0x10(%rbp), %rdi
callq 0x3500
movq %rax, -0x1c8(%rbp)
leaq -0x1c8(%rbp), %rdi
movl $0x1, %esi
callq 0x8670
movq %rax, -0x1c0(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x7980
testb $0x1, %al
jne 0x6cad
jmp 0x6ce4
leaq -0x188(%rbp), %rdi
leaq 0xd58a(%rip), %rsi      # 0x14245
callq 0x32e0
jmp 0x6cc2
jmp 0x6ce4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3210
jmp 0x6d46
jmp 0x6ce6
leaq -0x1b0(%rbp), %rdi
xorl %esi, %esi
callq 0x86b0
movq %rax, -0x1d0(%rbp)
jmp 0x6c15
leaq -0x188(%rbp), %rdi
leaq 0xd753(%rip), %rsi      # 0x14461
callq 0x32e0
jmp 0x6d15
movq -0x1e0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x32d0
jmp 0x6d2a
leaq -0x198(%rbp), %rdi
callq 0x3210
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
// File: chrischute[P]are-you-the-one/src/./TruthBooth.h
// Function: TruthBooth::toString[abi:cxx11]() const
std::string toString() const {
        const char chars[] = {
                static_cast<char>('0' + index),
                this->charAtIndex
        };
        return std::string(chars, 2);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
addb $0x30, %cl
movb %cl, -0x12(%rbp)
movb 0x4(%rax), %al
movb %al, -0x11(%rbp)
leaq -0x13(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x34e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rcx
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x3380
jmp 0x88c2
leaq -0x13(%rbp), %rdi
callq 0x3340
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x13(%rbp), %rdi
callq 0x3340
movq -0x20(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chrischute[P]are-you-the-one/src/PerfectMatching.cpp
// Function: numInCommon(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int numInCommon(PerfectMatching const& pm1, PerfectMatching const& pm2) {
    int numInCommon = 0;
    for (unsigned int i = 0; i < pm1.size() && i < pm2.size(); ++i)
        if (pm1[i] == pm2[i])
            ++numInCommon;
    return numInCommon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq -0x28(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jae 0x1009f
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x100a8
jmp 0x100f0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x3360
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x3360
movq %rax, %rcx
movl -0x34(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x100e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x100e2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1005e
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::filter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void PerfectMatchingSet::filter(const PerfectMatching& p, int n) {
    vector<Pm>* newData = new vector<Pm>();
    for (PerfectMatchingSet::iterator it = this->begin(); it != this->end(); ++it) {
        if (numInCommon(p, *it) == n) {
            newData->push_back(*it);
        }
    }

    delete this->data;
    this->data = newData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x18, %edi
callq 0x32f0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x3150
movq -0x40(%rbp), %rdi
callq 0x10960
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x10280
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10320
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10b40
testb $0x1, %al
jne 0x103c6
jmp 0x10412
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10c00
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x10040
cmpl -0x14(%rbp), %eax
jne 0x10405
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10c00
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x10aa0
jmp 0x10407
leaq -0x28(%rbp), %rdi
callq 0x10c20
jmp 0x103a6
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x1043a
movq -0x58(%rbp), %rdi
callq 0x10a40
movq -0x58(%rbp), %rdi
movl $0x18, %esi
callq 0x3300
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::filter(TruthBooth const&, bool)
void PerfectMatchingSet::filter(const Tb& m, bool isMatch) {
    vector<Pm>* newData = new vector<Pm>();
    for (PerfectMatchingSet::iterator it = this->begin(); it != this->end(); ++it) {
        if (isMatch == ((*it)[m.index] == m.charAtIndex)) {
            newData->push_back(*it);
        }
    }

    delete this->data;
    this->data = newData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x18, %edi
callq 0x32f0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x3150
movq -0x40(%rbp), %rdi
callq 0x10960
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x10280
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10320
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10b40
testb $0x1, %al
jne 0x104ca
jmp 0x1053a
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10c00
movq %rax, %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x3520
movq %rax, %rcx
movl -0x44(%rbp), %eax
movsbl (%rcx), %ecx
movq -0x10(%rbp), %rdx
movsbl 0x4(%rdx), %edx
cmpl %edx, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1052a
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10c00
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x10aa0
jmp 0x1052c
leaq -0x28(%rbp), %rdi
callq 0x10c20
jmp 0x104aa
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x10562
movq -0x58(%rbp), %rdi
callq 0x10a40
movq -0x58(%rbp), %rdi
movl $0x18, %esi
callq 0x3300
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::populateAll()
void PerfectMatchingSet::populateAll() {
    Pm p = "0123456789";
    do {
        this->add(p);
    } while (next_permutation(p.begin(), p.end()));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34e0
movq -0x58(%rbp), %rdx
leaq 0x3a49(%rip), %rsi      # 0x14025
leaq -0x28(%rbp), %rdi
callq 0x6e80
jmp 0x105e7
leaq -0x29(%rbp), %rdi
callq 0x3340
movq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10250
jmp 0x105ff
jmp 0x10601
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3260
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x3160
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x6f30
movb %al, -0x61(%rbp)
jmp 0x10631
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x105f0
jmp 0x1063a
leaq -0x28(%rbp), %rdi
callq 0x3190
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3340
jmp 0x10675
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3190
movq -0x38(%rbp), %rdi
callq 0x34d0
nop
// File: chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::populateFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PerfectMatchingSet::populateFromFile(string filename) {
    Pm s;
    ifstream inputFile(filename);

    while (inputFile >> s) {
        this->add(s);
    }

    inputFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rsi, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3420
movq -0x250(%rbp), %rsi
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0x3480
jmp 0x106c8
jmp 0x106ca
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33e0
movq %rax, -0x260(%rbp)
jmp 0x106e3
movq -0x260(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33d0
movb %al, -0x261(%rbp)
jmp 0x10701
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x1070d
jmp 0x10755
movq -0x258(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10250
jmp 0x1071f
jmp 0x106ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x10781
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x30a0
jmp 0x10781
leaq -0x238(%rbp), %rdi
callq 0x3080
jmp 0x10763
leaq -0x238(%rbp), %rdi
callq 0x30a0
leaq -0x30(%rbp), %rdi
callq 0x3190
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3190
movq -0x240(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
// File: chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::copyIntoChunks(int) const
PerfectMatchingSet** PerfectMatchingSet::copyIntoChunks(int numChunks) const {
    PerfectMatchingSet** chunks = new PerfectMatchingSet*[numChunks];
    long chunkSize = this->size() / numChunks;
    long numChunksWithOneExtra = this->size() % numChunks;

    int i = 0;
    for (PerfectMatchingSet::iterator beginChunk = this->begin(), endChunk = this->begin();
         beginChunk != this->end();
         beginChunk = endChunk) {
        endChunk += chunkSize;
        if (numChunksWithOneExtra-- > 0) {
            ++endChunk;
        }

        chunks[i++] = new PerfectMatchingSet(beginChunk, endChunk);
    }
    assert(i == numChunks);

    return chunks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq -0x70(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x107a0
movq -0x70(%rbp), %rdi
movslq -0xc(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
callq 0x107a0
movq -0x70(%rbp), %rdi
movslq -0xc(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
callq 0x10280
movq -0x70(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x10280
movq %rax, -0x40(%rbp)
movq -0x70(%rbp), %rdi
callq 0x10320
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x10b40
testb $0x1, %al
jne 0x10873
jmp 0x10914
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x10ca0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
jle 0x1089e
leaq -0x40(%rbp), %rdi
callq 0x10c20
movl $0x8, %edi
callq 0x32f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x10150
jmp 0x108d1
movq -0x78(%rbp), %rdx
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x2c(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x10850
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
movl $0x8, %esi
callq 0x3300
jmp 0x1094a
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x1091e
jmp 0x1093d
leaq 0x3baf(%rip), %rdi      # 0x144d4
leaq 0x3bb7(%rip), %rsi      # 0x144e3
movl $0x72, %edx
leaq 0x3bc2(%rip), %rcx      # 0x144fa
callq 0x31a0
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lionell[P]huffman-rle/main.cc
// Function: read[abi:cxx11]()
string read() {
  string l, res = "";
  while (getline(cin, l)) {
    res += l + '\n';
  }
  return res;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2280
movb $0x0, 0x5f(%rsp)
leaq 0x5e(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2330
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x5b2e(%rip), %rsi      # 0x8039
callq 0x2270
jmp 0x2512
leaq 0x5e(%rsp), %rdi
callq 0x21f0
movq 0x9abd(%rip), %rdi      # 0xbfe0
leaq 0x60(%rsp), %rsi
callq 0x2050
movq %rax, 0x8(%rsp)
jmp 0x2534
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2240
movb %al, 0x7(%rsp)
jmp 0x254e
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2558
jmp 0x25cf
leaq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0xa, %edx
callq 0x3760
jmp 0x256e
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2250
jmp 0x257f
leaq 0x28(%rsp), %rdi
callq 0x20f0
jmp 0x251c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5e(%rsp), %rdi
callq 0x21f0
jmp 0x2606
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x25fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x20f0
jmp 0x25fc
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x25e5
movq 0x18(%rsp), %rdi
callq 0x20f0
leaq 0x60(%rsp), %rdi
callq 0x20f0
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x20f0
leaq 0x60(%rsp), %rdi
callq 0x20f0
movq 0x50(%rsp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: lionell[P]huffman-rle/main.cc
// Function: optimize(Node*, bool)
void optimize(Node *root, bool zero = true) {
  if (root->val) return;
  if (zero && root->zero->freq < root->one->freq) swap(root->zero, root->one);
  if (!zero && root->zero->freq > root->one->freq) swap(root->zero, root->one);
  optimize(root->zero, true);
  optimize(root->one, false);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, 0x10(%rax)
je 0x2a32
jmp 0x2aba
testb $0x1, 0xf(%rsp)
je 0x2a65
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x14(%rax), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x14(%rcx), %eax
jge 0x2a65
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
callq 0x3b70
testb $0x1, 0xf(%rsp)
jne 0x2a98
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x14(%rax), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x14(%rcx), %eax
jle 0x2a98
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
callq 0x3b70
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x2a10
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x2a10
addq $0x18, %rsp
retq
nop