unsigned int neigh_side = invalid_uint;
              const Elem * neigh =
#ifdef LIBMESH_ENABLE_UNIQUE_ID
                  _mesh->has_disjoint_neighbor_node_keys() ? elem->neighbor_ptr(s) :
#endif
                  db->neighbor(id, *point_locator, elem, s, &neigh_side);

                      sender_could_become_owner)
                    {
                      if (it != repartitioned_node_pids.end() &&
                          pid < it->second)
                        it->second = pid;
                      else
                        repartitioned_node_pids[n] = pid;
                    }
                  else
                    if (it == repartitioned_node_pids.end())
                      repartitioned_node_pids[n] =
                        DofObject::invalid_processor_id;

                  repartitioned_node_sets_to_push[pid].insert(n);

    if (entry == name)
      return true;

  return false;
}

const std::string disjoint_neighbor_node_key_name = "disjoint_neighbor_node_key";
}

void MeshBase::add_disjoint_neighbor_node_keys()
{
  constexpr unique_id_type no_key = DofObject::invalid_unique_id;
  this->add_node_datum<unique_id_type>(disjoint_neighbor_node_key_name, true, &no_key);
}

bool MeshBase::has_disjoint_neighbor_node_keys() const
{
  return this->has_node_integer(disjoint_neighbor_node_key_name);
}

unique_id_type MeshBase::disjoint_neighbor_node_key(const Node & node) const
{
  if (this->has_disjoint_neighbor_node_keys())
    {
      const auto key = node.get_extra_datum<unique_id_type>(
        this->get_node_integer_index(disjoint_neighbor_node_key_name));
      if (key != DofObject::invalid_unique_id)
        return key;
    }
  return node.unique_id();
}

void MeshBase::set_disjoint_neighbor_node_key(Node & node, const unique_id_type key) const
{
  node.set_extra_datum<unique_id_type>(
    this->get_node_integer_index(disjoint_neighbor_node_key_name), key);
}
#endif // LIBMESH_ENABLE_UNIQUE_ID

        return false;
      if (!other_elem->topologically_equal(*elem))
        return false;
    }
  for (const auto & elem : this->element_ptr_range())
    if (!other_mesh.query_elem_ptr(elem->id()))
      return false;

    {
      ray_target = inside - Point(1);
      intersection_distances =
        this->find_ray_intersections(inside, ray_target);
    }

  // I'd make this an assert, but I'm not 100% confident we can't

  auto * db = this->get_disjoint_neighbor_boundary_pairs();

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (db && this->has_disjoint_neighbor_node_keys())
    {
      // Match sides across disjoint neighbor boundary pairs by their
      // sorted vertex keys. The keys are independent of the node
      // coordinates, so this gives the same neighbors on a deformed mesh.
      typedef std::tuple<Elem *, unsigned int, boundary_id_type> side_type;
      std::map<std::vector<unique_id_type>, std::vector<side_type>> key_to_sides;
      std::vector<boundary_id_type> side_bcids;

      // Key every disjoint side, including sides with a neighbor, so
      // that a side without a neighbor always finds its paired side.
      for (const auto & element : this->element_ptr_range())
        for (auto ms : element->side_index_range())
          {
            this->get_boundary_info().boundary_ids(element, ms, side_bcids);
            for (const auto bcid : side_bcids)
              {
                if (!db->boundary(bcid))
                  continue;

                std::vector<unique_id_type> key;
                for (const auto n : element->nodes_on_side(ms))
                  if (element->is_vertex(n))
                    key.push_back(this->disjoint_neighbor_node_key(element->node_ref(n)));
                std::sort(key.begin(), key.end());
                key_to_sides[std::move(key)].emplace_back(element, ms, bcid);
              }
          }

      for (const auto & [_, sides] : key_to_sides)
        for (const auto & [elem, s, bcid] : sides)
          {
            const boundary_id_type paired_bcid = db->boundary(bcid)->pairedboundary;
            Elem * neigh = nullptr;
            for (const auto & [candidate, cs, candidate_bcid] : sides)
              if (candidate != elem && candidate_bcid == paired_bcid)
                {
                  neigh = candidate;
                  break;
                }

            // A local element must have its disjoint neighbor at least
            // ghosted. A ghost element may have a remote one.
            libmesh_error_msg_if(!neigh && (this->is_serial() ||
                                            elem->processor_id() == this->processor_id()),
                                 "Disjoint neighbor not found");
            elem->set_neighbor(s, neigh ? neigh : const_cast<RemoteElem *>(remote_elem));
          }
    }
  else