     Initialize(entropy_reduction, h_keys_in, num_items, max_segment);
     int num_segments = Solve(h_keys_in, h_keys_reference, h_values_in, h_values_reference, equality_op, reduction_op, num_items);
 
-    printf("\nPointer %s cub::DeviceReduce::ReduceByKey %d items, %d segments (avg run length %d), {%s,%s} key value pairs, entropy_reduction %d\n",
+    printf("\nPointer %s cub::DeviceReduce::ReduceByKey %s reduction of %d items, %d segments (avg run length %d), {%s,%s} key value pairs, max_segment %d, entropy_reduction %d\n",
         (BACKEND == CDP) ? "CDP CUB" : (BACKEND == THRUST) ? "Thrust" : "CUB",
+        (Equals<ReductionOp, Sum>::VALUE) ? "Sum" : "Max",
         num_items, num_segments, num_items / num_segments,
         key_type_string, value_type_string,
-        entropy_reduction);
+        max_segment, entropy_reduction);
     fflush(stdout);
 
     // Allocate problem device arrays

    char*           key_type_string,
    char*           value_type_string)
{
    Test<CUB, Key, Value>(num_items, key_type_string, value_type_string);
#ifdef CUB_CDP
    Test<CDP, Key, Value>(num_items, key_type_string, value_type_string);
#endif
}


/ **
 * Test different input sizes
 * /
template <
    typename        Key,
    typename        Value>
void Test(
    int             num_items,
    char*           key_type_string,
    char*           value_type_string)
{
    if (num_items < 0)
    {
        TestOp<Key, Value>(1,        key_type_string, value_type_string);
        TestOp<Key, Value>(100,      key_type_string, value_type_string);
        TestOp<Key, Value>(10000,    key_type_string, value_type_string);
        TestOp<Key, Value>(1000000,  key_type_string, value_type_string);
    }
    else
    {
        TestOp<Key, Value>(num_items, key_type_string, value_type_string);
    }
}
*/


//---------------------------------------------------------------------

}


/**
 * Dispatch to run-length encode entrypoint
 */
template <
    typename                    KeyInputIterator,
    typename                    KeyOutputIterator,
    typename                    ValueOutputIterator,
    typename                    NumSegmentsIterator,
    typename                    Offset>
__host__ __device__ __forceinline__
cudaError_t Dispatch(
    Int2Type<CUB>               dispatch_to,
    int                         timing_timing_iterations,
    size_t                      *d_temp_storage_bytes,
    cudaError_t                 *d_cdp_error,

    void                        *d_temp_storage,
    size_t                      &temp_storage_bytes,
    KeyInputIterator            d_keys_in,
    KeyOutputIterator           d_keys_out,
    ConstantInputIterator<typename std::iterator_traits<ValueOutputIterator>::value_type, Offset> d_values_in,
    ValueOutputIterator         d_values_out,
    NumSegmentsIterator         d_num_segments,
    cub::Equality               equality_op,
    cub::Sum                    reduction_op,
    Offset                      num_items,
    cudaStream_t                stream,
    bool                        debug_synchronous)
{
    cudaError_t error = cudaSuccess;
    for (int i = 0; i < timing_timing_iterations; ++i)
    {
        error = DeviceReduce::RunLengthEncode(
            d_temp_storage,
            temp_storage_bytes,
            d_keys_in,
            d_keys_out,
            d_values_out,
            d_num_segments,
            num_items,
            stream,
            debug_synchronous);
    }
    return error;
}



//---------------------------------------------------------------------
// Dispatch to different Thrust entrypoints
//---------------------------------------------------------------------

/**
 * Dispatch to reduce-by-key entrypoint
 */
template <
    typename                    KeyInputIterator,
