diff --git a/doc/modules/ROOT/pages/api_reference.adoc b/doc/modules/ROOT/pages/api_reference.adoc
index c8fb32b..174f204 100644
--- a/doc/modules/ROOT/pages/api_reference.adoc
+++ b/doc/modules/ROOT/pages/api_reference.adoc
@@ -61,16 +61,38 @@ https://www.boost.org/LICENSE_1_0.txt
 
 | xref:policies.adoc[`overflow_policy`]
 | Enum class specifying the overflow handling policy for arithmetic operations
+
+| xref:cuda.adoc#cuda_device_exception_mode[`device_exception_mode`]
+| Enum class controlling whether CUDA device errors trap the kernel or defer to the host
 |===
 
-=== CUDA Specific Handling
+=== CUDA Support
 
 [cols="1,2", options="header"]
 |===
 | Type | Description
 
-| xref:cuda.adoc[`device_error_context`]
-| CUDA specific device error context replacing `cudaDeviceSynchronize` and `cudaGetLastError`
+| xref:cuda.adoc#cuda_device_error_context[`device_error_context`]
+| CUDA device error context replacing `cudaDeviceSynchronize` and `cudaGetLastError`
+
+| xref:cuda.adoc#cuda_device_exception_mode[`device_exception_mode`]
+| Enum selecting trapped (immediate `__trap()`) or untrapped (deferred host exception) error handling
+|===
+
+==== `device_error_context` Member Functions
+
+[cols="1,2", options="header"]
+|===
+| Function | Description
+
+| xref:cuda.adoc#cuda_device_error_context_reset[`reset`]
+| Clears the error state so the context can be reused across kernel launches
+
+| xref:cuda.adoc#cuda_device_error_context_set_mode[`set_device_exception_method`]
+| Changes the device exception mode after construction
+
+| xref:cuda.adoc#cuda_device_error_context_synchronize[`synchronize`]
+| Synchronizes the device, checks for captured errors, and throws the corresponding host exception
 |===
 
 [#api_functions]
@@ -337,4 +359,7 @@ This header is not included in the convenience header since it requires external
 
 | `<boost/safe_numbers/byte_conversions.hpp>`
 | Byte order conversion functions (`to_be`, `from_be`, `to_le`, `from_le`, `to_be_bytes`, `from_be_bytes`, `to_le_bytes`, `from_le_bytes`, `to_ne_bytes`, `from_ne_bytes`)
+
+| `<boost/safe_numbers/cuda_error_reporting.hpp>`
+| CUDA device error handling (`device_exception_mode`, `device_error_context`)
 |===
diff --git a/doc/modules/ROOT/pages/cuda.adoc b/doc/modules/ROOT/pages/cuda.adoc
index dc7ff15..2d7a0a3 100644
--- a/doc/modules/ROOT/pages/cuda.adoc
+++ b/doc/modules/ROOT/pages/cuda.adoc
@@ -45,7 +45,7 @@ int main()
 }
 ----
 
-For the on-device computation behavior to match the CPU computation behavior, we have our own error context class
+For the on-device computation behavior to match the CPU computation behavior, we have our own error context class.
 This reduces our above example to the following:
 
 [source, c++]
@@ -92,5 +92,201 @@ Device error on thread 256 at /home/runner/work/safe_numbers/boost-root/libs/saf
 
 The `device_error_context` will also attempt to `printf` the error into the terminal.
 This works when compiling with verbose mode `-V`.
-`printf` error messages will look the same as the message displayed by the thrown exception
+`printf` error messages will look the same as the message displayed by the thrown exception.
+
+[#cuda_device_exception_mode]
+== The `device_exception_mode` Enum
+
+[source,c++]
+----
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
+
+namespace boost::safe_numbers {
+
+enum class device_exception_mode : unsigned
+{
+    trapped,
+    untrapped,
+};
+
+inline constexpr auto trapped = device_exception_mode::trapped;
+inline constexpr auto untrapped = device_exception_mode::untrapped;
+
+} // namespace boost::safe_numbers
+----
+
+This enum controls what happens when a safe_numbers operation detects an error on the CUDA device.
+
+|===
+| Mode | Behavior
+
+| `trapped`
+| Calls `__trap()` on the device, which immediately terminates the kernel.
+This is a *sticky, unrecoverable error*: the CUDA context is corrupted and the entire host process must be terminated in order to reuse the device.
+All other threads in the kernel spin until `__trap()` takes effect.
+This is the default mode because it guarantees a hard failure that cannot be silently ignored.
+
+| `untrapped`
+| Records the error in managed memory and returns without calling `__trap()`.
+The kernel completes normally — other threads may continue executing with potentially incorrect values.
+The error is detected on the host when `synchronize()` is called, which throws the appropriate exception.
+This mode preserves the CUDA context, allowing the `device_error_context` to be reused for subsequent kernel launches after catching the exception.
+|===
+
+Convenience constants `boost::safe_numbers::trapped` and `boost::safe_numbers::untrapped` are provided so the mode can be passed without qualifying the enum:
+
+[source,c++]
+----
+boost::safe_numbers::device_error_context ctx{boost::safe_numbers::untrapped};
+----
+
+[#cuda_device_error_context]
+== The `device_error_context` Class
+
+[source,c++]
+----
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
+
+namespace boost::safe_numbers {
+
+class device_error_context
+{
+public:
+    device_error_context();
+    explicit device_error_context(device_exception_mode e);
+    ~device_error_context();
+
+    device_error_context(const device_error_context&) = delete;
+    device_error_context& operator=(const device_error_context&) = delete;
+
+    void reset();
+    void set_device_exception_method(device_exception_mode e);
+    void synchronize();
+};
+
+} // namespace boost::safe_numbers
+----
+
+The `device_error_context` class manages a CUDA `__managed__` memory buffer used to capture errors from device code.
+When a safe_numbers operation detects an error on the GPU (overflow, underflow, domain error), the error details — file, line, thread ID, expression, and exception type — are written into this shared buffer.
+The host then reads the buffer during `synchronize()` and throws the corresponding `std::exception`.
+
+Only *one* `device_error_context` may exist at a time.
+Constructing a second instance while one is already alive throws `std::logic_error`.
+This constraint prevents races on the shared error buffer.
+
+=== Constructors
+
+[source,c++]
+----
+device_error_context();
+----
+
+Constructs a context with the default `device_exception_mode::trapped` mode.
+Clears any stale error state.
+
+[source,c++]
+----
+explicit device_error_context(device_exception_mode e);
+----
+
+Constructs a context with the specified exception mode.
+Clears any stale error state.
+
+[#cuda_device_error_context_reset]
+=== `reset`
+
+[source,c++]
+----
+void reset();
+----
+
+Clears the error fields (flag, file, line, thread ID, expression) so the context can be reused across kernel launches.
+This is called automatically by the constructors and by `synchronize()` after reading the error state.
+
+[#cuda_device_error_context_set_mode]
+=== `set_device_exception_method`
+
+[source,c++]
+----
+void set_device_exception_method(device_exception_mode e);
+----
+
+Changes the device exception mode after construction.
+This writes to `__managed__` memory, so it takes effect on the next kernel launch.
+
+[#cuda_device_error_context_synchronize]
+=== `synchronize`
+
+[source,c++]
+----
+void synchronize();
+----
+
+Calls `cudaDeviceSynchronize()`, then inspects the managed error buffer.
+If an error was captured by device code, the error state is cleared and the appropriate exception is thrown on the host:
+
+|===
+| Device Error | Host Exception
+
+| Overflow
+| `std::overflow_error`
+
+| Underflow
+| `std::underflow_error`
+
+| Domain error (e.g. division by zero)
+| `std::domain_error`
+
+| Unknown
+| `std::runtime_error`
+|===
+
+The error state is cleared *before* throwing, so after catching the exception the same context is immediately reusable — no manual `reset()` call is needed.
+
+If no device error was captured but `cudaDeviceSynchronize()` returned a non-success status (e.g. from a `__trap()` in trapped mode), a `std::runtime_error` is thrown with the CUDA error string.
+
+== Choosing a Mode
+
+Use `trapped` (the default) when errors must halt execution immediately and silently continuing with wrong results is unacceptable.
+This is the safest option, but the CUDA context cannot be recovered — the process must exit.
+
+Use `untrapped` when you want to detect errors on the host and handle them gracefully (e.g. retry with different inputs, log and continue, or run a fallback path).
+Be aware that other threads in the kernel may continue executing with incorrect values between the point of error and kernel completion.
+
+[source,c++]
+----
+// Trapped mode (default): any device error is immediately fatal
+{
+    boost::safe_numbers::device_error_context ctx;
+    my_kernel<<<blocks, threads>>>(input, output, n);
+
+    try
+    {
+        ctx.synchronize();
+    }
+    catch (const std::runtime_error& e)
+    {
+        // CUDA context is corrupted — log and terminate
+        std::cerr << e.what() << std::endl;
+        return EXIT_FAILURE;
+    }
+}
+
+// Untrapped mode: errors are deferred to the host
+{
+    boost::safe_numbers::device_error_context ctx{boost::safe_numbers::untrapped};
+    my_kernel<<<blocks, threads>>>(input, output, n);
+
+    try
+    {
+        ctx.synchronize();
+    }
+    catch (const std::overflow_error& e)
+    {
+        // Context is still valid — can reuse for another launch
+        std::cerr << "Overflow detected: " << e.what() << std::endl;
+    }
+}
+----
 
diff --git a/examples/cuda.cu b/examples/cuda.cu
index eb0a63c..f1d2724 100644
--- a/examples/cuda.cu
+++ b/examples/cuda.cu
@@ -11,7 +11,7 @@
 #include <boost/safe_numbers/integer_utilities.hpp>
 #include <boost/safe_numbers/numeric.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 
 #include <cuda_runtime.h>
 
diff --git a/examples/cuda_error_handling.cu b/examples/cuda_error_handling.cu
index 2e9efff..c8aac30 100644
--- a/examples/cuda_error_handling.cu
+++ b/examples/cuda_error_handling.cu
@@ -16,7 +16,7 @@
 #include <iostream>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 
 #include <cuda_runtime.h>
 
@@ -51,7 +51,7 @@ int main()
     // Create a single device_error_context for the lifetime of the program.
     // The constructor allocates managed memory for error reporting and
     // clears any stale state.
-    boost::safe_numbers::device_error_context ctx;
+    boost::safe_numbers::device_error_context ctx(boost::safe_numbers::untrapped);
 
     // ---------------------------------------------------------------
     // Step 1: Launch a kernel that overflows and catch the error
diff --git a/include/boost/safe_numbers/detail/cuda_error_reporting.hpp b/include/boost/safe_numbers/cuda_error_reporting.hpp
similarity index 77%
rename from include/boost/safe_numbers/detail/cuda_error_reporting.hpp
rename to include/boost/safe_numbers/cuda_error_reporting.hpp
index 669fe36..a0ba083 100644
--- a/include/boost/safe_numbers/detail/cuda_error_reporting.hpp
+++ b/include/boost/safe_numbers/cuda_error_reporting.hpp
@@ -29,6 +29,15 @@
 
 namespace boost::safe_numbers {
 
+enum class device_exception_mode : unsigned
+{
+    trapped,
+    untrapped,
+};
+
+inline constexpr auto trapped = device_exception_mode::trapped;
+inline constexpr auto untrapped = device_exception_mode::untrapped;
+
 namespace detail {
 
 enum class exception_type : unsigned
@@ -91,6 +100,10 @@ BOOST_SAFE_NUMBERS_HOST_DEVICE inline void copy_to_buf(char* dst, const char* sr
 // Since we never destroy the CUDA context, __managed__ is safe to use.
 __managed__ cuda_device_error g_device_error {};
 
+// Managed memory enum class that allows us to set what report_device_error should do
+// We default to trapped as that's the best way to ensure hard failure in the event of error
+__managed__ device_exception_mode g_device_fail_type {device_exception_mode::trapped};
+
 // Tracks whether a device_error_context instance is alive.
 // Only one may exist at a time to prevent races on g_device_error.
 inline bool g_device_error_context_active = false;
@@ -112,13 +125,35 @@ __host__ __device__ inline void report_device_error(
         copy_to_buf(g_device_error.file, file, BOOST_SAFE_NUMBERS_DEVICE_ERROR_BUFFER_SIZE);
         copy_to_buf(g_device_error.expression, expression, BOOST_SAFE_NUMBERS_DEVICE_ERROR_BUFFER_SIZE);
         __threadfence_system();
+
+        if (g_device_fail_type == device_exception_mode::trapped)
+        {
+            __trap();
+        }
+    }
+
+    switch (g_device_fail_type)
+    {
+        case device_exception_mode::trapped:
+            // In the event that __trap() is called the error is non-recoverable
+            // The user must terminate the current PROCESS in order to reuse the device
+            // There is currently (3/26) way to recover using the cuda_runtime or hardware APIs
+            // Other threads: spin until the trap terminates the kernel
+            while (true)
+            {
+                __nanosleep(1000000);
+            }
+            break;
+
+        case device_exception_mode::untrapped:
+            // Return instead of calling __trap(). This allows the kernel to
+            // complete normally without corrupting the CUDA context. Other
+            // threads may continue with incorrect values, but synchronize()
+            // will detect the error via the flag and throw on the host.
+            return;
+            break;
     }
 
-    // Return instead of calling __trap(). This allows the kernel to
-    // complete normally without corrupting the CUDA context. Other
-    // threads may continue with incorrect values, but synchronize()
-    // will detect the error via the flag and throw on the host.
-    return;
     #else
 
     const auto msg = std::string(file) + ":" + std::to_string(line) + ": " + expression;
@@ -164,6 +199,21 @@ class device_error_context
         reset();
     }
 
+    // Sets a different error type to our managed global variable
+    device_error_context(const device_exception_mode e)
+    {
+        if (detail::g_device_error_context_active)
+        {
+            BOOST_THROW_EXCEPTION(std::logic_error(
+                "Only one device_error_context may exist at a time"));
+        }
+
+        detail::g_device_fail_type = e;
+
+        detail::g_device_error_context_active = true;
+        reset();
+    }
+
     ~device_error_context()
     {
         detail::g_device_error_context_active = false;
@@ -183,6 +233,12 @@ class device_error_context
         detail::g_device_error.expression[0] = '\0';
     }
 
+    // Adds a post-construction way of setting the failure mode for the device
+    void set_device_exception_method(const device_exception_mode e)
+    {
+        detail::g_device_fail_type = e;
+    }
+
     // Synchronizes the device and checks for errors captured by device code.
     // If an error was detected, the error state is cleared (so the context
     // is immediately reusable), and the appropriate std::exception is thrown.
diff --git a/include/boost/safe_numbers/detail/throw_exception.hpp b/include/boost/safe_numbers/detail/throw_exception.hpp
index 2ac1b48..e7e6de0 100644
--- a/include/boost/safe_numbers/detail/throw_exception.hpp
+++ b/include/boost/safe_numbers/detail/throw_exception.hpp
@@ -9,7 +9,7 @@
 #ifndef BOOST_SAFE_NUMBERS_THROW_EXCEPTION_HPP
 #define BOOST_SAFE_NUMBERS_THROW_EXCEPTION_HPP
 
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 
 #ifndef BOOST_SAFE_NUMBERS_BUILD_MODULE
 
diff --git a/test/cuda_jamfile b/test/cuda_jamfile
index 667f088..43241bc 100644
--- a/test/cuda_jamfile
+++ b/test/cuda_jamfile
@@ -9,6 +9,9 @@ project : requirements
     [ requires cxx20_hdr_bit cxx20_hdr_compare cxx20_hdr_concepts ]
     ;
 
+# Test the error handler mechanisms
+run test_cuda_error_handling.cu ;
+
 # u8 tests
 run test_cuda_u8_add.cu ;
 run test_cuda_u8_sub.cu ;
diff --git a/test/test_cuda_error_handling.cu b/test/test_cuda_error_handling.cu
new file mode 100644
index 0000000..5348609
--- /dev/null
+++ b/test/test_cuda_error_handling.cu
@@ -0,0 +1,59 @@
+// Copyright 2026 Matt Borland
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <iostream>
+#include <limits>
+#include <boost/safe_numbers/unsigned_integers.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
+
+#include <cuda_runtime.h>
+
+using test_type = boost::safe_numbers::u32;
+using basis_type = test_type::basis_type;
+
+// This kernel deliberately overflows: it adds 1 to the maximum u32 value
+__global__ void overflow_kernel(test_type* out)
+{
+    int i = blockDim.x * blockIdx.x + threadIdx.x;
+
+    if (i == 0)
+    {
+        const test_type max_val {(std::numeric_limits<basis_type>::max)()};
+        out[0] = max_val + test_type{1};  // Overflow!
+    }
+}
+
+int main()
+{
+    boost::safe_numbers::device_error_context ctx;
+
+    test_type* result = nullptr;
+    cudaMallocManaged(&result, sizeof(test_type));
+    cudaDeviceSynchronize();
+
+    std::cout << "=== Launching kernel that overflows ===" << std::endl;
+
+    overflow_kernel<<<1, 1>>>(result);
+
+    try
+    {
+        ctx.synchronize();
+        std::cout << "No error detected (unexpected)" << std::endl;
+    }
+    catch (const std::overflow_error& e)
+    {
+        std::cout << "Caught overflow_error: " << e.what() << std::endl;
+    }
+
+    // Since we have trapped, the context is now unrecoverable until the process terminates
+    const auto status = cudaDeviceSynchronize();
+    if (status != cudaSuccess)
+    {
+        return 0;
+    }
+    else
+    {
+        return 1;
+    }
+}
diff --git a/test/test_cuda_u128_abs_diff.cu b/test/test_cuda_u128_abs_diff.cu
index fb863d7..7605b63 100644
--- a/test/test_cuda_u128_abs_diff.cu
+++ b/test/test_cuda_u128_abs_diff.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_add.cu b/test/test_cuda_u128_add.cu
index 2a02c43..7baeb0b 100644
--- a/test/test_cuda_u128_add.cu
+++ b/test/test_cuda_u128_add.cu
@@ -12,7 +12,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_add_error.cu b/test/test_cuda_u128_add_error.cu
index a948903..4857ea9 100644
--- a/test/test_cuda_u128_add_error.cu
+++ b/test/test_cuda_u128_add_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u128_bit_ceil.cu b/test/test_cuda_u128_bit_ceil.cu
index 52ca8ec..b846323 100644
--- a/test/test_cuda_u128_bit_ceil.cu
+++ b/test/test_cuda_u128_bit_ceil.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_bit_floor.cu b/test/test_cuda_u128_bit_floor.cu
index b22b8ba..bdb4c9b 100644
--- a/test/test_cuda_u128_bit_floor.cu
+++ b/test/test_cuda_u128_bit_floor.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_bit_width.cu b/test/test_cuda_u128_bit_width.cu
index 99ede69..65ab0d7 100644
--- a/test/test_cuda_u128_bit_width.cu
+++ b/test/test_cuda_u128_bit_width.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_bitswap.cu b/test/test_cuda_u128_bitswap.cu
index 636d746..3a5e457 100644
--- a/test/test_cuda_u128_bitswap.cu
+++ b/test/test_cuda_u128_bitswap.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_byteswap.cu b/test/test_cuda_u128_byteswap.cu
index 8c449f8..94cafd7 100644
--- a/test/test_cuda_u128_byteswap.cu
+++ b/test/test_cuda_u128_byteswap.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_charconv.cu b/test/test_cuda_u128_charconv.cu
index 7a7e2b8..e9b15e2 100644
--- a/test/test_cuda_u128_charconv.cu
+++ b/test/test_cuda_u128_charconv.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_charconv_all_bases.cu b/test/test_cuda_u128_charconv_all_bases.cu
index 762ba5a..a9615b0 100644
--- a/test/test_cuda_u128_charconv_all_bases.cu
+++ b/test/test_cuda_u128_charconv_all_bases.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_countl_one.cu b/test/test_cuda_u128_countl_one.cu
index 06caaef..9642b51 100644
--- a/test/test_cuda_u128_countl_one.cu
+++ b/test/test_cuda_u128_countl_one.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_countl_zero.cu b/test/test_cuda_u128_countl_zero.cu
index 74cbfe6..a8c89d6 100644
--- a/test/test_cuda_u128_countl_zero.cu
+++ b/test/test_cuda_u128_countl_zero.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_countr_one.cu b/test/test_cuda_u128_countr_one.cu
index 8fa6fa7..43ff539 100644
--- a/test/test_cuda_u128_countr_one.cu
+++ b/test/test_cuda_u128_countr_one.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_countr_zero.cu b/test/test_cuda_u128_countr_zero.cu
index 1fd6114..9505062 100644
--- a/test/test_cuda_u128_countr_zero.cu
+++ b/test/test_cuda_u128_countr_zero.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_div.cu b/test/test_cuda_u128_div.cu
index 89a70c6..ffa36ab 100644
--- a/test/test_cuda_u128_div.cu
+++ b/test/test_cuda_u128_div.cu
@@ -12,7 +12,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_div_ceil.cu b/test/test_cuda_u128_div_ceil.cu
index a23045e..ac886c1 100644
--- a/test/test_cuda_u128_div_ceil.cu
+++ b/test/test_cuda_u128_div_ceil.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_div_error.cu b/test/test_cuda_u128_div_error.cu
index 27878e1..fa43fb3 100644
--- a/test/test_cuda_u128_div_error.cu
+++ b/test/test_cuda_u128_div_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u128_from_be.cu b/test/test_cuda_u128_from_be.cu
index 56476d9..11cd7d7 100644
--- a/test/test_cuda_u128_from_be.cu
+++ b/test/test_cuda_u128_from_be.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_from_le.cu b/test/test_cuda_u128_from_le.cu
index 4558a42..723918e 100644
--- a/test/test_cuda_u128_from_le.cu
+++ b/test/test_cuda_u128_from_le.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_gcd.cu b/test/test_cuda_u128_gcd.cu
index d39fb2d..65ef405 100644
--- a/test/test_cuda_u128_gcd.cu
+++ b/test/test_cuda_u128_gcd.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_has_single_bit.cu b/test/test_cuda_u128_has_single_bit.cu
index 775398f..4b8b145 100644
--- a/test/test_cuda_u128_has_single_bit.cu
+++ b/test/test_cuda_u128_has_single_bit.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_ilog.cu b/test/test_cuda_u128_ilog.cu
index 4b61aa3..d4771eb 100644
--- a/test/test_cuda_u128_ilog.cu
+++ b/test/test_cuda_u128_ilog.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_ilog10.cu b/test/test_cuda_u128_ilog10.cu
index 7c2f731..4f94e0e 100644
--- a/test/test_cuda_u128_ilog10.cu
+++ b/test/test_cuda_u128_ilog10.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_ilog2.cu b/test/test_cuda_u128_ilog2.cu
index 2764202..7787148 100644
--- a/test/test_cuda_u128_ilog2.cu
+++ b/test/test_cuda_u128_ilog2.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_ipow.cu b/test/test_cuda_u128_ipow.cu
index 4caada7..55d6596 100644
--- a/test/test_cuda_u128_ipow.cu
+++ b/test/test_cuda_u128_ipow.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_is_power_10.cu b/test/test_cuda_u128_is_power_10.cu
index 5d7048f..738aa95 100644
--- a/test/test_cuda_u128_is_power_10.cu
+++ b/test/test_cuda_u128_is_power_10.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_is_power_2.cu b/test/test_cuda_u128_is_power_2.cu
index 2775f07..69f4208 100644
--- a/test/test_cuda_u128_is_power_2.cu
+++ b/test/test_cuda_u128_is_power_2.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_isqrt.cu b/test/test_cuda_u128_isqrt.cu
index a54b27f..0a14a7a 100644
--- a/test/test_cuda_u128_isqrt.cu
+++ b/test/test_cuda_u128_isqrt.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_lcm.cu b/test/test_cuda_u128_lcm.cu
index ba04d7e..83410a6 100644
--- a/test/test_cuda_u128_lcm.cu
+++ b/test/test_cuda_u128_lcm.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_midpoint.cu b/test/test_cuda_u128_midpoint.cu
index 00ea8d2..055d8fd 100644
--- a/test/test_cuda_u128_midpoint.cu
+++ b/test/test_cuda_u128_midpoint.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_mod.cu b/test/test_cuda_u128_mod.cu
index b3f8fd2..607bd72 100644
--- a/test/test_cuda_u128_mod.cu
+++ b/test/test_cuda_u128_mod.cu
@@ -12,7 +12,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_mod_error.cu b/test/test_cuda_u128_mod_error.cu
index 87cef05..3617b09 100644
--- a/test/test_cuda_u128_mod_error.cu
+++ b/test/test_cuda_u128_mod_error.cu
@@ -6,7 +6,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u128_mul.cu b/test/test_cuda_u128_mul.cu
index f5a8af2..3b29f5f 100644
--- a/test/test_cuda_u128_mul.cu
+++ b/test/test_cuda_u128_mul.cu
@@ -12,7 +12,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_mul_error.cu b/test/test_cuda_u128_mul_error.cu
index b5b258f..be483eb 100644
--- a/test/test_cuda_u128_mul_error.cu
+++ b/test/test_cuda_u128_mul_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u128_next_multiple_of.cu b/test/test_cuda_u128_next_multiple_of.cu
index 313092a..c59ee19 100644
--- a/test/test_cuda_u128_next_multiple_of.cu
+++ b/test/test_cuda_u128_next_multiple_of.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_popcount.cu b/test/test_cuda_u128_popcount.cu
index ad62bd6..fc095d7 100644
--- a/test/test_cuda_u128_popcount.cu
+++ b/test/test_cuda_u128_popcount.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_remove_trailing_zeros.cu b/test/test_cuda_u128_remove_trailing_zeros.cu
index 5ef04b7..c155bac 100644
--- a/test/test_cuda_u128_remove_trailing_zeros.cu
+++ b/test/test_cuda_u128_remove_trailing_zeros.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_rotl.cu b/test/test_cuda_u128_rotl.cu
index 3b33dd7..90781ee 100644
--- a/test/test_cuda_u128_rotl.cu
+++ b/test/test_cuda_u128_rotl.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_rotr.cu b/test/test_cuda_u128_rotr.cu
index 6e259de..bb8d68c 100644
--- a/test/test_cuda_u128_rotr.cu
+++ b/test/test_cuda_u128_rotr.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_sub.cu b/test/test_cuda_u128_sub.cu
index cdfe939..a214c9a 100644
--- a/test/test_cuda_u128_sub.cu
+++ b/test/test_cuda_u128_sub.cu
@@ -13,7 +13,7 @@
 #include <algorithm>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_sub_error.cu b/test/test_cuda_u128_sub_error.cu
index e072f44..2cdada8 100644
--- a/test/test_cuda_u128_sub_error.cu
+++ b/test/test_cuda_u128_sub_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u128_to_be.cu b/test/test_cuda_u128_to_be.cu
index 0e1e6cf..9f45d24 100644
--- a/test/test_cuda_u128_to_be.cu
+++ b/test/test_cuda_u128_to_be.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u128_to_le.cu b/test/test_cuda_u128_to_le.cu
index 461d47d..2548a7b 100644
--- a/test/test_cuda_u128_to_le.cu
+++ b/test/test_cuda_u128_to_le.cu
@@ -13,7 +13,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include <boost/safe_numbers/detail/int128/random.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 #include "cuda_managed_ptr.hpp"
diff --git a/test/test_cuda_u16_abs_diff.cu b/test/test_cuda_u16_abs_diff.cu
index 830196a..a106567 100644
--- a/test/test_cuda_u16_abs_diff.cu
+++ b/test/test_cuda_u16_abs_diff.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_add.cu b/test/test_cuda_u16_add.cu
index ccb62b9..4ef66c9 100644
--- a/test/test_cuda_u16_add.cu
+++ b/test/test_cuda_u16_add.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_add_error.cu b/test/test_cuda_u16_add_error.cu
index 97aea30..b9e018a 100644
--- a/test/test_cuda_u16_add_error.cu
+++ b/test/test_cuda_u16_add_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u16_bit_ceil.cu b/test/test_cuda_u16_bit_ceil.cu
index a8ddfb7..063446b 100644
--- a/test/test_cuda_u16_bit_ceil.cu
+++ b/test/test_cuda_u16_bit_ceil.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_bit_floor.cu b/test/test_cuda_u16_bit_floor.cu
index ef63dbe..7c28294 100644
--- a/test/test_cuda_u16_bit_floor.cu
+++ b/test/test_cuda_u16_bit_floor.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_bit_width.cu b/test/test_cuda_u16_bit_width.cu
index 2085fc5..e5c2634 100644
--- a/test/test_cuda_u16_bit_width.cu
+++ b/test/test_cuda_u16_bit_width.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_bitswap.cu b/test/test_cuda_u16_bitswap.cu
index db46116..f61d4b8 100644
--- a/test/test_cuda_u16_bitswap.cu
+++ b/test/test_cuda_u16_bitswap.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_byteswap.cu b/test/test_cuda_u16_byteswap.cu
index a9fcb6d..6b0a89c 100644
--- a/test/test_cuda_u16_byteswap.cu
+++ b/test/test_cuda_u16_byteswap.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_charconv.cu b/test/test_cuda_u16_charconv.cu
index cd53a19..b503c6d 100644
--- a/test/test_cuda_u16_charconv.cu
+++ b/test/test_cuda_u16_charconv.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_charconv_all_bases.cu b/test/test_cuda_u16_charconv_all_bases.cu
index 50f64a7..72c5d9f 100644
--- a/test/test_cuda_u16_charconv_all_bases.cu
+++ b/test/test_cuda_u16_charconv_all_bases.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_countl_one.cu b/test/test_cuda_u16_countl_one.cu
index 1fcc61c..f951719 100644
--- a/test/test_cuda_u16_countl_one.cu
+++ b/test/test_cuda_u16_countl_one.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_countl_zero.cu b/test/test_cuda_u16_countl_zero.cu
index e78dc50..4879a07 100644
--- a/test/test_cuda_u16_countl_zero.cu
+++ b/test/test_cuda_u16_countl_zero.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_countr_one.cu b/test/test_cuda_u16_countr_one.cu
index f900927..4bfce26 100644
--- a/test/test_cuda_u16_countr_one.cu
+++ b/test/test_cuda_u16_countr_one.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_countr_zero.cu b/test/test_cuda_u16_countr_zero.cu
index 4feddc9..87d2089 100644
--- a/test/test_cuda_u16_countr_zero.cu
+++ b/test/test_cuda_u16_countr_zero.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_div.cu b/test/test_cuda_u16_div.cu
index b0bdbbb..ec677da 100644
--- a/test/test_cuda_u16_div.cu
+++ b/test/test_cuda_u16_div.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_div_ceil.cu b/test/test_cuda_u16_div_ceil.cu
index 52013ad..f0abefc 100644
--- a/test/test_cuda_u16_div_ceil.cu
+++ b/test/test_cuda_u16_div_ceil.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_div_error.cu b/test/test_cuda_u16_div_error.cu
index 0c18cbf..f3bf7a1 100644
--- a/test/test_cuda_u16_div_error.cu
+++ b/test/test_cuda_u16_div_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u16_from_be.cu b/test/test_cuda_u16_from_be.cu
index 1eda1cd..11ed7e3 100644
--- a/test/test_cuda_u16_from_be.cu
+++ b/test/test_cuda_u16_from_be.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_from_le.cu b/test/test_cuda_u16_from_le.cu
index 389a8fd..9058d38 100644
--- a/test/test_cuda_u16_from_le.cu
+++ b/test/test_cuda_u16_from_le.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_gcd.cu b/test/test_cuda_u16_gcd.cu
index 0bff419..7ee5987 100644
--- a/test/test_cuda_u16_gcd.cu
+++ b/test/test_cuda_u16_gcd.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_has_single_bit.cu b/test/test_cuda_u16_has_single_bit.cu
index 39bb369..83a7929 100644
--- a/test/test_cuda_u16_has_single_bit.cu
+++ b/test/test_cuda_u16_has_single_bit.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_ilog.cu b/test/test_cuda_u16_ilog.cu
index 39bf5de..94e336a 100644
--- a/test/test_cuda_u16_ilog.cu
+++ b/test/test_cuda_u16_ilog.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_ilog10.cu b/test/test_cuda_u16_ilog10.cu
index 3eff426..2421729 100644
--- a/test/test_cuda_u16_ilog10.cu
+++ b/test/test_cuda_u16_ilog10.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_ilog2.cu b/test/test_cuda_u16_ilog2.cu
index 23696c4..73ad788 100644
--- a/test/test_cuda_u16_ilog2.cu
+++ b/test/test_cuda_u16_ilog2.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_ipow.cu b/test/test_cuda_u16_ipow.cu
index a45070a..c5eea4e 100644
--- a/test/test_cuda_u16_ipow.cu
+++ b/test/test_cuda_u16_ipow.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_is_power_10.cu b/test/test_cuda_u16_is_power_10.cu
index 1d680da..e9bf609 100644
--- a/test/test_cuda_u16_is_power_10.cu
+++ b/test/test_cuda_u16_is_power_10.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_is_power_2.cu b/test/test_cuda_u16_is_power_2.cu
index e53ae2c..ccc59d9 100644
--- a/test/test_cuda_u16_is_power_2.cu
+++ b/test/test_cuda_u16_is_power_2.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_isqrt.cu b/test/test_cuda_u16_isqrt.cu
index 7f9708e..215374f 100644
--- a/test/test_cuda_u16_isqrt.cu
+++ b/test/test_cuda_u16_isqrt.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_lcm.cu b/test/test_cuda_u16_lcm.cu
index 2f2f420..2862c58 100644
--- a/test/test_cuda_u16_lcm.cu
+++ b/test/test_cuda_u16_lcm.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_midpoint.cu b/test/test_cuda_u16_midpoint.cu
index 136056b..acca756 100644
--- a/test/test_cuda_u16_midpoint.cu
+++ b/test/test_cuda_u16_midpoint.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_mod.cu b/test/test_cuda_u16_mod.cu
index 12b5785..489d47b 100644
--- a/test/test_cuda_u16_mod.cu
+++ b/test/test_cuda_u16_mod.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_mod_error.cu b/test/test_cuda_u16_mod_error.cu
index e4a322e..8361dec 100644
--- a/test/test_cuda_u16_mod_error.cu
+++ b/test/test_cuda_u16_mod_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u16_mul.cu b/test/test_cuda_u16_mul.cu
index a3ca55c..ed83522 100644
--- a/test/test_cuda_u16_mul.cu
+++ b/test/test_cuda_u16_mul.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_mul_error.cu b/test/test_cuda_u16_mul_error.cu
index 5ae78ed..735ca7c 100644
--- a/test/test_cuda_u16_mul_error.cu
+++ b/test/test_cuda_u16_mul_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u16_next_multiple_of.cu b/test/test_cuda_u16_next_multiple_of.cu
index f597589..7a0d182 100644
--- a/test/test_cuda_u16_next_multiple_of.cu
+++ b/test/test_cuda_u16_next_multiple_of.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_popcount.cu b/test/test_cuda_u16_popcount.cu
index b883bf3..a55aa9d 100644
--- a/test/test_cuda_u16_popcount.cu
+++ b/test/test_cuda_u16_popcount.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_remove_trailing_zeros.cu b/test/test_cuda_u16_remove_trailing_zeros.cu
index 85559e2..db9afee 100644
--- a/test/test_cuda_u16_remove_trailing_zeros.cu
+++ b/test/test_cuda_u16_remove_trailing_zeros.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_rotl.cu b/test/test_cuda_u16_rotl.cu
index 94f331a..3196b99 100644
--- a/test/test_cuda_u16_rotl.cu
+++ b/test/test_cuda_u16_rotl.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_rotr.cu b/test/test_cuda_u16_rotr.cu
index eeda3d0..94008f5 100644
--- a/test/test_cuda_u16_rotr.cu
+++ b/test/test_cuda_u16_rotr.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_sub.cu b/test/test_cuda_u16_sub.cu
index 9cae107..d3aeffa 100644
--- a/test/test_cuda_u16_sub.cu
+++ b/test/test_cuda_u16_sub.cu
@@ -10,7 +10,7 @@
 #include <algorithm>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_sub_error.cu b/test/test_cuda_u16_sub_error.cu
index 4aa68b6..e86155c 100644
--- a/test/test_cuda_u16_sub_error.cu
+++ b/test/test_cuda_u16_sub_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u16_to_be.cu b/test/test_cuda_u16_to_be.cu
index 9268e37..e7c7b3a 100644
--- a/test/test_cuda_u16_to_be.cu
+++ b/test/test_cuda_u16_to_be.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u16_to_le.cu b/test/test_cuda_u16_to_le.cu
index 7b0ce48..7f4e004 100644
--- a/test/test_cuda_u16_to_le.cu
+++ b/test/test_cuda_u16_to_le.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_abs_diff.cu b/test/test_cuda_u32_abs_diff.cu
index 213bfe8..2ffa845 100644
--- a/test/test_cuda_u32_abs_diff.cu
+++ b/test/test_cuda_u32_abs_diff.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_add.cu b/test/test_cuda_u32_add.cu
index 79b1d5f..c6ea297 100644
--- a/test/test_cuda_u32_add.cu
+++ b/test/test_cuda_u32_add.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_add_error.cu b/test/test_cuda_u32_add_error.cu
index 93622c4..2dd6ec4 100644
--- a/test/test_cuda_u32_add_error.cu
+++ b/test/test_cuda_u32_add_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u32_bit_ceil.cu b/test/test_cuda_u32_bit_ceil.cu
index f1b130a..396ec43 100644
--- a/test/test_cuda_u32_bit_ceil.cu
+++ b/test/test_cuda_u32_bit_ceil.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_bit_floor.cu b/test/test_cuda_u32_bit_floor.cu
index 987c4ba..bb9c3e7 100644
--- a/test/test_cuda_u32_bit_floor.cu
+++ b/test/test_cuda_u32_bit_floor.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_bit_width.cu b/test/test_cuda_u32_bit_width.cu
index 4ea5784..0ef8388 100644
--- a/test/test_cuda_u32_bit_width.cu
+++ b/test/test_cuda_u32_bit_width.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_bitswap.cu b/test/test_cuda_u32_bitswap.cu
index 2c8c5b2..3719071 100644
--- a/test/test_cuda_u32_bitswap.cu
+++ b/test/test_cuda_u32_bitswap.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_byteswap.cu b/test/test_cuda_u32_byteswap.cu
index 300e1d9..002fe5e 100644
--- a/test/test_cuda_u32_byteswap.cu
+++ b/test/test_cuda_u32_byteswap.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_charconv.cu b/test/test_cuda_u32_charconv.cu
index b618742..92084f5 100644
--- a/test/test_cuda_u32_charconv.cu
+++ b/test/test_cuda_u32_charconv.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_charconv_all_bases.cu b/test/test_cuda_u32_charconv_all_bases.cu
index 70c43e7..3f04477 100644
--- a/test/test_cuda_u32_charconv_all_bases.cu
+++ b/test/test_cuda_u32_charconv_all_bases.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_countl_one.cu b/test/test_cuda_u32_countl_one.cu
index b5d40e5..6927f21 100644
--- a/test/test_cuda_u32_countl_one.cu
+++ b/test/test_cuda_u32_countl_one.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_countl_zero.cu b/test/test_cuda_u32_countl_zero.cu
index f5b4284..474097c 100644
--- a/test/test_cuda_u32_countl_zero.cu
+++ b/test/test_cuda_u32_countl_zero.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_countr_one.cu b/test/test_cuda_u32_countr_one.cu
index 3e687cb..01c6b8f 100644
--- a/test/test_cuda_u32_countr_one.cu
+++ b/test/test_cuda_u32_countr_one.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_countr_zero.cu b/test/test_cuda_u32_countr_zero.cu
index 99028ef..c1cd361 100644
--- a/test/test_cuda_u32_countr_zero.cu
+++ b/test/test_cuda_u32_countr_zero.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_div.cu b/test/test_cuda_u32_div.cu
index d811570..92c7914 100644
--- a/test/test_cuda_u32_div.cu
+++ b/test/test_cuda_u32_div.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_div_ceil.cu b/test/test_cuda_u32_div_ceil.cu
index 83def48..9cad1a5 100644
--- a/test/test_cuda_u32_div_ceil.cu
+++ b/test/test_cuda_u32_div_ceil.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_div_error.cu b/test/test_cuda_u32_div_error.cu
index 23b65aa..423c610 100644
--- a/test/test_cuda_u32_div_error.cu
+++ b/test/test_cuda_u32_div_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u32_from_be.cu b/test/test_cuda_u32_from_be.cu
index 409cdda..a57e033 100644
--- a/test/test_cuda_u32_from_be.cu
+++ b/test/test_cuda_u32_from_be.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_from_le.cu b/test/test_cuda_u32_from_le.cu
index 358f4f4..eb3a1f6 100644
--- a/test/test_cuda_u32_from_le.cu
+++ b/test/test_cuda_u32_from_le.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_gcd.cu b/test/test_cuda_u32_gcd.cu
index 0ca6178..3f1557f 100644
--- a/test/test_cuda_u32_gcd.cu
+++ b/test/test_cuda_u32_gcd.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_has_single_bit.cu b/test/test_cuda_u32_has_single_bit.cu
index 308d0a6..25b5456 100644
--- a/test/test_cuda_u32_has_single_bit.cu
+++ b/test/test_cuda_u32_has_single_bit.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_ilog.cu b/test/test_cuda_u32_ilog.cu
index b98cd7b..d4d687a 100644
--- a/test/test_cuda_u32_ilog.cu
+++ b/test/test_cuda_u32_ilog.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_ilog10.cu b/test/test_cuda_u32_ilog10.cu
index 9302d56..4d4c865 100644
--- a/test/test_cuda_u32_ilog10.cu
+++ b/test/test_cuda_u32_ilog10.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_ilog2.cu b/test/test_cuda_u32_ilog2.cu
index 85b2e9d..1732664 100644
--- a/test/test_cuda_u32_ilog2.cu
+++ b/test/test_cuda_u32_ilog2.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_ipow.cu b/test/test_cuda_u32_ipow.cu
index e8c1f1d..1e41197 100644
--- a/test/test_cuda_u32_ipow.cu
+++ b/test/test_cuda_u32_ipow.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_is_power_10.cu b/test/test_cuda_u32_is_power_10.cu
index 3d8b03c..1fd4d0f 100644
--- a/test/test_cuda_u32_is_power_10.cu
+++ b/test/test_cuda_u32_is_power_10.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_is_power_2.cu b/test/test_cuda_u32_is_power_2.cu
index 381e674..6ac5b2d 100644
--- a/test/test_cuda_u32_is_power_2.cu
+++ b/test/test_cuda_u32_is_power_2.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_isqrt.cu b/test/test_cuda_u32_isqrt.cu
index a6fcb8c..3b87830 100644
--- a/test/test_cuda_u32_isqrt.cu
+++ b/test/test_cuda_u32_isqrt.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_lcm.cu b/test/test_cuda_u32_lcm.cu
index 09019b9..bd77d96 100644
--- a/test/test_cuda_u32_lcm.cu
+++ b/test/test_cuda_u32_lcm.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_midpoint.cu b/test/test_cuda_u32_midpoint.cu
index aadfcac..47901a4 100644
--- a/test/test_cuda_u32_midpoint.cu
+++ b/test/test_cuda_u32_midpoint.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_mod.cu b/test/test_cuda_u32_mod.cu
index 42af4d8..bc3f447 100644
--- a/test/test_cuda_u32_mod.cu
+++ b/test/test_cuda_u32_mod.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_mod_error.cu b/test/test_cuda_u32_mod_error.cu
index c2e55ef..9ebaa0c 100644
--- a/test/test_cuda_u32_mod_error.cu
+++ b/test/test_cuda_u32_mod_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u32_mul.cu b/test/test_cuda_u32_mul.cu
index df47867..2947ac5 100644
--- a/test/test_cuda_u32_mul.cu
+++ b/test/test_cuda_u32_mul.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_mul_error.cu b/test/test_cuda_u32_mul_error.cu
index 17fece8..58a4596 100644
--- a/test/test_cuda_u32_mul_error.cu
+++ b/test/test_cuda_u32_mul_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u32_next_multiple_of.cu b/test/test_cuda_u32_next_multiple_of.cu
index 3371948..fa16fd1 100644
--- a/test/test_cuda_u32_next_multiple_of.cu
+++ b/test/test_cuda_u32_next_multiple_of.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_popcount.cu b/test/test_cuda_u32_popcount.cu
index 1b2678c..a9eed9c 100644
--- a/test/test_cuda_u32_popcount.cu
+++ b/test/test_cuda_u32_popcount.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_remove_trailing_zeros.cu b/test/test_cuda_u32_remove_trailing_zeros.cu
index 1e8c9e4..3b52b97 100644
--- a/test/test_cuda_u32_remove_trailing_zeros.cu
+++ b/test/test_cuda_u32_remove_trailing_zeros.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_rotl.cu b/test/test_cuda_u32_rotl.cu
index ed06774..aada247 100644
--- a/test/test_cuda_u32_rotl.cu
+++ b/test/test_cuda_u32_rotl.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_rotr.cu b/test/test_cuda_u32_rotr.cu
index 9b6b7a2..a38c382 100644
--- a/test/test_cuda_u32_rotr.cu
+++ b/test/test_cuda_u32_rotr.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_sub.cu b/test/test_cuda_u32_sub.cu
index 1c8046e..d5d4b6e 100644
--- a/test/test_cuda_u32_sub.cu
+++ b/test/test_cuda_u32_sub.cu
@@ -10,7 +10,7 @@
 #include <algorithm>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_sub_error.cu b/test/test_cuda_u32_sub_error.cu
index 9e06143..40f4c0b 100644
--- a/test/test_cuda_u32_sub_error.cu
+++ b/test/test_cuda_u32_sub_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u32_to_be.cu b/test/test_cuda_u32_to_be.cu
index abf22d7..16b7861 100644
--- a/test/test_cuda_u32_to_be.cu
+++ b/test/test_cuda_u32_to_be.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u32_to_le.cu b/test/test_cuda_u32_to_le.cu
index 2d31f30..b685cde 100644
--- a/test/test_cuda_u32_to_le.cu
+++ b/test/test_cuda_u32_to_le.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_abs_diff.cu b/test/test_cuda_u64_abs_diff.cu
index 038f420..1fb8658 100644
--- a/test/test_cuda_u64_abs_diff.cu
+++ b/test/test_cuda_u64_abs_diff.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_add.cu b/test/test_cuda_u64_add.cu
index 4a8ff14..7cd2ebe 100644
--- a/test/test_cuda_u64_add.cu
+++ b/test/test_cuda_u64_add.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_add_error.cu b/test/test_cuda_u64_add_error.cu
index 43a7a92..45afb1b 100644
--- a/test/test_cuda_u64_add_error.cu
+++ b/test/test_cuda_u64_add_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u64_bit_ceil.cu b/test/test_cuda_u64_bit_ceil.cu
index 885f44c..6b546f6 100644
--- a/test/test_cuda_u64_bit_ceil.cu
+++ b/test/test_cuda_u64_bit_ceil.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_bit_floor.cu b/test/test_cuda_u64_bit_floor.cu
index 18b61b0..c5c5344 100644
--- a/test/test_cuda_u64_bit_floor.cu
+++ b/test/test_cuda_u64_bit_floor.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_bit_width.cu b/test/test_cuda_u64_bit_width.cu
index ec04975..333df34 100644
--- a/test/test_cuda_u64_bit_width.cu
+++ b/test/test_cuda_u64_bit_width.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_bitswap.cu b/test/test_cuda_u64_bitswap.cu
index ca98035..22860ae 100644
--- a/test/test_cuda_u64_bitswap.cu
+++ b/test/test_cuda_u64_bitswap.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_byteswap.cu b/test/test_cuda_u64_byteswap.cu
index e07beb1..88b81e2 100644
--- a/test/test_cuda_u64_byteswap.cu
+++ b/test/test_cuda_u64_byteswap.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_charconv.cu b/test/test_cuda_u64_charconv.cu
index 75998ff..b20ff71 100644
--- a/test/test_cuda_u64_charconv.cu
+++ b/test/test_cuda_u64_charconv.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_charconv_all_bases.cu b/test/test_cuda_u64_charconv_all_bases.cu
index 5de01ea..b05fadc 100644
--- a/test/test_cuda_u64_charconv_all_bases.cu
+++ b/test/test_cuda_u64_charconv_all_bases.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_countl_one.cu b/test/test_cuda_u64_countl_one.cu
index 4f52634..2fa797c 100644
--- a/test/test_cuda_u64_countl_one.cu
+++ b/test/test_cuda_u64_countl_one.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_countl_zero.cu b/test/test_cuda_u64_countl_zero.cu
index 81d3d67..f5ee174 100644
--- a/test/test_cuda_u64_countl_zero.cu
+++ b/test/test_cuda_u64_countl_zero.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_countr_one.cu b/test/test_cuda_u64_countr_one.cu
index de86742..b6f2dd1 100644
--- a/test/test_cuda_u64_countr_one.cu
+++ b/test/test_cuda_u64_countr_one.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_countr_zero.cu b/test/test_cuda_u64_countr_zero.cu
index c348275..de18f07 100644
--- a/test/test_cuda_u64_countr_zero.cu
+++ b/test/test_cuda_u64_countr_zero.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_div.cu b/test/test_cuda_u64_div.cu
index 2c74de1..ad4adc6 100644
--- a/test/test_cuda_u64_div.cu
+++ b/test/test_cuda_u64_div.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_div_ceil.cu b/test/test_cuda_u64_div_ceil.cu
index 4bd8b1b..69facdf 100644
--- a/test/test_cuda_u64_div_ceil.cu
+++ b/test/test_cuda_u64_div_ceil.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_div_error.cu b/test/test_cuda_u64_div_error.cu
index 03b62a6..27f8697 100644
--- a/test/test_cuda_u64_div_error.cu
+++ b/test/test_cuda_u64_div_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u64_from_be.cu b/test/test_cuda_u64_from_be.cu
index e867176..becb752 100644
--- a/test/test_cuda_u64_from_be.cu
+++ b/test/test_cuda_u64_from_be.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_from_le.cu b/test/test_cuda_u64_from_le.cu
index 29e4024..96846e0 100644
--- a/test/test_cuda_u64_from_le.cu
+++ b/test/test_cuda_u64_from_le.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_gcd.cu b/test/test_cuda_u64_gcd.cu
index 6d0dc83..14b93ee 100644
--- a/test/test_cuda_u64_gcd.cu
+++ b/test/test_cuda_u64_gcd.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_has_single_bit.cu b/test/test_cuda_u64_has_single_bit.cu
index 76012cd..febd906 100644
--- a/test/test_cuda_u64_has_single_bit.cu
+++ b/test/test_cuda_u64_has_single_bit.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_ilog.cu b/test/test_cuda_u64_ilog.cu
index 430ae89..8aec005 100644
--- a/test/test_cuda_u64_ilog.cu
+++ b/test/test_cuda_u64_ilog.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_ilog10.cu b/test/test_cuda_u64_ilog10.cu
index 2c67863..c26fb8d 100644
--- a/test/test_cuda_u64_ilog10.cu
+++ b/test/test_cuda_u64_ilog10.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_ilog2.cu b/test/test_cuda_u64_ilog2.cu
index 375c119..111a156 100644
--- a/test/test_cuda_u64_ilog2.cu
+++ b/test/test_cuda_u64_ilog2.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_ipow.cu b/test/test_cuda_u64_ipow.cu
index be09471..40182ad 100644
--- a/test/test_cuda_u64_ipow.cu
+++ b/test/test_cuda_u64_ipow.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_is_power_10.cu b/test/test_cuda_u64_is_power_10.cu
index 0f2fb55..09e883e 100644
--- a/test/test_cuda_u64_is_power_10.cu
+++ b/test/test_cuda_u64_is_power_10.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_is_power_2.cu b/test/test_cuda_u64_is_power_2.cu
index c823c6f..d637dfa 100644
--- a/test/test_cuda_u64_is_power_2.cu
+++ b/test/test_cuda_u64_is_power_2.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_isqrt.cu b/test/test_cuda_u64_isqrt.cu
index ba5a5ae..03d3281 100644
--- a/test/test_cuda_u64_isqrt.cu
+++ b/test/test_cuda_u64_isqrt.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_lcm.cu b/test/test_cuda_u64_lcm.cu
index 24dce83..a9b8902 100644
--- a/test/test_cuda_u64_lcm.cu
+++ b/test/test_cuda_u64_lcm.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_midpoint.cu b/test/test_cuda_u64_midpoint.cu
index bba9451..5b98709 100644
--- a/test/test_cuda_u64_midpoint.cu
+++ b/test/test_cuda_u64_midpoint.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_mod.cu b/test/test_cuda_u64_mod.cu
index 32d4e0d..5f937a5 100644
--- a/test/test_cuda_u64_mod.cu
+++ b/test/test_cuda_u64_mod.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_mod_error.cu b/test/test_cuda_u64_mod_error.cu
index 32fd1a9..2f877f9 100644
--- a/test/test_cuda_u64_mod_error.cu
+++ b/test/test_cuda_u64_mod_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u64_mul.cu b/test/test_cuda_u64_mul.cu
index d8e924d..6a7c86d 100644
--- a/test/test_cuda_u64_mul.cu
+++ b/test/test_cuda_u64_mul.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_mul_error.cu b/test/test_cuda_u64_mul_error.cu
index e7ef0a3..aee86b4 100644
--- a/test/test_cuda_u64_mul_error.cu
+++ b/test/test_cuda_u64_mul_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u64_next_multiple_of.cu b/test/test_cuda_u64_next_multiple_of.cu
index fd6f1a7..b18eadc 100644
--- a/test/test_cuda_u64_next_multiple_of.cu
+++ b/test/test_cuda_u64_next_multiple_of.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_popcount.cu b/test/test_cuda_u64_popcount.cu
index e48df1d..a9d883b 100644
--- a/test/test_cuda_u64_popcount.cu
+++ b/test/test_cuda_u64_popcount.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_remove_trailing_zeros.cu b/test/test_cuda_u64_remove_trailing_zeros.cu
index 0a58876..3ca4ffd 100644
--- a/test/test_cuda_u64_remove_trailing_zeros.cu
+++ b/test/test_cuda_u64_remove_trailing_zeros.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_rotl.cu b/test/test_cuda_u64_rotl.cu
index a3240b1..ac84552 100644
--- a/test/test_cuda_u64_rotl.cu
+++ b/test/test_cuda_u64_rotl.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_rotr.cu b/test/test_cuda_u64_rotr.cu
index 3cf95de..017cb12 100644
--- a/test/test_cuda_u64_rotr.cu
+++ b/test/test_cuda_u64_rotr.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_sub.cu b/test/test_cuda_u64_sub.cu
index 6974030..5e235a1 100644
--- a/test/test_cuda_u64_sub.cu
+++ b/test/test_cuda_u64_sub.cu
@@ -10,7 +10,7 @@
 #include <algorithm>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_sub_error.cu b/test/test_cuda_u64_sub_error.cu
index bfb57ec..fc69b82 100644
--- a/test/test_cuda_u64_sub_error.cu
+++ b/test/test_cuda_u64_sub_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u64_to_be.cu b/test/test_cuda_u64_to_be.cu
index 01613a0..47bed5b 100644
--- a/test/test_cuda_u64_to_be.cu
+++ b/test/test_cuda_u64_to_be.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u64_to_le.cu b/test/test_cuda_u64_to_le.cu
index 80ce98a..d5757d1 100644
--- a/test/test_cuda_u64_to_le.cu
+++ b/test/test_cuda_u64_to_le.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_abs_diff.cu b/test/test_cuda_u8_abs_diff.cu
index 3d0e736..2ae8bfc 100644
--- a/test/test_cuda_u8_abs_diff.cu
+++ b/test/test_cuda_u8_abs_diff.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_add.cu b/test/test_cuda_u8_add.cu
index e047c52..77df882 100644
--- a/test/test_cuda_u8_add.cu
+++ b/test/test_cuda_u8_add.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_add_error.cu b/test/test_cuda_u8_add_error.cu
index 6de15f5..9fb4a6b 100644
--- a/test/test_cuda_u8_add_error.cu
+++ b/test/test_cuda_u8_add_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u8_bit_ceil.cu b/test/test_cuda_u8_bit_ceil.cu
index f84d37d..0eaeb22 100644
--- a/test/test_cuda_u8_bit_ceil.cu
+++ b/test/test_cuda_u8_bit_ceil.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_bit_floor.cu b/test/test_cuda_u8_bit_floor.cu
index 5ef0598..c3d4c0c 100644
--- a/test/test_cuda_u8_bit_floor.cu
+++ b/test/test_cuda_u8_bit_floor.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_bit_width.cu b/test/test_cuda_u8_bit_width.cu
index 3ae3bbc..4edc3ca 100644
--- a/test/test_cuda_u8_bit_width.cu
+++ b/test/test_cuda_u8_bit_width.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_bitswap.cu b/test/test_cuda_u8_bitswap.cu
index d2d0d56..726a52d 100644
--- a/test/test_cuda_u8_bitswap.cu
+++ b/test/test_cuda_u8_bitswap.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_byteswap.cu b/test/test_cuda_u8_byteswap.cu
index 9a6e4d5..59921b9 100644
--- a/test/test_cuda_u8_byteswap.cu
+++ b/test/test_cuda_u8_byteswap.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_charconv.cu b/test/test_cuda_u8_charconv.cu
index daaed8c..b1756d0 100644
--- a/test/test_cuda_u8_charconv.cu
+++ b/test/test_cuda_u8_charconv.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_charconv_all_bases.cu b/test/test_cuda_u8_charconv_all_bases.cu
index 481caf1..9a08503 100644
--- a/test/test_cuda_u8_charconv_all_bases.cu
+++ b/test/test_cuda_u8_charconv_all_bases.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/charconv.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_countl_one.cu b/test/test_cuda_u8_countl_one.cu
index b5b89fe..0a535ba 100644
--- a/test/test_cuda_u8_countl_one.cu
+++ b/test/test_cuda_u8_countl_one.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_countl_zero.cu b/test/test_cuda_u8_countl_zero.cu
index 68ba382..6643b7b 100644
--- a/test/test_cuda_u8_countl_zero.cu
+++ b/test/test_cuda_u8_countl_zero.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_countr_one.cu b/test/test_cuda_u8_countr_one.cu
index 4466c8c..73a7e5b 100644
--- a/test/test_cuda_u8_countr_one.cu
+++ b/test/test_cuda_u8_countr_one.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_countr_zero.cu b/test/test_cuda_u8_countr_zero.cu
index 9902dd0..e722b4c 100644
--- a/test/test_cuda_u8_countr_zero.cu
+++ b/test/test_cuda_u8_countr_zero.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_div.cu b/test/test_cuda_u8_div.cu
index 1e81aa4..9bfd9b5 100644
--- a/test/test_cuda_u8_div.cu
+++ b/test/test_cuda_u8_div.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_div_ceil.cu b/test/test_cuda_u8_div_ceil.cu
index 9a4d4f2..f2f8cbb 100644
--- a/test/test_cuda_u8_div_ceil.cu
+++ b/test/test_cuda_u8_div_ceil.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_div_error.cu b/test/test_cuda_u8_div_error.cu
index 13a8cad..5cddd3b 100644
--- a/test/test_cuda_u8_div_error.cu
+++ b/test/test_cuda_u8_div_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u8_from_be.cu b/test/test_cuda_u8_from_be.cu
index b914fdd..9e0e941 100644
--- a/test/test_cuda_u8_from_be.cu
+++ b/test/test_cuda_u8_from_be.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_from_le.cu b/test/test_cuda_u8_from_le.cu
index 4f669cc..7676cb9 100644
--- a/test/test_cuda_u8_from_le.cu
+++ b/test/test_cuda_u8_from_le.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_gcd.cu b/test/test_cuda_u8_gcd.cu
index 3ab02ee..3c9e888 100644
--- a/test/test_cuda_u8_gcd.cu
+++ b/test/test_cuda_u8_gcd.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_has_single_bit.cu b/test/test_cuda_u8_has_single_bit.cu
index 4c30350..f716108 100644
--- a/test/test_cuda_u8_has_single_bit.cu
+++ b/test/test_cuda_u8_has_single_bit.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_ilog.cu b/test/test_cuda_u8_ilog.cu
index 8fcdce1..c47ce6b 100644
--- a/test/test_cuda_u8_ilog.cu
+++ b/test/test_cuda_u8_ilog.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_ilog10.cu b/test/test_cuda_u8_ilog10.cu
index 3bde939..47b296a 100644
--- a/test/test_cuda_u8_ilog10.cu
+++ b/test/test_cuda_u8_ilog10.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_ilog2.cu b/test/test_cuda_u8_ilog2.cu
index adf4094..49926f9 100644
--- a/test/test_cuda_u8_ilog2.cu
+++ b/test/test_cuda_u8_ilog2.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_ipow.cu b/test/test_cuda_u8_ipow.cu
index ca643a8..be222da 100644
--- a/test/test_cuda_u8_ipow.cu
+++ b/test/test_cuda_u8_ipow.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_is_power_10.cu b/test/test_cuda_u8_is_power_10.cu
index 7cee6aa..84ea12b 100644
--- a/test/test_cuda_u8_is_power_10.cu
+++ b/test/test_cuda_u8_is_power_10.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_is_power_2.cu b/test/test_cuda_u8_is_power_2.cu
index 4405f2d..a4551ed 100644
--- a/test/test_cuda_u8_is_power_2.cu
+++ b/test/test_cuda_u8_is_power_2.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_isqrt.cu b/test/test_cuda_u8_isqrt.cu
index 3c68a88..cc39059 100644
--- a/test/test_cuda_u8_isqrt.cu
+++ b/test/test_cuda_u8_isqrt.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_lcm.cu b/test/test_cuda_u8_lcm.cu
index 636263b..1b895c1 100644
--- a/test/test_cuda_u8_lcm.cu
+++ b/test/test_cuda_u8_lcm.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_midpoint.cu b/test/test_cuda_u8_midpoint.cu
index 37e2a76..b4521b3 100644
--- a/test/test_cuda_u8_midpoint.cu
+++ b/test/test_cuda_u8_midpoint.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/numeric.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_mod.cu b/test/test_cuda_u8_mod.cu
index 4d43a1f..55f11b6 100644
--- a/test/test_cuda_u8_mod.cu
+++ b/test/test_cuda_u8_mod.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_mod_error.cu b/test/test_cuda_u8_mod_error.cu
index 255eb7a..bc9d668 100644
--- a/test/test_cuda_u8_mod_error.cu
+++ b/test/test_cuda_u8_mod_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u8_mul.cu b/test/test_cuda_u8_mul.cu
index 4a1ed12..8ae9cc4 100644
--- a/test/test_cuda_u8_mul.cu
+++ b/test/test_cuda_u8_mul.cu
@@ -9,7 +9,7 @@
 #include <random>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_mul_error.cu b/test/test_cuda_u8_mul_error.cu
index c8fde2c..79101bc 100644
--- a/test/test_cuda_u8_mul_error.cu
+++ b/test/test_cuda_u8_mul_error.cu
@@ -9,7 +9,7 @@
 #include <stdexcept>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u8_next_multiple_of.cu b/test/test_cuda_u8_next_multiple_of.cu
index d5a95d3..b676786 100644
--- a/test/test_cuda_u8_next_multiple_of.cu
+++ b/test/test_cuda_u8_next_multiple_of.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_popcount.cu b/test/test_cuda_u8_popcount.cu
index cd27d91..6c5ba4f 100644
--- a/test/test_cuda_u8_popcount.cu
+++ b/test/test_cuda_u8_popcount.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_remove_trailing_zeros.cu b/test/test_cuda_u8_remove_trailing_zeros.cu
index f115383..7b4b9f2 100644
--- a/test/test_cuda_u8_remove_trailing_zeros.cu
+++ b/test/test_cuda_u8_remove_trailing_zeros.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/integer_utilities.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_rotl.cu b/test/test_cuda_u8_rotl.cu
index a45e622..28e06a4 100644
--- a/test/test_cuda_u8_rotl.cu
+++ b/test/test_cuda_u8_rotl.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_rotr.cu b/test/test_cuda_u8_rotr.cu
index 47cfd9e..b50db99 100644
--- a/test/test_cuda_u8_rotr.cu
+++ b/test/test_cuda_u8_rotr.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/bit.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_sub.cu b/test/test_cuda_u8_sub.cu
index f48d115..4036564 100644
--- a/test/test_cuda_u8_sub.cu
+++ b/test/test_cuda_u8_sub.cu
@@ -10,7 +10,7 @@
 #include <algorithm>
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_sub_error.cu b/test/test_cuda_u8_sub_error.cu
index dc2c1ff..045f91b 100644
--- a/test/test_cuda_u8_sub_error.cu
+++ b/test/test_cuda_u8_sub_error.cu
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <boost/safe_numbers/unsigned_integers.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 
 #include <cuda_runtime.h>
diff --git a/test/test_cuda_u8_to_be.cu b/test/test_cuda_u8_to_be.cu
index ae5801c..7b184c9 100644
--- a/test/test_cuda_u8_to_be.cu
+++ b/test/test_cuda_u8_to_be.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"
 
diff --git a/test/test_cuda_u8_to_le.cu b/test/test_cuda_u8_to_le.cu
index d51dd61..2de11d0 100644
--- a/test/test_cuda_u8_to_le.cu
+++ b/test/test_cuda_u8_to_le.cu
@@ -10,7 +10,7 @@
 #include <limits>
 #include <boost/safe_numbers/unsigned_integers.hpp>
 #include <boost/safe_numbers/byte_conversions.hpp>
-#include <boost/safe_numbers/detail/cuda_error_reporting.hpp>
+#include <boost/safe_numbers/cuda_error_reporting.hpp>
 #include "cuda_managed_ptr.hpp"
 #include "stopwatch.hpp"