             typename ValueIteratorT,
             typename OffsetT,
             typename CompareOpT>
-  CUB_RUNTIME_FUNCTION static cudaError_t SortPairsCopy(void *d_temp_storage,              ///< [in] Device-accessible allocation of temporary storage. When NULL, the required allocation size is written to \p temp_storage_bytes and no work is done.
-                                                        std::size_t &temp_storage_bytes,   ///< [in,out] Reference to size in bytes of \p d_temp_storage allocation
-                                                        KeyInputIteratorT d_input_keys,    ///< [in] Pointer to the input sequence of unsorted input keys
-                                                        ValueInputIteratorT d_input_items, ///< [in] Pointer to the input sequence of unsorted input values
-                                                        KeyIteratorT d_output_keys,        ///< [out] Pointer to the output sequence of sorted input keys
-                                                        ValueIteratorT d_output_items,     ///< [out] Pointer to the output sequence of sorted input values
-                                                        OffsetT num_items,                 ///< [in] Number of items to sort
-                                                        CompareOpT compare_op,             ///< [in] Comparison function object which returns true if the first argument is ordered before the second
-                                                        cudaStream_t stream = 0,           ///< [in] <b>[optional]</b> CUDA stream to launch kernels within. Default is stream<sub>0</sub>.
-                                                        bool debug_synchronous = false)    ///< [in] <b>[optional]</b> Whether or not to synchronize the stream after every kernel launch to check for errors.  Also causes launch configurations to be printed to the console.  Default is \p false.
+  CUB_RUNTIME_FUNCTION static cudaError_t
+  SortPairsCopy(void *d_temp_storage,
+                std::size_t &temp_storage_bytes,
+                KeyInputIteratorT d_input_keys,
+                ValueInputIteratorT d_input_items,
+                KeyIteratorT d_output_keys,
+                ValueIteratorT d_output_items,
+                OffsetT num_items,
+                CompareOpT compare_op,
+                cudaStream_t stream    = 0,
+                bool debug_synchronous = false)
   {
     using DispatchMergeSortT = DispatchMergeSort<KeyInputIteratorT,
                                                  ValueInputIteratorT,

 *   }
 * };
 *
 * // Declare, allocate, and initialize device-accessible pointers for sorting data
 * thrust::device_vector<KeyType> d_keys(num_items);
 * thrust::device_vector<DataType> d_values(num_items);
 * // ...

 *   thrust::raw_pointer_cast(d_values.data()),
 *   num_items,
 *   CustomLess());
 * @endcode
 *
 * [LessThan Comparable] https://en.cppreference.com/w/cpp/named_req/LessThanComparable
 */
struct DeviceMergeSort
{

  /**
   * @brief Sorts items using a merge sorting method.
   *
   * @par
   * SortPairs is not guaranteed to be stable. That is, suppose that i and j are
   * equivalent: neither one is less than the other. It is not guaranteed
   * that the relative order of these two elements will be preserved by sort.
   *
   * @par Snippet
   * The code snippet below illustrates the sorting of a device vector of `int`
   * keys with associated vector of `int` values.
   * @par
   * @code
   * #include <cub/cub.cuh>
   * // or equivalently <cub/device/device_merge_sort.cuh>
   *
   * // Declare, allocate, and initialize device-accessible pointers for
   * // sorting data
   * int  num_items;       // e.g., 7
   * int  *d_keys;         // e.g., [8, 6, 6, 5, 3, 0, 9]
   * int  *d_values;       // e.g., [0, 1, 2, 3, 4, 5, 6]
