LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::disjoint_module::schedule_handle_repoint_swap(GC::smart_handle&, GC::smart_handle&)
void GC::disjoint_module::schedule_handle_repoint_swap(smart_handle &handle_a, smart_handle &handle_b)
{
	std::lock_guard<std::mutex> internal_lock(internal_mutex);

	// get their current repoint targets
	info *target_a = __get_current_target(handle_a);
	info *target_b = __get_current_target(handle_b);

	#if DRAGAZO_GARBAGE_COLLECT_DISJUNCTION_SAFETY_CHECKS

	// if we're going to repoint outside the disjunction of either handle, that's a disjunction violation
	if ((target_b && handle_a.disjunction != target_b->disjunction) || (target_a && handle_b.disjunction != target_a->disjunction))
	{
		throw GC::disjunction_error("attempt to repoint GC::ptr outside of the current disjunction");
	}

	#endif

	// only perform the swap if they point to different things
	if (target_a != target_b)
	{
		// schedule repoint actions to swap them
		__raw_schedule_handle_repoint(handle_a, target_b);
		__raw_schedule_handle_repoint(handle_b, target_a);

		// there's no need for reference counting logic in a swap operation
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5380
testl %eax, %eax
jne 0x84f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7e74
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7e74
testq %rax, %rax
je 0x8470
movq 0x8(%r15), %rcx
cmpq 0x18(%rax), %rcx
jne 0x84b4
testq %r12, %r12
je 0x8480
movq 0x8(%r14), %rcx
cmpq 0x18(%r12), %rcx
jne 0x84b4
cmpq %rax, %r12
je 0x84a1
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x829a
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x829a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5200
movl $0x10, %edi
callq 0x5110
movq %rax, %r14
leaq 0x17d9b(%rip), %rsi     # 0x20263
movq %rax, %rdi
callq 0x5460
leaq 0x29e19(%rip), %rax     # 0x322f0
movq %rax, (%r14)
leaq 0x29de7(%rip), %rsi     # 0x322c8
movq 0x2aab8(%rip), %rdx     # 0x32fa0
movq %r14, %rdi
callq 0x53f0
movl %eax, %edi
callq 0x51a0
movq %rax, %r15
movq %r14, %rdi
callq 0x51f0
jmp 0x8507
movq %rax, %r15
movq %rbx, %rdi
callq 0x5200
movq %r15, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::disjoint_module::local()
GC::disjoint_module *GC::disjoint_module::local()
{
	// get the local detour
	disjoint_module *detour = local_detour;

	// if we're taking a detour, use that, otherwise the handle is alive and we should read that instead
	return detour ? detour : local_handle().get();
}

// Assembly:
movq 0x2ab81(%rip), %rax     # 0x33290
testq %rax, %rax
je 0x8715
retq
pushq %rax
callq 0x865a
movq (%rax), %rax
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::disjoint_module_container::create_new_disjunction(GC::shared_disjoint_handle&)
void GC::disjoint_module_container::create_new_disjunction(shared_disjoint_handle &dest)
{
	// create a new disjoint module handle data block
	auto m = std::make_unique<handle_data>();
	// and construct its module in-place
	new (m->get()) disjoint_module;

	// repoint dest to the new disjunction
	dest.reset(m.release());

	// add it to the disjunction database
	{
		std::lock_guard<std::mutex> internal_lock(internal_mutex);

		// if we're not collecting, we need to put it immediately in the disjunction list
		if (!collecting) disjunctions.emplace_back(dest);
		// otherwise we need to cache the add action
		else disjunction_add_cache.emplace_back(dest);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1f8, %edi            # imm = 0x1F8
callq 0x5290
movq %rax, %r15
movl $0x1f8, %edx            # imm = 0x1F8
movq %rax, %rdi
xorl %esi, %esi
callq 0x5150
movq %r15, %rdi
callq 0x9134
movq %r15, %rsi
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x87fe
movq %rbx, %rdi
callq 0x5380
testl %eax, %eax
jne 0x87c4
cmpb $0x0, 0x28(%rbx)
je 0x8794
leaq 0x48(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa050
movq %rax, %rdi
movq %r15, %rsi
callq 0x5060
movl $0x58, %eax
jmp 0x87b3
leaq 0x30(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa050
movq %rax, %rdi
movq %r15, %rsi
callq 0x5060
movl $0x40, %eax
incq (%rbx,%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5200
movl %eax, %edi
callq 0x51a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5200
jmp 0x87db
movq %rax, %r14
xorl %r15d, %r15d
jmp 0x87e3
movq %rax, %r14
testq %r15, %r15
je 0x87f5
movl $0x1f8, %esi            # imm = 0x1F8
movq %r15, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::shared_disjoint_handle::reset(GC::handle_data*)
void GC::shared_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 strong reference and get the previous tag
		auto prev = data->tag_sub(handle_data::strong_1, std::memory_order_acq_rel);

		// if we were the last strong reference, there are no longer any strong references - destroy the object
		// we include the lock strong refs because those locks succeeded - i.e. our very existence as a non-lock strong owner proves those locks succeeded.
		if ((prev & handle_data::strong_mask) == handle_data::strong_1)
		{
			__module->blocking_collect(); // perform one final collection to make sure everything's collected
			__module->~disjoint_module(); // then destroy the module itself - its dtor asserts that all objects were collected

			// if there were also no more weak references, delete the handle
			if ((prev & handle_data::weak_mask) == 0) delete data;
			// otherwise we're not deleting it but the weak ref count might have fallen to zero in the meantime and could be waiting - alert that we're done destroying
			else data->destroyed_flag.store(true, std::memory_order_release);
		}
	}

	// repoint and test for null - must come after destruction logic to ensure the collection can potentially alias this handle
	data = other;
	if (data)
	{
		__module = data->get(); // cache the module pointer
		data->tag_add(handle_data::strong_1, std::memory_order_acq_rel); // bump up the strong ref count
	}
	else __module = nullptr; // cache the module pointer (in this case null)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
cmpq %rsi, %rdi
je 0x88b5
movq %rsi, %rbx
testq %rdi, %rdi
je 0x8885
movl $0x1, %esi
movl $0x4, %edx
callq 0x8b4c
movq %rax, %r15
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
andq %r15, %rax
cmpq $0x1, %rax
jne 0x8885
movq (%r14), %r12
movq %r12, %rdi
callq 0x757a
testb %al, %al
je 0x8846
movq (%r14), %rdi
callq 0x740c
movabsq $0xf00000000000000, %rax # imm = 0xF00000000000000
movq 0x8(%r14), %rdi
testq %rax, %r15
je 0x8876
movb $0x1, 0x1f0(%rdi)
jmp 0x8885
testq %rdi, %rdi
je 0x8885
movl $0x1f8, %esi            # imm = 0x1F8
callq 0x52a0
movq %rbx, 0x8(%r14)
testq %rbx, %rbx
je 0x88ae
movq %rbx, (%r14)
movl $0x1, %esi
movq %rbx, %rdi
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8a80
movq $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::weak_disjoint_handle::expired() const
bool GC::weak_disjoint_handle::expired() const noexcept
{
	// get the current tag
	auto tag = data ? data->tag.load(std::memory_order_acq_rel) : 0;

	// this weak ptr is expired if there are no strong refs remaining.
	// we include lock strong refs because otherwise it's possible for a series of atomic steps to result in a successful lock but intermediately no non-lock strong refs.
	// due to locking, however, this approach could report false negatives (but never false positives).
	return (tag & handle_data::strong_mask) == 0;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x8a7d
movq 0x1e8(%rax), %rax
shlq $0x8, %rax
sete %al
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/GarbageCollection.cpp
// Function: GC::handle_data::tag_add(unsigned long, std::memory_order)
GC::handle_data::tag_t GC::handle_data::tag_add(tag_t v, std::memory_order order)
{
	const auto prev = tag.fetch_add(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:
pushq %rax
decl %edx
cmpl $0x4, %edx
ja 0x8a98
leaq 0x17575(%rip), %rax     # 0x20004
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rsi, %rax
lock
xaddq %rax, 0x1e8(%rdi)
addq %rax, %rsi
movabsq $0xffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFF
movq %rsi, %rdx
andq %rcx, %rdx
andq %rax, %rcx
cmpq %rcx, %rdx
jb 0x8aee
movabsq $0xf00000000000000, %rcx # imm = 0xF00000000000000
movq %rsi, %rdx
andq %rcx, %rdx
andq %rax, %rcx
cmpq %rcx, %rdx
jb 0x8b0d
movabsq $-0x1000000000000000, %rcx # imm = 0xF000000000000000
andq %rcx, %rsi
andq %rax, %rcx
cmpq %rcx, %rsi
jb 0x8b2c
popq %rcx
retq
leaq 0x17a2f(%rip), %rdi     # 0x20524
leaq 0x1765a(%rip), %rsi     # 0x20156
leaq 0x17a4d(%rip), %rcx     # 0x20550
movl $0x39b, %edx            # imm = 0x39B
callq 0x5190
leaq 0x17a86(%rip), %rdi     # 0x2059a
leaq 0x1763b(%rip), %rsi     # 0x20156
leaq 0x17a2e(%rip), %rcx     # 0x20550
movl $0x39c, %edx            # imm = 0x39C
callq 0x5190
leaq 0x17a8f(%rip), %rdi     # 0x205c2
leaq 0x1761c(%rip), %rsi     # 0x20156
leaq 0x17a0f(%rip), %rcx     # 0x20550
movl $0x39d, %edx            # imm = 0x39D
callq 0x5190
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
decl %edx
cmpl $0x4, %edx
ja 0x8b64
leaq 0x174bd(%rip), %rax     # 0x20018
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rsi, %rax
negq %rax
lock
xaddq %rax, 0x1e8(%rdi)
movq %rax, %rcx
subq %rsi, %rcx
movabsq $0xffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFF
movq %rcx, %rsi
andq %rdx, %rsi
andq %rax, %rdx
cmpq %rdx, %rsi
ja 0x8bc0
movabsq $0xf00000000000000, %rdx # imm = 0xF00000000000000
movq %rcx, %rsi
andq %rdx, %rsi
andq %rax, %rdx
cmpq %rdx, %rsi
ja 0x8bdf
movabsq $-0x1000000000000000, %rdx # imm = 0xF000000000000000
andq %rdx, %rcx
andq %rax, %rdx
cmpq %rdx, %rcx
ja 0x8bfe
popq %rcx
retq
leaq 0x17a23(%rip), %rdi     # 0x205ea
leaq 0x17588(%rip), %rsi     # 0x20156
leaq 0x17a41(%rip), %rcx     # 0x20616
movl $0x3ac, %edx            # imm = 0x3AC
callq 0x5190
leaq 0x17a7a(%rip), %rdi     # 0x20660
leaq 0x17569(%rip), %rsi     # 0x20156
leaq 0x17a22(%rip), %rcx     # 0x20616
movl $0x3ad, %edx            # imm = 0x3AD
callq 0x5190
leaq 0x17a83(%rip), %rdi     # 0x20688
leaq 0x1754a(%rip), %rsi     # 0x20156
leaq 0x17a03(%rip), %rcx     # 0x20616
movl $0x3ae, %edx            # imm = 0x3AE
callq 0x5190
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x87fe
testq %rbx, %rbx
je 0x8c94
movabsq $0x1000000000000001, %r15 # imm = 0x1000000000000001
movq %rbx, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x8a80
movabsq $0xffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFF
andq %rax, %rcx
shrq $0x3c, %rax
cmpq %rax, %rcx
jne 0x8c7a
movq %rbx, %rdi
movq %r15, %rsi
movl $0x4, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x8b4c
decq %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x8b4c
movq %rbx, 0x8(%r14)
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x8d36
movq %rsi, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x87fe
movq 0x8(%r14), %rax
movq %r15, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq (%r14), %rax
movq %r15, (%r14)
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq (%rdi), %rdi
cmpq %rsi, %rdi
je 0x8dbd
movq %rsi, %rbx
movabsq $0x100000000000000, %r14 # imm = 0x100000000000000
testq %rdi, %rdi
je 0x8da0
movq %r14, %rsi
movl $0x4, %edx
callq 0x8b4c
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
andq %rax, %rcx
cmpq %r14, %rcx
jne 0x8da0
movq (%r15), %rax
movb 0x1f0(%rax), %al
testb $0x1, %al
je 0x8d81
movq (%r15), %rdi
testq %rdi, %rdi
je 0x8da0
movl $0x1f8, %esi            # imm = 0x1F8
callq 0x52a0
movq %rbx, (%r15)
testq %rbx, %rbx
je 0x8dbd
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x8a80
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x8e3e
movq %rsi, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8d40
movq (%r14), %rax
movq $0x0, (%r14)
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x120ca
movl $0xa, %ebp
leaq 0x20(%rsp), %r14
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x120ca
movq (%rbx), %rsi
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rsi)
movq 0x28(%rsi), %rdi
addq $0x20, %rsi
movq %r14, %rdx
callq 0x82f8
movq $0x0, 0x18(%rsp)
movq %r14, %rdi
callq 0x186a4
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x8(%rbx), %rdx
movq %rax, (%rsi)
movq 0x10(%rsi), %rdi
addq $0x8, %rsi
callq 0x82f8
movq (%rbx), %r15
leaq 0x18(%r15), %rbx
decl %ebp
jne 0xa0e2
movq (%rsp), %rsi
movq 0x18(%r15), %rax
addq $0x20, %r15
movq %rax, (%rsi)
movq 0x10(%rsi), %rdi
addq $0x8, %rsi
movq %r15, %rdx
callq 0x82f8
movq (%rbx), %rsi
leaq 0x8(%rsp), %r14
movq -0x8(%r14), %rax
movq %rax, 0x18(%rsi)
movq 0x28(%rsi), %rdi
addq $0x20, %rsi
movq %r14, %rdx
callq 0x82f8
movq (%rsp), %rax
movq (%rbx), %rcx
movq %rcx, (%rsp)
movq %rax, (%rbx)
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x842a
movq (%rsp), %rax
movq (%rbx), %rcx
movq %rcx, (%rsp)
movq %rax, (%rbx)
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x842a
movq $0x0, (%rsp)
movq %r14, %rdi
callq 0x186a4
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa1ef
jmp 0xa1ef
movq %rax, %rbx
movq $0x0, 0x18(%rsp)
movq %r14, %rdi
callq 0x186a4
jmp 0xa1f2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq $0x0, -0x8(%rdi)
callq 0x186a4
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/./GarbageCollection.h
// Function: GC::thread::thread<main::$_1>(GC::new_disjunction_t, main::$_1&&)
explicit thread(new_disjunction_t, Function &&f, Args &&...args) : t([](std::decay_t<Function> &&ff, std::decay_t<Args> &&...fargs)
		{
			// now that we're a new thread, repoint our local disjunction handle to a new disjunction
			disjoint_module_container::get().create_new_disjunction(disjoint_module::local_handle());

			// then invoke the user function
			std::invoke(std::move(ff), std::move(fargs)...);

		}, std::forward<Function>(f), std::forward<Args>(args)...)
		{}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x10, %edi
callq 0x5290
leaq 0x23002(%rip), %rcx     # 0x32580
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5260
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf5a3
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf5bc
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
movl $0x2d, (%rsi)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x15a26
movq (%r15), %rax
leaq 0x18(%rsp), %r15
movq %rax, (%r14)
leaq 0x8(%r14), %r12
movq 0x10(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x82f8
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
callq 0x186a4
movq %r12, %rdi
callq *%rbx
addq $0x20, %r14
movq %r14, %rdi
callq *%rbx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
callq 0x186a4
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/./GarbageCollection.h
// Function: GC::ptr<int []> GC::adopt<int, std::default_delete<int []>>(int*, unsigned long)
[[nodiscard]]
	static ptr<T[]> adopt(T obj[], std::size_t count)
	{
		// -- verification -- //

		// if obj is null, return an null ptr
		if (!obj) return {};

		// -- normalize T -- //

		// get the allocator
		typedef checked_aligned_allocator_for<info> allocator_t;

		// -- create the vtable -- //

		// use lambda to conveniently create the set of all router functions for type T
		auto router_set = [](info &handle, auto func) { for (std::size_t i = 0; i < handle.count; ++i) GC::route(reinterpret_cast<T*>(handle.obj)[i], func); };

		static const info_vtable _vtable(
			[](info &handle) { Deleter()(reinterpret_cast<T*>(handle.obj)); },
			[](info &handle) { allocator_t::dealloc(&handle); },
			router_set,
			router_set
		);

		// -- create the info object for management -- //

		info *handle;

		// allocate the buffer space for the info object
		try { handle = reinterpret_cast<info*>(allocator_t::alloc(sizeof(info))); }
		// on failure, delete the object and rethrow whatever killed us
		catch (...) { Deleter()(obj); throw; }

		// construct the info object
		new (handle) info(obj, count, &_vtable);

		// -- do the garbage collection aspects -- //

		// claim its children
		handle->route(GC::router_unroot);

		// create the ptr first - this roots obj
		ptr<T[]> res(obj, handle, GC::bind_new_obj);

		// begin timed collection (if it's not already)
		GC::start_timed_collect();

		// return the now-initialized ptr
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x18056
movq %rdx, %r12
movq %rsi, %r14
movb 0x1b440(%rip), %al      # 0x33430
testb %al, %al
je 0x18084
movl $0x40, %edi
callq 0x185a6
movq %rax, %r15
movq %r14, (%rax)
movq %r12, 0x8(%rax)
leaq 0x1b3fd(%rip), %rax     # 0x33410
movq %rax, 0x10(%r15)
callq 0x8708
movq %rax, 0x18(%r15)
movq 0x10(%r15), %rax
leaq -0xf179(%rip), %rsi     # 0x8eb2
movq %r15, %rdi
callq *0x10(%rax)
movq %r14, (%rbx)
leaq 0x8(%rbx), %r14
callq 0x8708
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7ce0
callq 0x8ede
jmp 0x18075
movq $0x0, (%rbx)
leaq 0x8(%rbx), %r14
callq 0x8708
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x7bd2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6b85
jmp 0x17ff8
movq %rax, %r15
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x186a4
jmp 0x180bf
movq %rax, %rdi
callq 0x50e0
movq %r14, %rdi
callq 0x5320
callq 0x5370
movq %rax, %r15
callq 0x53d0
movq %r15, %rdi
callq 0x5430
movq %rax, %rdi
callq 0x90ea
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
callq 0x5340
testq %rax, %rax
jne 0x185ce
callq 0x8ebe
testb $0x2, %al
jne 0x185c1
xorl %eax, %eax
jmp 0x185ce
callq 0x8e90
movq %rbx, %rdi
callq 0x5340
testq %rax, %rax
je 0x185d5
popq %rbx
retq
movl $0x8, %edi
callq 0x5110
movq 0x1a9aa(%rip), %rcx     # 0x32f90
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1a9c4(%rip), %rsi     # 0x32fb8
movq 0x1a985(%rip), %rdx     # 0x32f80
movq %rax, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq *%rsi
leaq 0x20(%rbx), %rdi
callq *%r14
leaq 0x38(%rbx), %rdi
callq *%r14
leaq 0x50(%rbx), %rdi
callq *%r14
leaq 0x68(%rbx), %rdi
callq *%r14
leaq 0x80(%rbx), %rdi
callq *%r14
leaq 0x98(%rbx), %rdi
callq *%r14
leaq 0xb0(%rbx), %rdi
callq *%r14
leaq 0xe8(%rbx), %rdi
callq *%r14
leaq 0x128(%rbx), %rdi
callq *%r14
leaq 0x140(%rbx), %rdi
callq *%r14
leaq 0x158(%rbx), %rdi
callq *%r14
addq $0x170, %rbx            # imm = 0x170
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1989e
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x1989e
leaq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x1989e
addq $0xc0, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1989e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1bbcf
movq %rsi, %r14
leaq 0x38(%rbx), %r15
movq %r15, %rdi
callq 0x5380
testl %eax, %eax
jne 0x1bbd8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bc48
movq %r15, %rdi
callq 0x5200
addq $0x60, %r14
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x1bbf2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x51a0
movq %rax, %rbx
movq %r15, %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1c0b9
movq %rsi, %r14
leaq 0x38(%rbx), %r12
leaq 0x38(%rsi), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1c128
movq %rbx, %rdi
movq %r14, %rsi
callq 0x572a
movq %r12, %rdi
callq 0x5200
movq %r15, %rdi
callq 0x5200
addq $0x60, %r14
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x1c0d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x90ea
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1c111
movq %rsi, %r12
leaq 0x38(%rbx), %r15
leaq 0x38(%rsi), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c1fe
movq %rbx, %rdi
movq %r12, %rsi
callq 0x572a
movq %r15, %rdi
callq 0x5200
movq %r14, %rdi
callq 0x5200
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x90ea
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/test.cpp
// Function: void GC::router<SymbolTable>::route<GC::router_fn>(SymbolTable const&, GC::router_fn)
static void route(const SymbolTable &table, F func)
    {
		{
			// modification of the mutable collection of GC::ptr and router must be mutually exclusive
			std::lock_guard<std::mutex> lock(table.symbols_mutex);
			GC::route(table.symbols, func);
		}
		GC::route(table.better_symbols, func);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
movq %r15, %rdi
callq 0x5380
testl %eax, %eax
jne 0x1c564
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x1c542
leaq 0x30(%r12), %rdi
callq *%rbx
movq (%r12), %r12
jmp 0x1c530
movq %r15, %rdi
callq 0x5200
addq $0x60, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1c57e
movl %eax, %edi
callq 0x51a0
movq %rax, %rbx
movq %r15, %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O1/dragazo[P]cpp-gc/test.cpp
// Function: void GC::router<MaybeTreeNode>::route<GC::router_fn>(MaybeTreeNode const&, GC::router_fn)
static void route(const MaybeTreeNode &maybe, F func)
    {
        // this must be synchronized with constructing/destucting the buffer object.
        std::lock_guard<std::mutex> lock(maybe.buf_mutex);
        
        // because TreeNode contains GC::ptr objects, we need to route to it,
        // but only if the MaybeTreeNode actually has it constructed in the buffer.
        if (maybe.contains_tree_node) GC::route(*reinterpret_cast<const TreeNode*>(maybe.buf), func);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48(%rdi), %rbx
movq %rbx, %rdi
callq 0x5380
testl %eax, %eax
jne 0x1df18
cmpb $0x1, 0x40(%r15)
jne 0x1df0b
leaq 0x8(%r15), %rdi
callq *%r14
addq $0x20, %r15
movq %r15, %rdi
callq *%r14
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5200
movl %eax, %edi
callq 0x51a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5200
movq %r14, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x2fe0(%rip), %rsi      # 0x7025
leaq 0x2fe3(%rip), %rdx      # 0x702f
callq 0x5320
movq 0x8(%rbx), %r14
cmpl $0x2, %r14d
jl 0x4096
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
decq %r14
callq 0x2090
cltd
idivl %r14d
movq (%rbx), %rax
movb (%rax,%r14), %cl
movslq %edx, %rdx
movb (%rax,%rdx), %sil
movb %sil, (%rax,%r14)
movq (%rbx), %rax
movb %cl, (%rax,%rdx)
leaq -0x1(%r14), %rax
incq %r14
cmpq $0x2, %r14
movq %rax, %r14
jg 0x4065
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x64f0
cmpq $0x1, %rax
jne 0x40e2
movq %r14, %rdi
xorl %esi, %esi
callq 0x635e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x53b0
jmp 0x4139
movq %r15, %rdi
callq 0x64f0
cmpq $0x1, %rax
je 0x410c
testq %rax, %rax
jne 0x412b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2f22(%rip), %rsi      # 0x7025
leaq 0x2f25(%rip), %rdx      # 0x702f
jmp 0x4121
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x30d5(%rip), %rsi      # 0x71ef
leaq 0x30d8(%rip), %rdx      # 0x71f9
movq %rbx, %rdi
callq 0x5320
jmp 0x4139
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4142
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chrischute[P]are-you-the-one/src/ayto.cpp
// Function: getPrintableNames(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> 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 PerfectMatching& p,
                         const map<int, string>* femaleNames,
                         const map<char, string>* maleNames) {
    stringstream printableNamesBuilder;

    int i = 0;
    for (PerfectMatching::const_iterator it = p.begin(); it != p.end(); it++) {
        printableNamesBuilder << "    " <<  femaleNames->at(i++)
                              << " + " << maleNames->at(*it);
        if (it != p.end() - 1)
            printableNamesBuilder << endl;
    }

    return printableNamesBuilder.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2190
cmpq $0x0, 0x8(%r12)
je 0x4ae8
movq (%r12), %r14
leaq 0x30(%rsp), %r13
xorl %r15d, %r15d
movl $0x4, %edx
movq %r13, %rdi
leaq 0x280a(%rip), %rsi      # 0x723a
callq 0x2280
movl %r15d, 0x4(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x502e
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r13, %rdi
callq 0x2280
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
leaq 0x27d5(%rip), %rsi      # 0x723f
callq 0x2280
leaq (%r14,%r15), %rbp
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x507a
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x2280
movq (%r12), %rax
movq 0x8(%r12), %rcx
addq %rcx, %rax
decq %rax
cmpq %rax, %rbp
je 0x4acc
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2230
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movq (%r12), %rax
addq 0x8(%r12), %rax
leaq (%r14,%r15), %rcx
incq %rcx
incq %r15
cmpq %rax, %rcx
jne 0x4a21
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2310
movq 0x64b7(%rip), %rsi      # 0xafb8
leaq 0x20(%rsp), %rdi
callq 0x21b0
leaq 0xa0(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4b31
jmp 0x4b31
movq %rax, %rbx
movq 0x647d(%rip), %rsi      # 0xafb8
leaq 0x20(%rsp), %rdi
callq 0x21b0
leaq 0xa0(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2190
leaq 0x18(%rsp), %r12
leaq 0x26b7(%rip), %rsi      # 0x7243
movl $0x1, %edx
movq %r12, %rdi
callq 0x2280
movq %r13, %rdi
movq %r15, %rsi
callq 0x502e
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r12, %rdi
callq 0x2280
movq %rax, %r12
leaq 0x2688(%rip), %rsi      # 0x7245
movl $0x2, %edx
movq %rax, %rdi
callq 0x2280
addq $0x4, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x507a
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r12, %rdi
callq 0x2280
leaq 0x293a(%rip), %rsi      # 0x7529
movl $0x1, %edx
movq %rax, %rdi
callq 0x2280
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2310
movq 0x63a8(%rip), %rsi      # 0xafb8
leaq 0x8(%rsp), %rdi
callq 0x21b0
leaq 0x88(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x6373(%rip), %rsi      # 0xafb8
leaq 0x8(%rsp), %rdi
callq 0x21b0
leaq 0x88(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2190
leaq 0x20(%rsp), %r14
leaq 0x25b2(%rip), %rsi      # 0x7243
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
cmpq $0x0, 0x8(%r15)
je 0x4cfc
movq (%r15), %rbp
leaq 0xf(%rsp), %r12
leaq 0x2591(%rip), %r13      # 0x7245
movb (%rbp), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2280
movq (%r15), %rax
movq 0x8(%r15), %rcx
addq %rcx, %rax
decq %rax
cmpq %rax, %rbp
je 0x4ced
movl $0x2, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2280
incq %rbp
movq (%r15), %rax
addq 0x8(%r15), %rax
cmpq %rax, %rbp
jne 0x4cb4
leaq 0x2826(%rip), %rsi      # 0x7529
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2310
movq 0x6294(%rip), %rsi      # 0xafb8
leaq 0x10(%rsp), %rdi
callq 0x21b0
leaq 0x90(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d52
movq %rax, %rbx
movq 0x625c(%rip), %rsi      # 0xafb8
leaq 0x10(%rsp), %rdi
callq 0x21b0
leaq 0x90(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
cmovbq %rax, %rcx
testq %rcx, %rcx
je 0x6168
movq (%rdi), %rdx
movq (%rsi), %rsi
xorl %edi, %edi
xorl %eax, %eax
movb (%rdx,%rdi), %r8b
xorl %r9d, %r9d
cmpb (%rsi,%rdi), %r8b
sete %r9b
addl %r9d, %eax
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x614a
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2240
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %r13
movq (%r13), %r12
cmpq 0x8(%r13), %r12
je 0x62a0
movq %r15, %rdi
movq %r12, %rsi
callq 0x612c
cmpl %ebp, %eax
jne 0x6297
movq %r14, %rdi
movq %r12, %rsi
callq 0x66b2
addq $0x20, %r12
movq (%rbx), %r13
jmp 0x6277
testq %r13, %r13
je 0x62ba
movq %r13, %rdi
callq 0x6656
movl $0x18, %esi
movq %r13, %rdi
callq 0x2250
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2240
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %r13
movq (%r13), %r12
cmpq 0x8(%r13), %r12
je 0x6331
movslq (%r15), %rax
movq (%r12), %rcx
movb (%rcx,%rax), %al
cmpb 0x4(%r15), %al
setne %al
cmpb %bpl, %al
je 0x6328
movq %r14, %rdi
movq %r12, %rsi
callq 0x66b2
addq $0x20, %r12
movq (%rbx), %r13
jmp 0x6301
testq %r13, %r13
je 0x634b
movq %r13, %rdi
callq 0x6656
movl $0x18, %esi
movq %r13, %rdi
callq 0x2250
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc7b(%rip), %rsi       # 0x7025
leaq 0xc7e(%rip), %rdx       # 0x702f
movq %rsp, %r14
movq %r14, %rdi
callq 0x5320
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x66b2
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq %rdi, %rsi
callq 0x5440
testb %al, %al
jne 0x63bc
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x63f2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2250
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6415
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x2320
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x22a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6484
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x66b2
jmp 0x645e
leaq 0x20(%rsp), %rdi
callq 0x2070
leaq 0x20(%rsp), %rdi
callq 0x2080
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x64ae
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2250
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x64c4
movq %rax, %rbx
jmp 0x64d1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2080
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x64e7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x2370
nop