diff --git a/.drone.star b/.drone.star
index 7b773dda7d..6b9ee76629 100644
--- a/.drone.star
+++ b/.drone.star
@@ -32,10 +32,10 @@ def main(ctx):
     #
     # Sanitizers:
     #
-    result.append(linux_cxx("Ubuntu g++-10 C++2a ASAN" + " " + suite, "g++-10", packages="g++-10", privileged=True, buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++2a', 'TEST_SUITE': suite, 'OPTIONS': '<cxxflags>-fsanitize=address <linkflags>-fsanitize=address <cxxflags>-DBOOST_CI_SANITIZER_BUILD' }, globalenv=globalenv))
-    result.append(linux_cxx("Ubuntu g++-10 C++2a USAN" + " " + suite, "g++-10", packages="g++-10", privileged=True, buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++2a', 'TEST_SUITE': suite, 'OPTIONS': '<cxxflags>-fsanitize=undefined <linkflags>-fsanitize=undefined <cxxflags>-DBOOST_CI_SANITIZER_BUILD' }, globalenv=globalenv))
-    result.append(linux_cxx("Ubuntu g++-10 C++2a TSAN" + " " + suite, "g++-10", packages="g++-10", privileged=True, buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++2a', 'TEST_SUITE': suite, 'OPTIONS': '<cxxflags>-fsanitize=thread <linkflags>-fsanitize=thread <cxxflags>-DBOOST_CI_SANITIZER_BUILD' }, globalenv=globalenv))
-    result.append(linux_cxx("Ubuntu clang++-10 C++2a ISAN" + " " + suite, "clang++-10", packages="clang-10", privileged=True, buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'gnu++2a', 'TEST_SUITE': suite, 'OPTIONS': '<cxxflags>-fsanitize=integer <linkflags>-fsanitize=integer' }, globalenv=globalenv))
+    result.append(linux_cxx("Ubuntu g++-12 C++20 ASAN" + " " + suite, "g++-12", packages="g++-12", privileged=True, buildtype="boost", image="cppalliance/droneubuntu2204:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-12', 'CXXSTD': 'gnu++20', 'TEST_SUITE': suite, 'OPTIONS': '<cxxflags>-fsanitize=address <linkflags>-fsanitize=address <cxxflags>-DBOOST_CI_SANITIZER_BUILD' }, globalenv=globalenv))
+    result.append(linux_cxx("Ubuntu g++-12 C++20 USAN" + " " + suite, "g++-12", packages="g++-12", privileged=True, buildtype="boost", image="cppalliance/droneubuntu2204:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-12', 'CXXSTD': 'gnu++20', 'TEST_SUITE': suite, 'OPTIONS': '<cxxflags>-fsanitize=undefined <linkflags>-fsanitize=undefined <cxxflags>-DBOOST_CI_SANITIZER_BUILD' }, globalenv=globalenv))
+    result.append(linux_cxx("Ubuntu g++-12 C++20 TSAN" + " " + suite, "g++-12", packages="g++-12", privileged=True, buildtype="boost", image="cppalliance/droneubuntu2204:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-12', 'CXXSTD': 'gnu++20', 'TEST_SUITE': suite, 'OPTIONS': '<cxxflags>-fsanitize=thread <linkflags>-fsanitize=thread <cxxflags>-DBOOST_CI_SANITIZER_BUILD' }, globalenv=globalenv))
+    result.append(linux_cxx("Ubuntu clang++-14 C++20 ISAN" + " " + suite, "clang++-14", packages="clang-14", privileged=True, buildtype="boost", image="cppalliance/droneubuntu2204:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-14', 'CXXSTD': 'gnu++20', 'TEST_SUITE': suite, 'OPTIONS': '<cxxflags>-fsanitize=integer <linkflags>-fsanitize=integer' }, globalenv=globalenv))
 
   for suite in things_to_test:
     for cxx in gnu_5_stds:
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f446b5c48a..6914aa527f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -25,7 +25,7 @@ jobs:
       fail-fast: false
       matrix:
         compiler: [ g++-12, clang++-14 ]
-        standard: [ c++14, c++17, c++20 ]
+        standard: [ c++14, c++17 ]
         suite: [ github_ci_block_1, github_ci_block_2 ]
     steps:
       - uses: actions/checkout@v3
@@ -181,6 +181,7 @@ jobs:
         shell: cmd
     env:
       ARGS: toolset=${{ matrix.toolset }} address-model=64 cxxstd=${{ matrix.standard }}
+      ARGSLATEST: toolset=${{ matrix.toolset }} address-model=64 cxxstd=latest
     strategy:
       fail-fast: false
       matrix:
@@ -214,9 +215,14 @@ jobs:
       - name: Config info
         run: config_info_travis
         working-directory: ../boost-root/libs/config/test
-      - name: Test
+      - name: Test std-14 vc140 and std-14-17 vc142
+        if: ${{ matrix.toolset != 'msvc-14.0' || matrix.standard != '17' }}
         run: ..\..\..\b2 --hash %ARGS% define=CI_SUPPRESS_KNOWN_ISSUES debug-symbols=off ${{ matrix.suite }} pch=off
         working-directory: ../boost-root/libs/math/test
+      - name: Test std-latest vc140
+        if: ${{ matrix.toolset == 'msvc-14.0' && matrix.standard == '17' }}
+        run: ..\..\..\b2 --hash %ARGSLATEST% define=CI_SUPPRESS_KNOWN_ISSUES debug-symbols=off ${{ matrix.suite }} pch=off
+        working-directory: ../boost-root/libs/math/test
   windows_gcc:
     runs-on: windows-2019
     defaults:
@@ -270,7 +276,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        standard: [ 14, 17, 20 ]
+        toolset: [ msvc-14.3, clang-win ]
+        standard: [ 14, 17, latest ]
         suite: [ github_ci_block_1, github_ci_block_2 ]
     steps:
       - uses: actions/checkout@v3
diff --git a/doc/fp_utilities/float_next.qbk b/doc/fp_utilities/float_next.qbk
index 60d9df9f08..1e299f3882 100644
--- a/doc/fp_utilities/float_next.qbk
+++ b/doc/fp_utilities/float_next.qbk
@@ -261,7 +261,7 @@ next floating-point value, but `x - u` is not necessarily the previous value.  S
 value.  The corner cases occur at power of 2 boundaries.
 * When the argument becomes very small, it may be that there is no floating-point value that
 represents one ULP.  Whether this is the case or not depends not only on whether the hardware
-may ['sometimes] support denormals (as signalled by `std::numeric_limits<FPT>::has_denorm`), but also whether these are
+may ['sometimes] support denormals (as signalled by `boost::math::detail::has_denorm_now<FPT>()`), but also whether these are
 currently enabled at runtime (for example on SSE hardware, the DAZ or FTZ flags will disable denormal support).
 In this situation, the `ulp` function may return a value that is many orders of magnitude too large.
 
diff --git a/doc/sf/lambert_w.qbk b/doc/sf/lambert_w.qbk
index 22b13b6ac0..27591d9fee 100644
--- a/doc/sf/lambert_w.qbk
+++ b/doc/sf/lambert_w.qbk
@@ -289,7 +289,7 @@ The domain of /W/[sub -1] is \[-/e/[super -1], 0\). Numerically,
 For example, for `double`: lambert_wm1(-2.2250738585072014e-308) = -714.96865723796634 [br]
 and for `float`: lambert_wm1(-1.17549435e-38) = -91.8567734 [br]
 
-* `z < -std::numeric_limits<T>::min()`, means that z is zero or denormalized (if `std::numeric_limits<T>::has_denorm_min == true`),
+* `z < -std::numeric_limits<T>::min()`, means that z is zero or denormalized (if `boost::math::detail::has_denorm_now<T>() == true`),
 for example: `r = lambert_wm1(-std::numeric_limits<double>::denorm_min());` and an overflow_error exception is thrown,
 and will give a message like:
 
diff --git a/example/inspect_fp.cpp b/example/inspect_fp.cpp
index 71ea686f41..5de25f2ac7 100644
--- a/example/inspect_fp.cpp
+++ b/example/inspect_fp.cpp
@@ -20,6 +20,8 @@
 #include <boost/math/tools/config.hpp>
 #endif
 
+#include <boost/math/special_functions/next.hpp>  // for has_denorm_now
+
 //------------------------------------------------------------------------------
 
 bool is_big_endian()
@@ -111,9 +113,9 @@ template<class T> void print_table()
 {
     print_row("0", (T)0);
     print_row("sn.min", std::numeric_limits<T>::denorm_min(),
-          std::numeric_limits<T>::has_denorm);
+          boost::math::detail::has_denorm_now<T>());
     print_row("-sn.min", -std::numeric_limits<T>::denorm_min(),
-          std::numeric_limits<T>::has_denorm);
+          boost::math::detail::has_denorm_now<T>());
     print_row("n.min/256", (std::numeric_limits<T>::min)()/256);
     print_row("n.min/2", (std::numeric_limits<T>::min)()/2);
     print_row("-n.min/2", -(std::numeric_limits<T>::min)()/2);
diff --git a/include/boost/math/ccmath/abs.hpp b/include/boost/math/ccmath/abs.hpp
index 84e01fba01..c47ac1bac1 100644
--- a/include/boost/math/ccmath/abs.hpp
+++ b/include/boost/math/ccmath/abs.hpp
@@ -8,20 +8,13 @@
 #ifndef BOOST_MATH_CCMATH_ABS
 #define BOOST_MATH_CCMATH_ABS
 
-#include <cmath>
-#include <type_traits>
-#include <limits>
-#include <boost/math/tools/is_constant_evaluated.hpp>
 #include <boost/math/tools/assert.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 #include <boost/math/ccmath/isnan.hpp>
 #include <boost/math/ccmath/isinf.hpp>
 
-#include <boost/math/tools/is_standalone.hpp>
-#ifndef BOOST_MATH_STANDALONE
-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
-#error "The header <boost/math/norms.hpp> can only be used in C++17 and later."
-#endif
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/abs.hpp> can only be used in C++17 and later."
 #endif
 
 namespace boost::math::ccmath {
diff --git a/include/boost/math/ccmath/detail/config.hpp b/include/boost/math/ccmath/detail/config.hpp
new file mode 100644
index 0000000000..5dfbc2d912
--- /dev/null
+++ b/include/boost/math/ccmath/detail/config.hpp
@@ -0,0 +1,34 @@
+//  (C) Copyright John Maddock 2023.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  Core configuration for ccmath functions, basically will they work or not?
+
+#ifndef BOOST_MATH_CCMATH_DETAIL_CONFIG
+#define BOOST_MATH_CCMATH_DETAIL_CONFIG
+
+#include <cmath>
+#include <type_traits>
+#include <limits>
+#include <boost/math/tools/is_constant_evaluated.hpp>
+#include <boost/math/tools/is_standalone.hpp>
+
+#ifndef BOOST_MATH_STANDALONE
+#include <boost/config.hpp>
+#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
+#  define BOOST_MATH_NO_CCMATH
+#endif
+#endif
+
+#ifndef _MSC_VER
+//
+// Don't check here for msvc as they didn't get std lib configuration macros at the same time as C++17 <type_traits>
+//
+#if (__cpp_lib_bool_constant < 201505L) && !defined(BOOST_MATH_NO_CCMATH)
+#  define BOOST_MATH_NO_CCMATH
+#endif
+#endif
+
+
+#endif
diff --git a/include/boost/math/ccmath/div.hpp b/include/boost/math/ccmath/div.hpp
index a6cb5ce10c..613a22f3f5 100644
--- a/include/boost/math/ccmath/div.hpp
+++ b/include/boost/math/ccmath/div.hpp
@@ -6,18 +6,12 @@
 #ifndef BOOST_MATH_CCMATH_DIV_HPP
 #define BOOST_MATH_CCMATH_DIV_HPP
 
-#include <cmath>
-#include <cstdlib>
 #include <cinttypes>
 #include <cstdint>
-#include <type_traits>
+#include <boost/math/ccmath/detail/config.hpp>
 
-#include <boost/math/tools/is_standalone.hpp>
-#ifndef BOOST_MATH_STANDALONE
-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
-#error "The header <boost/math/norms.hpp> can only be used in C++17 and later."
-#endif
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/div.hpp> can only be used in C++17 and later."
 #endif
 
 namespace boost::math::ccmath {
diff --git a/include/boost/math/ccmath/fma.hpp b/include/boost/math/ccmath/fma.hpp
index 7bc12fe7a6..f11985521c 100644
--- a/include/boost/math/ccmath/fma.hpp
+++ b/include/boost/math/ccmath/fma.hpp
@@ -6,19 +6,12 @@
 #ifndef BOOST_MATH_CCMATH_FMA_HPP
 #define BOOST_MATH_CCMATH_FMA_HPP
 
-#include <cmath>
-#include <limits>
-#include <type_traits>
-#include <boost/math/tools/is_constant_evaluated.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 #include <boost/math/ccmath/isinf.hpp>
 #include <boost/math/ccmath/isnan.hpp>
 
-#include <boost/math/tools/is_standalone.hpp>
-#ifndef BOOST_MATH_STANDALONE
-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
-#error "The header <boost/math/norms.hpp> can only be used in C++17 and later."
-#endif
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/fma.hpp> can only be used in C++17 and later."
 #endif
 
 namespace boost::math::ccmath {
diff --git a/include/boost/math/ccmath/isinf.hpp b/include/boost/math/ccmath/isinf.hpp
index 7b942dcf72..dfbd1f00af 100644
--- a/include/boost/math/ccmath/isinf.hpp
+++ b/include/boost/math/ccmath/isinf.hpp
@@ -6,18 +6,11 @@
 #ifndef BOOST_MATH_CCMATH_ISINF
 #define BOOST_MATH_CCMATH_ISINF
 
-#include <cmath>
-#include <limits>
-#include <type_traits>
-#include <boost/math/tools/is_constant_evaluated.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 
-#include <boost/math/tools/is_standalone.hpp>
-#ifndef BOOST_MATH_STANDALONE
-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
-#error "The header <boost/math/norms.hpp> can only be used in C++17 and later."
-#endif
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/isinf.hpp> can only be used in C++17 and later."
 #endif
 
 namespace boost::math::ccmath {
diff --git a/include/boost/math/ccmath/isnan.hpp b/include/boost/math/ccmath/isnan.hpp
index a5e121a97f..504fa90d2c 100644
--- a/include/boost/math/ccmath/isnan.hpp
+++ b/include/boost/math/ccmath/isnan.hpp
@@ -6,17 +6,11 @@
 #ifndef BOOST_MATH_CCMATH_ISNAN
 #define BOOST_MATH_CCMATH_ISNAN
 
-#include <cmath>
-#include <type_traits>
-#include <boost/math/tools/is_constant_evaluated.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 
-#include <boost/math/tools/is_standalone.hpp>
-#ifndef BOOST_MATH_STANDALONE
-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
-#error "The header <boost/math/norms.hpp> can only be used in C++17 and later."
-#endif
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/isnan.hpp> can only be used in C++17 and later."
 #endif
 
 namespace boost::math::ccmath {
diff --git a/include/boost/math/ccmath/isnormal.hpp b/include/boost/math/ccmath/isnormal.hpp
index 8310a65848..96277caf72 100644
--- a/include/boost/math/ccmath/isnormal.hpp
+++ b/include/boost/math/ccmath/isnormal.hpp
@@ -6,20 +6,13 @@
 #ifndef BOOST_MATH_ISNORMAL_HPP
 #define BOOST_MATH_ISNORMAL_HPP
 
-#include <cmath>
-#include <limits>
-#include <type_traits>
-#include <boost/math/tools/is_constant_evaluated.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 #include <boost/math/ccmath/abs.hpp>
 #include <boost/math/ccmath/isinf.hpp>
 #include <boost/math/ccmath/isnan.hpp>
 
-#include <boost/math/tools/is_standalone.hpp>
-#ifndef BOOST_MATH_STANDALONE
-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
-#error "The header <boost/math/norms.hpp> can only be used in C++17 and later."
-#endif
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/abs.hpp> can only be used in C++17 and later."
 #endif
 
 namespace boost::math::ccmath {
diff --git a/include/boost/math/ccmath/ldexp.hpp b/include/boost/math/ccmath/ldexp.hpp
index 31730b265f..4e5c9a8d21 100644
--- a/include/boost/math/ccmath/ldexp.hpp
+++ b/include/boost/math/ccmath/ldexp.hpp
@@ -7,11 +7,8 @@
 #ifndef BOOST_MATH_CCMATH_LDEXP_HPP
 #define BOOST_MATH_CCMATH_LDEXP_HPP
 
-#include <cmath>
-#include <limits>
-#include <type_traits>
 #include <stdexcept>
-#include <boost/math/tools/is_constant_evaluated.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 #include <boost/math/ccmath/abs.hpp>
 #include <boost/math/ccmath/isinf.hpp>
 #include <boost/math/ccmath/isnan.hpp>
diff --git a/include/boost/math/ccmath/next.hpp b/include/boost/math/ccmath/next.hpp
index 30045a0a36..602c3bc9f9 100644
--- a/include/boost/math/ccmath/next.hpp
+++ b/include/boost/math/ccmath/next.hpp
@@ -101,7 +101,7 @@ constexpr T get_smallest_value(const std::false_type&)
 template <typename T>
 constexpr T get_smallest_value()
 {
-    return get_smallest_value<T>(std::integral_constant<bool, std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present)>());
+    return get_smallest_value<T>(std::integral_constant<bool, std::numeric_limits<T>::is_specialized>());
 }
 
 template <typename T>
diff --git a/include/boost/math/ccmath/round.hpp b/include/boost/math/ccmath/round.hpp
index 6b7947e646..0014c537ae 100644
--- a/include/boost/math/ccmath/round.hpp
+++ b/include/boost/math/ccmath/round.hpp
@@ -6,21 +6,15 @@
 #ifndef BOOST_MATH_CCMATH_ROUND_HPP
 #define BOOST_MATH_CCMATH_ROUND_HPP
 
-#include <cmath>
-#include <type_traits>
 #include <stdexcept>
-#include <boost/math/tools/is_constant_evaluated.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 #include <boost/math/ccmath/abs.hpp>
 #include <boost/math/ccmath/isinf.hpp>
 #include <boost/math/ccmath/isnan.hpp>
 #include <boost/math/ccmath/modf.hpp>
 
-#include <boost/math/tools/is_standalone.hpp>
-#ifndef BOOST_MATH_STANDALONE
-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
-#error "The header <boost/math/norms.hpp> can only be used in C++17 and later."
-#endif
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/round.hpp> can only be used in C++17 and later."
 #endif
 
 namespace boost::math::ccmath {
diff --git a/include/boost/math/ccmath/signbit.hpp b/include/boost/math/ccmath/signbit.hpp
index 4c7bf5b2c5..28ad619930 100644
--- a/include/boost/math/ccmath/signbit.hpp
+++ b/include/boost/math/ccmath/signbit.hpp
@@ -6,22 +6,15 @@
 #ifndef BOOST_MATH_CCMATH_SIGNBIT_HPP
 #define BOOST_MATH_CCMATH_SIGNBIT_HPP
 
-#include <cmath>
 #include <cstdint>
-#include <limits>
-#include <type_traits>
-#include <boost/math/tools/is_constant_evaluated.hpp>
 #include <boost/math/tools/assert.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 #include <boost/math/special_functions/detail/fp_traits.hpp>
 #include <boost/math/ccmath/isnan.hpp>
 #include <boost/math/ccmath/abs.hpp>
 
-#include <boost/math/tools/is_standalone.hpp>
-#ifndef BOOST_MATH_STANDALONE
-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
-#error "The header <boost/math/norms.hpp> can only be used in C++17 and later."
-#endif
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/signbit.hpp> can only be used in C++17 and later."
 #endif
 
 #ifdef __has_include
diff --git a/include/boost/math/concepts/real_concept.hpp b/include/boost/math/concepts/real_concept.hpp
index 56e4342e6b..565d58e421 100644
--- a/include/boost/math/concepts/real_concept.hpp
+++ b/include/boost/math/concepts/real_concept.hpp
@@ -45,8 +45,12 @@
 #  include <cstdio>
 #endif
 
-#if __has_include(<stdfloat>)
-#  include <stdfloat>
+#if defined __has_include
+#  if __cplusplus > 202002L || _MSVC_LANG > 202002L 
+#    if __has_include (<stdfloat>)
+#    include <stdfloat>
+#    endif
+#  endif
 #endif
 
 namespace boost{ namespace math{
diff --git a/include/boost/math/cstdfloat/cstdfloat_cmath.hpp b/include/boost/math/cstdfloat/cstdfloat_cmath.hpp
index 049ac4091e..515f3052a2 100644
--- a/include/boost/math/cstdfloat/cstdfloat_cmath.hpp
+++ b/include/boost/math/cstdfloat/cstdfloat_cmath.hpp
@@ -918,62 +918,6 @@ namespace std
    using boost::math::cstdfloat::detail::isunordered;
    //   end more functions
 
-   //
-   // Very basic iostream operator:
-   //
-   inline std::ostream& operator << (std::ostream& os, __float128 m_value)
-   {
-      std::streamsize digits = os.precision();
-      std::ios_base::fmtflags f = os.flags();
-      std::string s;
-
-      char buf[100];
-      std::unique_ptr<char[]> buf2;
-      std::string format = "%";
-      if (f & std::ios_base::showpos)
-         format += "+";
-      if (f & std::ios_base::showpoint)
-         format += "#";
-      format += ".*";
-      if (digits == 0)
-         digits = 36;
-      format += "Q";
-      if (f & std::ios_base::scientific)
-         format += "e";
-      else if (f & std::ios_base::fixed)
-         format += "f";
-      else
-         format += "g";
-
-      int v = quadmath_snprintf(buf, 100, format.c_str(), digits, m_value);
-
-      if ((v < 0) || (v >= 99))
-      {
-         int v_max = v;
-         buf2.reset(new char[v + 3]);
-         v = quadmath_snprintf(&buf2[0], v_max + 3, format.c_str(), digits, m_value);
-         if (v >= v_max + 3)
-         {
-            BOOST_MATH_THROW_EXCEPTION(std::runtime_error("Formatting of float128_type failed."));
-         }
-         s = &buf2[0];
-      }
-      else
-         s = buf;
-      std::streamsize ss = os.width();
-      if (ss > static_cast<std::streamsize>(s.size()))
-      {
-         char fill = os.fill();
-         if ((os.flags() & std::ios_base::left) == std::ios_base::left)
-            s.append(static_cast<std::string::size_type>(ss - s.size()), fill);
-         else
-            s.insert(static_cast<std::string::size_type>(0), static_cast<std::string::size_type>(ss - s.size()), fill);
-      }
-
-      return os << s;
-   }
-
-
 } // namespace std
 
 // We will now remove the preprocessor symbols representing quadruple-precision <cmath>
diff --git a/include/boost/math/cstdfloat/cstdfloat_iostream.hpp b/include/boost/math/cstdfloat/cstdfloat_iostream.hpp
index c01c236f71..7c2c396776 100644
--- a/include/boost/math/cstdfloat/cstdfloat_iostream.hpp
+++ b/include/boost/math/cstdfloat/cstdfloat_iostream.hpp
@@ -32,8 +32,7 @@
   #include <boost/math/tools/nothrow.hpp>
   #include <boost/math/tools/throw_exception.hpp>
 
-//  #if (0)
-  #if defined(__GNUC__)
+#if defined(__GNUC__) && !defined(BOOST_MATH_TEST_IO_AS_INTEL_QUAD)
 
   // Forward declarations of quadruple-precision string functions.
   extern "C" int quadmath_snprintf(char *str, size_t size, const char *format, ...) BOOST_MATH_NOTHROW;
@@ -96,7 +95,7 @@
         // So we have to use dynamic memory allocation for the output
         // string buffer.
 
-        char* my_buffer2 = static_cast<char*>(0U);
+        char* my_buffer2 = nullptr;
 
 #ifndef BOOST_NO_EXCEPTIONS
         try
@@ -160,8 +159,7 @@
     }
   }
 
-//  #elif defined(__GNUC__)
-  #elif defined(__INTEL_COMPILER)
+#elif defined(__INTEL_COMPILER) || defined(BOOST_MATH_TEST_IO_AS_INTEL_QUAD)
 
   // The section for I/O stream support for the ICC compiler is particularly
   // long, because these functions must be painstakingly synthesized from
@@ -172,6 +170,7 @@
   // used in Boost.Multiprecision by John Maddock and Christopher Kormanyos.
   // This methodology has been slightly modified here for boost::float128_t.
 
+
   #include <cstring>
   #include <cctype>
   
@@ -266,7 +265,7 @@
     {
       // Pad out the end with zero's if we need to.
 
-      int chars = static_cast<int>(str.size());
+      std::ptrdiff_t chars = static_cast<std::ptrdiff_t>(str.size());
       chars = digits - chars;
 
       if(scientific)
@@ -442,7 +441,7 @@
       if(isneg) { x = -x; }
 
       float_type t;
-      float_type ten = 10;
+      constexpr float_type ten = 10;
 
       eval_log10(t, x);
       eval_floor(t, t);
@@ -507,6 +506,8 @@
         eval_subtract(t, digit);
         eval_multiply(t, ten);
       }
+      if (result.size() == 0)
+         result = "0";
 
       // Possibly round the result.
       if(digits >= 0)
@@ -522,11 +523,13 @@
           if((static_cast<int>(*result.rbegin() - '0') & 1) != 0)
           {
             round_string_up_at(result, static_cast<int>(result.size() - 1U), expon);
+            if (digits == 0) digits = 1;
           }
         }
         else if(cdigit >= 5)
         {
-          round_string_up_at(result, static_cast<int>(result.size() - 1), expon);
+          round_string_up_at(result, static_cast<int>(result.size() - 1u), expon);
+          if (digits == 0) digits = 1;
         }
       }
     }
@@ -569,9 +572,9 @@
   {
     value = 0;
 
-    if((p == static_cast<const char*>(0U)) || (*p == static_cast<char>(0)))
+    if((p == nullptr) || (*p == '\0'))
     {
-      return;
+      return false;
     }
 
     bool is_neg       = false;
@@ -584,11 +587,11 @@
 
     constexpr int max_digits = std::numeric_limits<float_type>::max_digits10 + 1;
 
-    if(*p == static_cast<char>('+'))
+    if(*p == '+')
     {
       ++p;
     }
-    else if(*p == static_cast<char>('-'))
+    else if(*p == '-')
     {
       is_neg = true;
       ++p;
@@ -632,7 +635,7 @@
       ++digits_seen;
     }
 
-    if(*p == static_cast<char>('.'))
+    if(*p == '.')
     {
       // Grab everything after the point, stop when we've seen
       // enough digits, even if there are actually more available.
@@ -659,15 +662,15 @@
     }
 
     // Parse the exponent.
-    if((*p == static_cast<char>('e')) || (*p == static_cast<char>('E')))
+    if((*p == 'e') || (*p == 'E'))
     {
       ++p;
 
-      if(*p == static_cast<char>('+'))
+      if(*p == '+')
       {
         ++p;
       }
-      else if(*p == static_cast<char>('-'))
+      else if(*p == '-')
       {
         is_neg_expon = true;
         ++p;
@@ -718,7 +721,7 @@
       value = -value;
     }
 
-    return (*p == static_cast<char>(0));
+    return (*p == '\0');
   }
   } } } } // boost::math::cstdfloat::detail
 
diff --git a/include/boost/math/distributions/detail/inv_discrete_quantile.hpp b/include/boost/math/distributions/detail/inv_discrete_quantile.hpp
index 25216e88f6..2f5cae7432 100644
--- a/include/boost/math/distributions/detail/inv_discrete_quantile.hpp
+++ b/include/boost/math/distributions/detail/inv_discrete_quantile.hpp
@@ -147,7 +147,7 @@ typename Dist::value_type
    // we're assuming that "guess" is likely to be accurate
    // to the nearest int or so:
    //
-   else if(adder != 0)
+   else if((adder != 0) && (a + adder != a))
    {
       //
       // If we're looking for a large result, then bump "adder" up
@@ -302,15 +302,13 @@ inline typename Dist::value_type round_to_floor(const Dist& d, typename Dist::va
    //
    while(result != 0)
    {
-      cc = result - 1;
+      cc = floor(float_prior(result));
       if(cc < support(d).first)
          break;
       pp = c ? cdf(complement(d, cc)) : cdf(d, cc);
-      if(pp == p)
-         result = cc;
-      else if(c ? pp > p : pp < p)
+      if(c ? pp > p : pp < p)
          break;
-      result -= 1;
+      result = cc;
    }
 
    return result;
@@ -336,15 +334,13 @@ inline typename Dist::value_type round_to_ceil(const Dist& d, typename Dist::val
    //
    while(true)
    {
-      cc = result + 1;
+      cc = ceil(float_next(result));
       if(cc > support(d).second)
          break;
       pp = c ? cdf(complement(d, cc)) : cdf(d, cc);
-      if(pp == p)
-         result = cc;
-      else if(c ? pp < p : pp > p)
+      if(c ? pp < p : pp > p)
          break;
-      result += 1;
+      result = cc;
    }
 
    return result;
diff --git a/include/boost/math/distributions/kolmogorov_smirnov.hpp b/include/boost/math/distributions/kolmogorov_smirnov.hpp
index 0365b69838..6ae80632d3 100644
--- a/include/boost/math/distributions/kolmogorov_smirnov.hpp
+++ b/include/boost/math/distributions/kolmogorov_smirnov.hpp
@@ -382,7 +382,7 @@ inline RealType quantile(const kolmogorov_smirnov_distribution<RealType, Policy>
    std::uintmax_t m = policies::get_max_root_iterations<Policy>(); // and max iterations.
 
    return tools::newton_raphson_iterate(detail::kolmogorov_smirnov_quantile_functor<RealType, Policy>(dist, p),
-           k, RealType(0), boost::math::tools::max_value<RealType>(), get_digits, m);
+           k, RealType(0), RealType(1), get_digits, m);
 } // quantile
 
 template <class RealType, class Policy>
@@ -407,7 +407,7 @@ inline RealType quantile(const complemented2_type<kolmogorov_smirnov_distributio
 
    return tools::newton_raphson_iterate(
            detail::kolmogorov_smirnov_complementary_quantile_functor<RealType, Policy>(dist, p),
-           k, RealType(0), boost::math::tools::max_value<RealType>(), get_digits, m);
+           k, RealType(0), RealType(1), get_digits, m);
 } // quantile (complemented)
 
 template <class RealType, class Policy>
diff --git a/include/boost/math/distributions/non_central_t.hpp b/include/boost/math/distributions/non_central_t.hpp
index cb9af7e2e5..48483f0cae 100644
--- a/include/boost/math/distributions/non_central_t.hpp
+++ b/include/boost/math/distributions/non_central_t.hpp
@@ -396,10 +396,12 @@ namespace boost
             pois = gamma_p_derivative(T(k+1), d2, pol)
                * tgamma_delta_ratio(T(k + 1), T(0.5f))
                * delta / constants::root_two<T>();
+            BOOST_MATH_INSTRUMENT_VARIABLE(pois);
             // Starting beta term:
             xterm = x < y
                ? ibeta_derivative(T(k + 1), n / 2, x, pol)
                : ibeta_derivative(n / 2, T(k + 1), y, pol);
+            BOOST_MATH_INSTRUMENT_VARIABLE(xterm);
             T poisf(pois), xtermf(xterm);
             T sum = init_val;
             if((pois == 0) || (xterm == 0))
@@ -410,12 +412,16 @@ namespace boost
             // direction for recursion:
             //
             std::uintmax_t count = 0;
+            T old_ratio = 1;  // arbitrary "large" value
             for(auto i = k; i >= 0; --i)
             {
                T term = xterm * pois;
                sum += term;
-               if(((fabs(term/sum) < errtol) && (i != k)) || (term == 0))
+               BOOST_MATH_INSTRUMENT_VARIABLE(sum);
+               T ratio = fabs(term / sum);
+               if(((ratio < errtol) && (i != k) && (ratio < old_ratio)) || (term == 0))
                   break;
+               old_ratio = ratio;
                pois *= (i + 0.5f) / d2;
                xterm *= (i) / (x * (n / 2 + i));
                ++count;
@@ -426,6 +432,7 @@ namespace boost
                      "Series did not converge, closest value was %1%", sum, pol);
                }
             }
+            BOOST_MATH_INSTRUMENT_VARIABLE(sum);
             for(auto i = k + 1; ; ++i)
             {
                poisf *= d2 / (i + 0.5f);
@@ -442,6 +449,7 @@ namespace boost
                      "Series did not converge, closest value was %1%", sum, pol);
                }
             }
+            BOOST_MATH_INSTRUMENT_VARIABLE(sum);
             return sum;
          }
 
@@ -505,9 +513,12 @@ namespace boost
             // Calculate pdf:
             //
             T dt = n * t / (n * n + 2 * n * t * t + t * t * t * t);
+            BOOST_MATH_INSTRUMENT_VARIABLE(dt);
             T result = non_central_beta_pdf(a, b, d2, x, y, pol);
+            BOOST_MATH_INSTRUMENT_VARIABLE(result);
             T tol = tools::epsilon<T>() * result * 500;
             result = non_central_t2_pdf(n, delta, x, y, pol, result);
+            BOOST_MATH_INSTRUMENT_VARIABLE(result);
             if(result <= tol)
                result = 0;
             result *= dt;
diff --git a/include/boost/math/distributions/skew_normal.hpp b/include/boost/math/distributions/skew_normal.hpp
index c2843fea1c..0f0ffea8a8 100644
--- a/include/boost/math/distributions/skew_normal.hpp
+++ b/include/boost/math/distributions/skew_normal.hpp
@@ -676,8 +676,8 @@ namespace boost{ namespace math{
 
     // refine the result by numerically searching the root of (p-cdf)
 
-    const RealType search_min = range(dist).first;
-    const RealType search_max = range(dist).second;
+    const RealType search_min = support(dist).first;
+    const RealType search_max = support(dist).second;
 
     const int get_digits = policies::digits<RealType, Policy>();// get digits from policy,
     std::uintmax_t m = policies::get_max_root_iterations<Policy>(); // and max iterations.
diff --git a/include/boost/math/quadrature/detail/exp_sinh_detail.hpp b/include/boost/math/quadrature/detail/exp_sinh_detail.hpp
index a11a6aeb0c..db4863e7ac 100644
--- a/include/boost/math/quadrature/detail/exp_sinh_detail.hpp
+++ b/include/boost/math/quadrature/detail/exp_sinh_detail.hpp
@@ -226,7 +226,6 @@ auto exp_sinh_detail<Real, Policy>::integrate(const F& f, Real* error, Real* L1,
         auto weight_row = get_weight_row(i);
 
         first_j = first_j == 0 ? 0 : 2 * first_j - 1;  // appoximate location to start looking for lowest meaningful abscissa value
-        BOOST_MATH_MAYBE_UNUSED Real abterm1 = 1;
         std::size_t j = first_j;
         while (abscissas_row[j] < min_abscissa)
            ++j;
@@ -237,7 +236,6 @@ auto exp_sinh_detail<Real, Policy>::integrate(const F& f, Real* error, Real* L1,
             sum += y*weight_row[j];
             Real abterm0 = abs(y)*weight_row[j];
             absum += abterm0;
-            abterm1 = abterm0;
         }
 
         I1 += sum*h;
diff --git a/include/boost/math/special_functions/beta.hpp b/include/boost/math/special_functions/beta.hpp
index ec824daf72..f15e157324 100644
--- a/include/boost/math/special_functions/beta.hpp
+++ b/include/boost/math/special_functions/beta.hpp
@@ -230,7 +230,10 @@ T ibeta_power_terms(T a,
    T agh = static_cast<T>(a + Lanczos::g() - 0.5f);
    T bgh = static_cast<T>(b + Lanczos::g() - 0.5f);
    T cgh = static_cast<T>(c + Lanczos::g() - 0.5f);
-   result = Lanczos::lanczos_sum_expG_scaled(c) / (Lanczos::lanczos_sum_expG_scaled(a) * Lanczos::lanczos_sum_expG_scaled(b));
+   if ((a < tools::min_value<T>()) || (b < tools::min_value<T>()))
+      result = 0;  // denominator overflows in this case
+   else
+      result = Lanczos::lanczos_sum_expG_scaled(c) / (Lanczos::lanczos_sum_expG_scaled(a) * Lanczos::lanczos_sum_expG_scaled(b));
    result *= prefix;
    // combine with the leftover terms from the Lanczos approximation:
    result *= sqrt(bgh / boost::math::constants::e<T>());
@@ -389,14 +392,15 @@ T ibeta_power_terms(T a,
          }
          else
          {
-            T p1 = pow(b1, a / b);
+            // This protects against spurious overflow in a/b:
+            T p1 = (b1 < 1) && (b < 1) && (tools::max_value<T>() * b < a) ? static_cast<T>(0) : static_cast<T>(pow(b1, a / b));
             T l3 = (p1 != 0) && (b2 != 0) ? (log(p1) + log(b2)) * b : tools::max_value<T>();  // arbitrary large value if the logs would fail!
             if((l3 < tools::log_max_value<T>())
                && (l3 > tools::log_min_value<T>()))
             {
                result *= pow(p1 * b2, b);
             }
-            else
+            else if(result != 0)  // we can elude the calculation below if we're already going to be zero
             {
                l2 += l1 + log(result);
                if(l2 >= tools::log_max_value<T>())
@@ -473,20 +477,108 @@ T ibeta_power_terms(T a,
    if ((shift_a == 0) && (shift_b == 0))
    {
       T power1, power2;
+      bool need_logs = false;
       if (a < b)
       {
-         power1 = pow((x * y * c * c) / (a * b), a);
-         power2 = pow((y * c) / b, b - a);
+         BOOST_IF_CONSTEXPR(std::numeric_limits<T>::has_infinity)
+         {
+            power1 = pow((x * y * c * c) / (a * b), a);
+            power2 = pow((y * c) / b, b - a);
+         }
+         else
+         {
+            // We calculate these logs purely so we can check for overflow in the power functions
+            T l1 = log((x * y * c * c) / (a * b));
+            T l2 = log((y * c) / b);
+            if ((l1 * a > tools::log_min_value<T>()) && (l1 * a < tools::log_max_value<T>()) && (l2 * (b - a) < tools::log_max_value<T>()) && (l2 * (b - a) > tools::log_min_value<T>()))
+            {
+               power1 = pow((x * y * c * c) / (a * b), a);
+               power2 = pow((y * c) / b, b - a);
+            }
+            else
+            {
+               need_logs = true;
+            }
+         }
       }
       else
       {
-         power1 = pow((x * y * c * c) / (a * b), b);
-         power2 = pow((x * c) / a, a - b);
+         BOOST_IF_CONSTEXPR(std::numeric_limits<T>::has_infinity)
+         {
+            power1 = pow((x * y * c * c) / (a * b), b);
+            power2 = pow((x * c) / a, a - b);
+         }
+         else
+         {
+            // We calculate these logs purely so we can check for overflow in the power functions
+            T l1 = log((x * y * c * c) / (a * b)) * b;
+            T l2 = log((x * c) / a) * (a - b);
+            if ((l1 * a > tools::log_min_value<T>()) && (l1 * a < tools::log_max_value<T>()) && (l2 * (b - a) < tools::log_max_value<T>()) && (l2 * (b - a) > tools::log_min_value<T>()))
+            {
+               power1 = pow((x * y * c * c) / (a * b), b);
+               power2 = pow((x * c) / a, a - b);
+            }
+            else
+               need_logs = true;
+         }
+      }
+      BOOST_IF_CONSTEXPR(std::numeric_limits<T>::has_infinity)
+      {
+         if (!(boost::math::isnormal)(power1) || !(boost::math::isnormal)(power2))
+         {
+            need_logs = true;
+         }
       }
-      if (!(boost::math::isnormal)(power1) || !(boost::math::isnormal)(power2))
+      if (need_logs)
       {
-         // We have to use logs :(
-         return prefix * exp(a * log(x * c / a) + b * log(y * c / b)) * scaled_tgamma_no_lanczos(c, pol) / (scaled_tgamma_no_lanczos(a, pol) * scaled_tgamma_no_lanczos(b, pol));
+         //
+         // We want:
+         //
+         // (xc / a)^a (yc / b)^b
+         //
+         // But we know that one or other term will over / underflow and combining the logs will be next to useless as that will cause significant cancellation.
+         // If we assume b > a and express z ^ b as(z ^ b / a) ^ a with z = (yc / b) then we can move one power term inside the other :
+         //
+         // ((xc / a) * (yc / b)^(b / a))^a
+         //
+         // However, we're not quite there yet, as the term being exponentiated is quite likely to be close to unity, so let:
+         //
+         // xc / a = 1 + (xb - ya) / a
+         //
+         // analogously let :
+         //
+         // 1 + p = (yc / b) ^ (b / a) = 1 + expm1((b / a) * log1p((ya - xb) / b))
+         //
+         // so putting the two together we have :
+         //
+         // exp(a * log1p((xb - ya) / a + p + p(xb - ya) / a))
+         //
+         // Analogously, when a > b we can just swap all the terms around.
+         // 
+         // Finally, there are a few cases (x or y is unity) when the above logic can't be used
+         // or where there is no logarithmic cancellation and accuracy is better just using
+         // the regular formula:
+         //
+         T xc_a = x * c / a;
+         T yc_b = y * c / b;
+         if ((x == 1) || (y == 1) || (fabs(xc_a - 1) > 0.25) || (fabs(yc_b - 1) > 0.25))
+         {
+            // The above logic fails, the result is almost certainly zero:
+            power1 = exp(log(xc_a) * a + log(yc_b) * b);
+            power2 = 1;
+         }
+         else if (b > a)
+         {
+            T p = boost::math::expm1((b / a) * boost::math::log1p((y * a - x * b) / b));
+            power1 = exp(a * boost::math::log1p((x * b - y * a) / a + p * (x * c / a)));
+            power2 = 1;
+         }
+         else
+         {
+            T p = boost::math::expm1((a / b) * boost::math::log1p((x * b - y * a) / a));
+            power1 = exp(b * boost::math::log1p((y * a - x * b) / b + p * (y * c / b)));
+            power2 = 1;
+         }
       }
       return prefix * power1 * power2 * scaled_tgamma_no_lanczos(c, pol) / (scaled_tgamma_no_lanczos(a, pol) * scaled_tgamma_no_lanczos(b, pol));
    }
@@ -568,7 +660,10 @@ T ibeta_series(T a, T b, T x, T s0, const Lanczos&, bool normalised, T* p_deriva
       T agh = static_cast<T>(a + Lanczos::g() - 0.5f);
       T bgh = static_cast<T>(b + Lanczos::g() - 0.5f);
       T cgh = static_cast<T>(c + Lanczos::g() - 0.5f);
-      result = Lanczos::lanczos_sum_expG_scaled(c) / (Lanczos::lanczos_sum_expG_scaled(a) * Lanczos::lanczos_sum_expG_scaled(b));
+      if ((a < tools::min_value<T>()) || (b < tools::min_value<T>()))
+         result = 0;  // denorms cause overflow in the Lanzos series, result will be zero anyway
+      else
+         result = Lanczos::lanczos_sum_expG_scaled(c) / (Lanczos::lanczos_sum_expG_scaled(a) * Lanczos::lanczos_sum_expG_scaled(b));
 
       if (!(boost::math::isfinite)(result))
          result = 0;
@@ -601,10 +696,13 @@ T ibeta_series(T a, T b, T x, T s0, const Lanczos&, bool normalised, T* p_deriva
          //
          // Oh dear, we need logs, and this *will* cancel:
          //
-         result = log(result) + l1 + l2 + (log(agh) - 1) / 2;
-         if(p_derivative)
-            *p_derivative = exp(result + b * log(y));
-         result = exp(result);
+         if (result != 0)  // elude calculation when result will be zero.
+         {
+            result = log(result) + l1 + l2 + (log(agh) - 1) / 2;
+            if (p_derivative)
+               *p_derivative = exp(result + b * log(y));
+            result = exp(result);
+         }
       }
    }
    else
@@ -1021,18 +1119,15 @@ T ibeta_imp(T a, T b, T x, const Policy& pol, bool inv, bool normalised, T* p_de
    BOOST_MATH_ASSERT((p_derivative == 0) || normalised);
 
    if(!(boost::math::isfinite)(a))
-      return policies::raise_domain_error<T>(function, "The argument a to the incomplete beta function must be >= zero (got a=%1%).", a, pol);
+      return policies::raise_domain_error<T>(function, "The argument a to the incomplete beta function must be finite (got a=%1%).", a, pol);
    if(!(boost::math::isfinite)(b))
-      return policies::raise_domain_error<T>(function, "The argument b to the incomplete beta function must be >= zero (got b=%1%).", b, pol);
-   if(!(boost::math::isfinite)(x))
+      return policies::raise_domain_error<T>(function, "The argument b to the incomplete beta function must be finite (got b=%1%).", b, pol);
+   if (!(0 <= x && x <= 1))
       return policies::raise_domain_error<T>(function, "The argument x to the incomplete beta function must be in [0,1] (got x=%1%).", x, pol);
 
    if(p_derivative)
       *p_derivative = -1; // value not set.
 
-   if((x < 0) || (x > 1))
-      return policies::raise_domain_error<T>(function, "Parameter x outside the range [0,1] in the incomplete beta function (got x=%1%).", x, pol);
-
    if(normalised)
    {
       if(a < 0)
@@ -1422,18 +1517,16 @@ T ibeta_derivative_imp(T a, T b, T x, const Policy& pol)
    // start with the usual error checks:
    //
    if (!(boost::math::isfinite)(a))
-      return policies::raise_domain_error<T>(function, "The argument a to the incomplete beta function must be >= zero (got a=%1%).", a, pol);
+      return policies::raise_domain_error<T>(function, "The argument a to the incomplete beta function must be finite (got a=%1%).", a, pol);
    if (!(boost::math::isfinite)(b))
-      return policies::raise_domain_error<T>(function, "The argument b to the incomplete beta function must be >= zero (got b=%1%).", b, pol);
-   if (!(boost::math::isfinite)(x))
+      return policies::raise_domain_error<T>(function, "The argument b to the incomplete beta function must be finite (got b=%1%).", b, pol);
+   if (!(0 <= x && x <= 1))
       return policies::raise_domain_error<T>(function, "The argument x to the incomplete beta function must be in [0,1] (got x=%1%).", x, pol);
 
    if(a <= 0)
       return policies::raise_domain_error<T>(function, "The argument a to the incomplete beta function must be greater than zero (got a=%1%).", a, pol);
    if(b <= 0)
       return policies::raise_domain_error<T>(function, "The argument b to the incomplete beta function must be greater than zero (got b=%1%).", b, pol);
-   if((x < 0) || (x > 1))
-      return policies::raise_domain_error<T>(function, "Parameter x outside the range [0,1] in the incomplete beta function (got x=%1%).", x, pol);
    //
    // Now the corner cases:
    //
diff --git a/include/boost/math/special_functions/detail/hypergeometric_1F1_large_abz.hpp b/include/boost/math/special_functions/detail/hypergeometric_1F1_large_abz.hpp
index 6345095f8c..d072ec2b60 100644
--- a/include/boost/math/special_functions/detail/hypergeometric_1F1_large_abz.hpp
+++ b/include/boost/math/special_functions/detail/hypergeometric_1F1_large_abz.hpp
@@ -393,7 +393,15 @@
         // So shift b to match a (b shifting seems to be more stable via method of ratios).
         //
         int b_shift = itrunc(b - a);
+        if ((b_shift < 0) && (b - b_shift != a))
+           b_shift -= 1;
         T b_local = b - b_shift;
+        if ((b_local - a - 0.5 <= 0) && (b_local != a))
+        {
+           // Make sure b_local - a - 0.5 > 0
+           b_shift -= 1;
+           b_local += 1;
+        }
         T h = boost::math::detail::hypergeometric_1F1_AS_13_3_6(a, b_local, z, T(b_local - a), pol, log_scaling);
         return hypergeometric_1F1_shift_on_b(h, a, b_local, z, b_shift, pol, log_scaling);
      }
diff --git a/include/boost/math/special_functions/detail/ibeta_inverse.hpp b/include/boost/math/special_functions/detail/ibeta_inverse.hpp
index be4bd95399..98cc1d7485 100644
--- a/include/boost/math/special_functions/detail/ibeta_inverse.hpp
+++ b/include/boost/math/special_functions/detail/ibeta_inverse.hpp
@@ -25,23 +25,16 @@ namespace boost{ namespace math{ namespace detail{
 template <class T>
 struct temme_root_finder
 {
-   temme_root_finder(const T t_, const T a_) : t(t_), a(a_) {}
+   temme_root_finder(const T t_, const T a_) : t(t_), a(a_) {
+      const T x_extrema = 1 / (1 + a);
+      BOOST_MATH_ASSERT(0 < x_extrema && x_extrema < 1);
+   }
 
    boost::math::tuple<T, T> operator()(T x)
    {
       BOOST_MATH_STD_USING // ADL of std names
 
       T y = 1 - x;
-      if(y == 0)
-      {
-         T big = tools::max_value<T>() / 4;
-         return boost::math::make_tuple(static_cast<T>(-big), static_cast<T>(-big));
-      }
-      if(x == 0)
-      {
-         T big = tools::max_value<T>() / 4;
-         return boost::math::make_tuple(static_cast<T>(-big), big);
-      }
       T f = log(x) + a * log(y) + t;
       T f1 = (1 / x) - (a / (y));
       return boost::math::make_tuple(f, f1);
@@ -410,6 +403,10 @@ T temme_method_3_ibeta_inverse(T a, T b, T p, T q, const Policy& pol)
    T lower = eta < mu ? cross : 0;
    T upper = eta < mu ? 1 : cross;
    T x = (lower + upper) / 2;
+
+   // Early exit for cases with numerical precision issues.
+   if (cross == 0 || cross == 1) { return cross; }
+   
    x = tools::newton_raphson_iterate(
       temme_root_finder<T>(u, mu), x, lower, upper, policies::digits<T, Policy>() / 2);
 #ifdef BOOST_INSTRUMENT
@@ -828,7 +825,21 @@ T ibeta_inv_imp(T a, T b, T p, T q, const Policy& pol, T* py)
          std::swap(p, q);
          invert = !invert;
       }
-      if(pow(p, 1/a) < 0.5)
+      if (a < tools::min_value<T>())
+      {
+         // Avoid spurious overflows for denorms:
+         if (p < 1)
+         {
+            x = 1;
+            y = 0;
+         }
+         else
+         {
+            x = 0;
+            y = 1;
+         }
+      }
+      else if(pow(p, 1/a) < 0.5)
       {
 #ifndef BOOST_NO_EXCEPTIONS
          try 
diff --git a/include/boost/math/special_functions/fibonacci.hpp b/include/boost/math/special_functions/fibonacci.hpp
index 7aaf6dd854..2eb4cabaff 100644
--- a/include/boost/math/special_functions/fibonacci.hpp
+++ b/include/boost/math/special_functions/fibonacci.hpp
@@ -32,8 +32,8 @@ inline BOOST_CXX14_CONSTEXPR T unchecked_fibonacci(unsigned long long n) noexcep
     if (n <= 2) return n == 0 ? 0 : 1;
     /* 
      * This is based on the following identities by Dijkstra:
-     *   F(2*n)   = F(n)^2 + F(n+1)^2
-     *   F(2*n+1) = (2 * F(n) + F(n+1)) * F(n+1)
+     *   F(2*n-1) = F(n-1)^2 + F(n)^2
+     *   F(2*n)   = (2*F(n-1) + F(n)) * F(n)
      * The implementation is iterative and is unrolled version of trivial recursive implementation.
      */
     unsigned long long mask = 1;
diff --git a/include/boost/math/special_functions/hypergeometric_1F1.hpp b/include/boost/math/special_functions/hypergeometric_1F1.hpp
index f406996290..48740a3114 100644
--- a/include/boost/math/special_functions/hypergeometric_1F1.hpp
+++ b/include/boost/math/special_functions/hypergeometric_1F1.hpp
@@ -355,7 +355,9 @@ namespace boost { namespace math { namespace detail {
          if ((a < 0) && (a == ceil(a)) && (a > -50))
             return detail::hypergeometric_1F1_generic_series(a, b, z, pol, log_scaling, function);
 
-         return (b + z) * exp(z) / b;
+         log_scaling = lltrunc(floor(z));
+         T local_z = z - log_scaling;
+         return (b + z) * exp(local_z) / b;
       }
 
       if ((a == 1) && (b == 2))
diff --git a/include/boost/math/special_functions/lambert_w.hpp b/include/boost/math/special_functions/lambert_w.hpp
index c57ce1d5bd..014282e0cf 100644
--- a/include/boost/math/special_functions/lambert_w.hpp
+++ b/include/boost/math/special_functions/lambert_w.hpp
@@ -55,6 +55,7 @@ BOOST_MATH_INSTRUMENT_LAMBERT_W_SMALL_Z_SERIES_ITERATIONS  // Show evaluation of
 #include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/math/special_functions/log1p.hpp> // for log (1 + x)
 #include <boost/math/constants/constants.hpp> // For exp_minus_one == 3.67879441171442321595523770161460867e-01.
+#include <boost/math/special_functions/next.hpp>  // for has_denorm_now
 #include <boost/math/special_functions/pow.hpp> // powers with compile time exponent, used in arbitrary precision code.
 #include <boost/math/tools/series.hpp> // series functor.
 //#include <boost/math/tools/polynomial.hpp>  // polynomial.
@@ -1797,7 +1798,7 @@ T lambert_wm1_imp(const T z, const Policy&  pol)
       return -tools::max_value<T>();
     }
   }
-  if (std::numeric_limits<T>::has_denorm)
+  if (boost::math::detail::has_denorm_now<T>())
   { // All real types except arbitrary precision.
     if (!(boost::math::isnormal)(z))
     { // Almost zero - might also just return infinity like z == 0 or max_value?
diff --git a/include/boost/math/special_functions/legendre_stieltjes.hpp b/include/boost/math/special_functions/legendre_stieltjes.hpp
index 2e9e559db7..44eafea2d5 100644
--- a/include/boost/math/special_functions/legendre_stieltjes.hpp
+++ b/include/boost/math/special_functions/legendre_stieltjes.hpp
@@ -156,7 +156,7 @@ class legendre_stieltjes
 
         std::vector<Real> stieltjes_zeros;
         std::vector<Real> legendre_zeros = legendre_p_zeros<Real>(m_m - 1);
-        int k;
+        size_t k;
         if (m_m & 1)
         {
             stieltjes_zeros.resize(legendre_zeros.size() + 1, std::numeric_limits<Real>::quiet_NaN());
@@ -169,14 +169,14 @@ class legendre_stieltjes
             k = 0;
         }
 
-        while (k < (int)stieltjes_zeros.size())
+        while (k < stieltjes_zeros.size())
         {
             Real lower_bound;
             Real upper_bound;
             if (m_m & 1)
             {
                 lower_bound = legendre_zeros[k - 1];
-                if (k == (int)legendre_zeros.size())
+                if (k == legendre_zeros.size())
                 {
                     upper_bound = 1;
                 }
@@ -188,7 +188,7 @@ class legendre_stieltjes
             else
             {
                 lower_bound = legendre_zeros[k];
-                if (k == (int)legendre_zeros.size() - 1)
+                if (k == legendre_zeros.size() - 1)
                 {
                     upper_bound = 1;
                 }
diff --git a/include/boost/math/special_functions/next.hpp b/include/boost/math/special_functions/next.hpp
index 07c55e8d4a..1b56932423 100644
--- a/include/boost/math/special_functions/next.hpp
+++ b/include/boost/math/special_functions/next.hpp
@@ -82,8 +82,8 @@ inline T normalize_value(const T& val, const std::true_type&)
 }
 
 template <class T>
-inline T get_smallest_value(std::true_type const&)
-{
+inline T get_smallest_value(std::true_type const&) {
+   static_assert(std::numeric_limits<T>::is_specialized, "Type T must be specialized.");
    //
    // numeric_limits lies about denorms being present - particularly
    // when this can be turned on or off at runtime, as is the case
@@ -106,11 +106,12 @@ inline T get_smallest_value(std::false_type const&)
 template <class T>
 inline T get_smallest_value()
 {
-#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1310)
-   return get_smallest_value<T>(std::integral_constant<bool, std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == 1)>());
-#else
-   return get_smallest_value<T>(std::integral_constant<bool, std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present)>());
-#endif
+   return get_smallest_value<T>(std::integral_constant<bool, std::numeric_limits<T>::is_specialized>());
+}
+
+template <class T>
+inline bool has_denorm_now() {
+   return get_smallest_value<T>() < tools::min_value<T>();
 }
 
 //
diff --git a/include/boost/math/special_functions/round.hpp b/include/boost/math/special_functions/round.hpp
index b32c8e4347..e74acba85b 100644
--- a/include/boost/math/special_functions/round.hpp
+++ b/include/boost/math/special_functions/round.hpp
@@ -12,6 +12,7 @@
 #endif
 
 #include <boost/math/tools/config.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 #include <boost/math/policies/error_handling.hpp>
 #include <boost/math/special_functions/math_fwd.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
@@ -19,11 +20,9 @@
 #include <limits>
 #include <cmath>
 
-#ifndef BOOST_NO_CXX17_IF_CONSTEXPR
+#if !defined(BOOST_MATH_NO_CCMATH) && !defined(BOOST_MATH_NO_CONSTEXPR_DETECTION)
 #include <boost/math/ccmath/ldexp.hpp>
-#  if !defined(BOOST_MATH_NO_CONSTEXPR_DETECTION)
 #    define BOOST_MATH_HAS_CONSTEXPR_LDEXP
-#  endif
 #endif
 
 namespace boost{ namespace math{
diff --git a/include/boost/math/special_functions/trunc.hpp b/include/boost/math/special_functions/trunc.hpp
index 7ac33a92d3..a084de560b 100644
--- a/include/boost/math/special_functions/trunc.hpp
+++ b/include/boost/math/special_functions/trunc.hpp
@@ -14,14 +14,14 @@
 #include <type_traits>
 #include <boost/math/special_functions/math_fwd.hpp>
 #include <boost/math/tools/config.hpp>
+#include <boost/math/ccmath/detail/config.hpp>
 #include <boost/math/policies/error_handling.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/math/tools/is_constant_evaluated.hpp>
 
-#ifndef BOOST_NO_CXX17_IF_CONSTEXPR
+#if !defined(BOOST_MATH_NO_CCMATH) && !defined(BOOST_MATH_NO_CONSTEXPR_DETECTION)
 #include <boost/math/ccmath/ldexp.hpp>
-#  if !defined(BOOST_MATH_NO_CONSTEXPR_DETECTION)
 #    define BOOST_MATH_HAS_CONSTEXPR_LDEXP
-#  endif
 #endif
 
 namespace boost{ namespace math{ namespace detail{
diff --git a/include/boost/math/tools/big_constant.hpp b/include/boost/math/tools/big_constant.hpp
index bec93a1165..b26d8cf86d 100644
--- a/include/boost/math/tools/big_constant.hpp
+++ b/include/boost/math/tools/big_constant.hpp
@@ -60,7 +60,7 @@ inline T make_big_value(largest_float, const char* s, std::false_type const&, st
 }
 #else
 template <typename T>
-inline T make_big_value(largest_float, const char* s, std::false_type const&, std::false_type const&)
+inline T make_big_value(largest_float, const char*, std::false_type const&, std::false_type const&)
 {
    static_assert(sizeof(T) == 0, "Type is unsupported in standalone mode. Please disable and try again.");
 }
diff --git a/include/boost/math/tools/config.hpp b/include/boost/math/tools/config.hpp
index 66e7da52ab..b1d93bc3d2 100644
--- a/include/boost/math/tools/config.hpp
+++ b/include/boost/math/tools/config.hpp
@@ -146,34 +146,17 @@
 #  define BOOST_MATH_EXEC_COMPATIBLE
 #endif
 
-// Attributes from C++14 and newer
-#ifdef __has_cpp_attribute
-
-// C++17
-#if (__cplusplus >= 201703L || _MSVC_LANG >= 201703L)
-#  if __has_cpp_attribute(maybe_unused)
-#    define BOOST_MATH_MAYBE_UNUSED [[maybe_unused]]
-#  endif
-#endif
-
-#endif // Standalone config
-
-// If attributes are not defined make sure we don't have compiler errors
-#ifndef BOOST_MATH_MAYBE_UNUSED
-#  define BOOST_MATH_MAYBE_UNUSED 
-#endif
-
 // C++23
 #if __cplusplus > 202002L || _MSVC_LANG > 202002L
 #  if __GNUC__ >= 13
      // libstdc++3 only defines to/from_chars for std::float128_t when one of these defines are set
      // otherwise we're right out of luck...
 #    if defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) || defined(_GLIBCXX_HAVE_FLOAT128_MATH)
-#    include <cstring> // std::strlen is used with from_chars
-#    include <charconv>
-#    include <stdfloat>
-#    define BOOST_MATH_USE_CHARCONV_FOR_CONVERSION
-#endif
+#      include <cstring> // std::strlen is used with from_chars
+#      include <charconv>
+#      include <stdfloat>
+#      define BOOST_MATH_USE_CHARCONV_FOR_CONVERSION
+#    endif
 #  endif
 #endif
 
diff --git a/include/boost/math/tools/promotion.hpp b/include/boost/math/tools/promotion.hpp
index 68127efb04..842022694e 100644
--- a/include/boost/math/tools/promotion.hpp
+++ b/include/boost/math/tools/promotion.hpp
@@ -26,8 +26,12 @@
 #include <boost/math/tools/config.hpp>
 #include <type_traits>
 
-#if __has_include(<stdfloat>)
-#  include <stdfloat>
+#if defined __has_include
+#  if __cplusplus > 202002L || _MSVC_LANG > 202002L 
+#    if __has_include (<stdfloat>)
+#    include <stdfloat>
+#    endif
+#  endif
 #endif
 
 namespace boost
diff --git a/include/boost/math/tools/roots.hpp b/include/boost/math/tools/roots.hpp
index 9fd7bee488..af46e2fcdd 100644
--- a/include/boost/math/tools/roots.hpp
+++ b/include/boost/math/tools/roots.hpp
@@ -275,14 +275,7 @@ T newton_raphson_iterate(F f, T guess, T min, T max, int digits, std::uintmax_t&
       if (fabs(delta * 2) > fabs(delta2))
       {
          // Last two steps haven't converged.
-         T shift = (delta > 0) ? (result - min) / 2 : (result - max) / 2;
-         if ((result != 0) && (fabs(shift) > fabs(result)))
-         {
-            delta = sign(delta) * fabs(result) * 1.1f; // Protect against huge jumps!
-            //delta = sign(delta) * result; // Protect against huge jumps! Failed for negative result. https://github.com/boostorg/math/issues/216
-         }
-         else
-            delta = shift;
+         delta = (delta > 0) ? (result - min) / 2 : (result - max) / 2;
          // reset delta1/2 so we don't take this branch next time round:
          delta1 = 3 * delta;
          delta2 = 3 * delta;
@@ -596,7 +589,8 @@ namespace detail {
    #ifdef BOOST_MATH_INSTRUMENT
          std::cout << "Second order root iteration, delta = " << delta << ", residual = " << f0 << "\n";
    #endif
-         T convergence = fabs(delta / delta2);
+         // We need to avoid delta/delta2 overflowing here:
+         T convergence = (fabs(delta2) > 1) || (fabs(tools::max_value<T>() * delta2) > fabs(delta)) ? fabs(delta / delta2) : tools::max_value<T>();
          if ((convergence > 0.8) && (convergence < 2))
          {
             // last two steps haven't converged.
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 7885649f71..44c76058ba 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -169,6 +169,7 @@ test-suite special_fun :
    [ run git_issue_810.cpp ../../test/build//boost_unit_test_framework  ]
    [ run git_issue_826.cpp ../../test/build//boost_unit_test_framework  ]
    [ run git_issue_961.cpp ]
+   [ run git_issue_1006.cpp ]
    [ run special_functions_test.cpp ../../test/build//boost_unit_test_framework  ]
    [ run test_airy.cpp test_instances//test_instances pch_light ../../test/build//boost_unit_test_framework  ]
    [ run test_bessel_j.cpp test_instances//test_instances pch_light ../../test/build//boost_unit_test_framework  ]
@@ -908,6 +909,8 @@ test-suite new_floats :
    [ compile compile_test/float32.cpp ]
    [ compile compile_test/float64.cpp ]
    [ compile compile_test/float128.cpp ]
+   [ run test_float_io.cpp : : : [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <define>BOOST_MATH_TEST_FLOAT128 <linkflags>"-Bstatic -lquadmath -Bdynamic" ] ]
+   [ run test_float_io.cpp : : : <define>BOOST_MATH_TEST_IO_AS_INTEL_QUAD=1 [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <define>BOOST_MATH_TEST_FLOAT128 <linkflags>"-Bstatic -lquadmath -Bdynamic" ] : test_float_io_quad ]
 ;
 
 test-suite mp :
@@ -983,7 +986,7 @@ test-suite misc :
    [ run centered_continued_fraction_test.cpp : : : [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] ]
    [ run luroth_expansion_test.cpp : : : [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] ]
    [ run engel_expansion_test.cpp : : : [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] ]
-   [ run test_classify.cpp pch ../../test/build//boost_unit_test_framework  ]
+   [ run test_classify.cpp pch ../../test/build//boost_unit_test_framework : : : <toolset>msvc:<cxxflags>/bigobj ]
    [ run test_error_handling.cpp ../../test/build//boost_unit_test_framework  ]
    [ run legendre_stieltjes_test.cpp ../../test/build//boost_unit_test_framework : : : [ requires cxx11_auto_declarations cxx11_range_based_for ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ]  ]
    [ run test_minima.cpp pch ../../test/build//boost_unit_test_framework  ]
diff --git a/test/cohen_acceleration_test.cpp b/test/cohen_acceleration_test.cpp
index ad70c3f825..4269083050 100644
--- a/test/cohen_acceleration_test.cpp
+++ b/test/cohen_acceleration_test.cpp
@@ -71,7 +71,7 @@ void test_divergent()
 {
     auto g = Divergent<Real>();
     Real x = -cohen_acceleration(g);
-    CHECK_ULP_CLOSE(log(pi<Real>()/2)/2, x, (std::numeric_limits<Real>::digits > 100 ? 350 : 135));
+    CHECK_ULP_CLOSE(log(pi<Real>()/2)/2, x, (std::numeric_limits<Real>::digits > 100 ? 350 : 150));
 }
 
 int main()
diff --git a/test/git_issue_1006.cpp b/test/git_issue_1006.cpp
new file mode 100644
index 0000000000..f8d6dfa239
--- /dev/null
+++ b/test/git_issue_1006.cpp
@@ -0,0 +1,60 @@
+//  (C) Copyright Matt Borland 2023.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "math_unit_test.hpp"
+#include <cfenv>
+#include <iostream>
+#include <boost/math/distributions/beta.hpp>
+
+#pragma STDC FENV_ACCESS ON
+
+// Show and then clear the fenv flags
+void show_fpexcept_flags()
+{
+   bool fe = false;
+
+   if (std::fetestexcept(FE_OVERFLOW))
+   {
+      fe = true;
+      std::cerr << "FE_OVERFLOW" << std::endl;
+   }
+   if (std::fetestexcept(FE_UNDERFLOW))
+   {
+      //fe = true;
+      std::cerr << "FE_UNDERFLOW" << std::endl;
+   }
+   if (std::fetestexcept(FE_DIVBYZERO))
+   {
+      fe = true;
+      std::cerr << "FE_DIVBYZERO" << std::endl;
+   }
+   if (std::fetestexcept(FE_INVALID))
+   {
+      fe = true;
+      std::cerr << "FE_INVALID" << std::endl;
+   }
+
+   CHECK_EQUAL(fe, false);
+
+   std::feclearexcept(FE_ALL_EXCEPT);
+}
+
+int main()
+{
+   // Default Scipy policy
+   using my_policy = boost::math::policies::policy<boost::math::policies::promote_float<false>, boost::math::policies::default_policy, boost::math::policies::default_policy, boost::math::policies::default_policy, boost::math::policies::default_policy, boost::math::policies::default_policy, boost::math::policies::default_policy, boost::math::policies::default_policy, boost::math::policies::default_policy, boost::math::policies::default_policy, boost::math::policies::default_policy>;
+
+   double a = 1e-307;
+
+   while (a)
+   {
+      const auto dist_a = boost::math::beta_distribution<double, my_policy>(1e-308, 5.0);
+      const auto dist_a_ppf = boost::math::quantile(dist_a, 0.2);
+      show_fpexcept_flags();
+      CHECK_MOLLIFIED_CLOSE(dist_a_ppf, 0.0, 1e-10);
+      a /= 2;
+   }
+   return boost::math::test::report_errors();
+}
diff --git a/test/string_data.ipp b/test/string_data.ipp
new file mode 100644
index 0000000000..10cae8953c
--- /dev/null
+++ b/test/string_data.ipp
@@ -0,0 +1,4765 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2011 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+{{
+    "1e+08",
+    "1.e+08",
+    "+1e+08",
+    "1.2e+08",
+    "+1.2e+08",
+    "1.2e+08",
+    "123456789.0",
+    "123456789.0",
+    "+123456789.0",
+    "1.2e+08",
+    "1.2e+08",
+    "+1.2e+08",
+    "1.23e+08",
+    "+1.23e+08",
+    "1.23e+08",
+    "123456789.00",
+    "123456789.00",
+    "+123456789.00",
+    "1.23e+08",
+    "1.23e+08",
+    "+1.23e+08",
+    "1.235e+08",
+    "+1.235e+08",
+    "1.235e+08",
+    "123456789.000",
+    "123456789.000",
+    "+123456789.000",
+    "1.235e+08",
+    "1.235e+08",
+    "+1.235e+08",
+    "1.2346e+08",
+    "+1.2346e+08",
+    "1.2346e+08",
+    "123456789.0000",
+    "123456789.0000",
+    "+123456789.0000",
+    "1.2346e+08",
+    "1.2346e+08",
+    "+1.2346e+08",
+    "1.23457e+08",
+    "+1.23457e+08",
+    "1.23457e+08",
+    "123456789.00000",
+    "123456789.00000",
+    "+123456789.00000",
+    "1.23457e+08",
+    "1.23457e+08",
+    "+1.23457e+08",
+    "1.234568e+08",
+    "+1.234568e+08",
+    "1.234568e+08",
+    "123456789.000000",
+    "123456789.000000",
+    "+123456789.000000",
+    "1.234568e+08",
+    "1.234568e+08",
+    "+1.234568e+08",
+    "1.2345679e+08",
+    "+1.2345679e+08",
+    "1.2345679e+08",
+    "123456789.0000000",
+    "123456789.0000000",
+    "+123456789.0000000",
+    "1.2345679e+08",
+    "1.2345679e+08",
+    "+1.2345679e+08",
+    "1.23456789e+08",
+    "+1.23456789e+08",
+    "1.23456789e+08",
+    "123456789.00000000",
+    "123456789.00000000",
+    "+123456789.00000000",
+    "123456789",
+    "123456789.",
+    "+123456789",
+    "1.234567890e+08",
+    "+1.234567890e+08",
+    "1.234567890e+08",
+    "123456789.000000000",
+    "123456789.000000000",
+    "+123456789.000000000",
+    "123456789",
+    "123456789.0",
+    "+123456789",
+    "1.2345678900e+08",
+    "+1.2345678900e+08",
+    "1.2345678900e+08",
+    "123456789.0000000000",
+    "123456789.0000000000",
+    "+123456789.0000000000",
+    "123456789",
+    "123456789.00",
+    "+123456789",
+    "1.23456789000e+08",
+    "+1.23456789000e+08",
+    "1.23456789000e+08",
+    "123456789.00000000000",
+    "123456789.00000000000",
+    "+123456789.00000000000",
+    "123456789",
+    "123456789.000",
+    "+123456789",
+    "1.234567890000e+08",
+    "+1.234567890000e+08",
+    "1.234567890000e+08",
+    "123456789.000000000000",
+    "123456789.000000000000",
+    "+123456789.000000000000",
+    "123456789",
+    "123456789.0000",
+    "+123456789",
+    "1.2345678900000e+08",
+    "+1.2345678900000e+08",
+    "1.2345678900000e+08",
+    "123456789.0000000000000",
+    "123456789.0000000000000",
+    "+123456789.0000000000000",
+}},
+    {{
+        "-1e+08",
+        "-1.e+08",
+        "-1e+08",
+        "-1.2e+08",
+        "-1.2e+08",
+        "-1.2e+08",
+        "-123456789.0",
+        "-123456789.0",
+        "-123456789.0",
+        "-1.2e+08",
+        "-1.2e+08",
+        "-1.2e+08",
+        "-1.23e+08",
+        "-1.23e+08",
+        "-1.23e+08",
+        "-123456789.00",
+        "-123456789.00",
+        "-123456789.00",
+        "-1.23e+08",
+        "-1.23e+08",
+        "-1.23e+08",
+        "-1.235e+08",
+        "-1.235e+08",
+        "-1.235e+08",
+        "-123456789.000",
+        "-123456789.000",
+        "-123456789.000",
+        "-1.235e+08",
+        "-1.235e+08",
+        "-1.235e+08",
+        "-1.2346e+08",
+        "-1.2346e+08",
+        "-1.2346e+08",
+        "-123456789.0000",
+        "-123456789.0000",
+        "-123456789.0000",
+        "-1.2346e+08",
+        "-1.2346e+08",
+        "-1.2346e+08",
+        "-1.23457e+08",
+        "-1.23457e+08",
+        "-1.23457e+08",
+        "-123456789.00000",
+        "-123456789.00000",
+        "-123456789.00000",
+        "-1.23457e+08",
+        "-1.23457e+08",
+        "-1.23457e+08",
+        "-1.234568e+08",
+        "-1.234568e+08",
+        "-1.234568e+08",
+        "-123456789.000000",
+        "-123456789.000000",
+        "-123456789.000000",
+        "-1.234568e+08",
+        "-1.234568e+08",
+        "-1.234568e+08",
+        "-1.2345679e+08",
+        "-1.2345679e+08",
+        "-1.2345679e+08",
+        "-123456789.0000000",
+        "-123456789.0000000",
+        "-123456789.0000000",
+        "-1.2345679e+08",
+        "-1.2345679e+08",
+        "-1.2345679e+08",
+        "-1.23456789e+08",
+        "-1.23456789e+08",
+        "-1.23456789e+08",
+        "-123456789.00000000",
+        "-123456789.00000000",
+        "-123456789.00000000",
+        "-123456789",
+        "-123456789.",
+        "-123456789",
+        "-1.234567890e+08",
+        "-1.234567890e+08",
+        "-1.234567890e+08",
+        "-123456789.000000000",
+        "-123456789.000000000",
+        "-123456789.000000000",
+        "-123456789",
+        "-123456789.0",
+        "-123456789",
+        "-1.2345678900e+08",
+        "-1.2345678900e+08",
+        "-1.2345678900e+08",
+        "-123456789.0000000000",
+        "-123456789.0000000000",
+        "-123456789.0000000000",
+        "-123456789",
+        "-123456789.00",
+        "-123456789",
+        "-1.23456789000e+08",
+        "-1.23456789000e+08",
+        "-1.23456789000e+08",
+        "-123456789.00000000000",
+        "-123456789.00000000000",
+        "-123456789.00000000000",
+        "-123456789",
+        "-123456789.000",
+        "-123456789",
+        "-1.234567890000e+08",
+        "-1.234567890000e+08",
+        "-1.234567890000e+08",
+        "-123456789.000000000000",
+        "-123456789.000000000000",
+        "-123456789.000000000000",
+        "-123456789",
+        "-123456789.0000",
+        "-123456789",
+        "-1.2345678900000e+08",
+        "-1.2345678900000e+08",
+        "-1.2345678900000e+08",
+        "-123456789.0000000000000",
+        "-123456789.0000000000000",
+        "-123456789.0000000000000",
+    }},
+    {{
+        "2e+07",
+        "2.e+07",
+        "+2e+07",
+        "1.5e+07",
+        "+1.5e+07",
+        "1.5e+07",
+        "15432098.6",
+        "15432098.6",
+        "+15432098.6",
+        "1.5e+07",
+        "1.5e+07",
+        "+1.5e+07",
+        "1.54e+07",
+        "+1.54e+07",
+        "1.54e+07",
+        "15432098.62",
+        "15432098.62",
+        "+15432098.62",
+        "1.54e+07",
+        "1.54e+07",
+        "+1.54e+07",
+        "1.543e+07",
+        "+1.543e+07",
+        "1.543e+07",
+        "15432098.625",
+        "15432098.625",
+        "+15432098.625",
+        "1.543e+07",
+        "1.543e+07",
+        "+1.543e+07",
+        "1.5432e+07",
+        "+1.5432e+07",
+        "1.5432e+07",
+        "15432098.6250",
+        "15432098.6250",
+        "+15432098.6250",
+        "1.5432e+07",
+        "1.5432e+07",
+        "+1.5432e+07",
+        "1.54321e+07",
+        "+1.54321e+07",
+        "1.54321e+07",
+        "15432098.62500",
+        "15432098.62500",
+        "+15432098.62500",
+        "1.54321e+07",
+        "1.54321e+07",
+        "+1.54321e+07",
+        "1.543210e+07",
+        "+1.543210e+07",
+        "1.543210e+07",
+        "15432098.625000",
+        "15432098.625000",
+        "+15432098.625000",
+        "1.54321e+07",
+        "1.543210e+07",
+        "+1.54321e+07",
+        "1.5432099e+07",
+        "+1.5432099e+07",
+        "1.5432099e+07",
+        "15432098.6250000",
+        "15432098.6250000",
+        "+15432098.6250000",
+        "15432099",
+        "15432099.",
+        "+15432099",
+        "1.54320986e+07",
+        "+1.54320986e+07",
+        "1.54320986e+07",
+        "15432098.62500000",
+        "15432098.62500000",
+        "+15432098.62500000",
+        "15432098.6",
+        "15432098.6",
+        "+15432098.6",
+        "1.543209862e+07",
+        "+1.543209862e+07",
+        "1.543209862e+07",
+        "15432098.625000000",
+        "15432098.625000000",
+        "+15432098.625000000",
+        "15432098.62",
+        "15432098.62",
+        "+15432098.62",
+        "1.5432098625e+07",
+        "+1.5432098625e+07",
+        "1.5432098625e+07",
+        "15432098.6250000000",
+        "15432098.6250000000",
+        "+15432098.6250000000",
+        "15432098.625",
+        "15432098.625",
+        "+15432098.625",
+        "1.54320986250e+07",
+        "+1.54320986250e+07",
+        "1.54320986250e+07",
+        "15432098.62500000000",
+        "15432098.62500000000",
+        "+15432098.62500000000",
+        "15432098.625",
+        "15432098.6250",
+        "+15432098.625",
+        "1.543209862500e+07",
+        "+1.543209862500e+07",
+        "1.543209862500e+07",
+        "15432098.625000000000",
+        "15432098.625000000000",
+        "+15432098.625000000000",
+        "15432098.625",
+        "15432098.62500",
+        "+15432098.625",
+        "1.5432098625000e+07",
+        "+1.5432098625000e+07",
+        "1.5432098625000e+07",
+        "15432098.6250000000000",
+        "15432098.6250000000000",
+        "+15432098.6250000000000",
+    }},
+    {{
+        "-2e+07",
+        "-2.e+07",
+        "-2e+07",
+        "-1.5e+07",
+        "-1.5e+07",
+        "-1.5e+07",
+        "-15432098.6",
+        "-15432098.6",
+        "-15432098.6",
+        "-1.5e+07",
+        "-1.5e+07",
+        "-1.5e+07",
+        "-1.54e+07",
+        "-1.54e+07",
+        "-1.54e+07",
+        "-15432098.62",
+        "-15432098.62",
+        "-15432098.62",
+        "-1.54e+07",
+        "-1.54e+07",
+        "-1.54e+07",
+        "-1.543e+07",
+        "-1.543e+07",
+        "-1.543e+07",
+        "-15432098.625",
+        "-15432098.625",
+        "-15432098.625",
+        "-1.543e+07",
+        "-1.543e+07",
+        "-1.543e+07",
+        "-1.5432e+07",
+        "-1.5432e+07",
+        "-1.5432e+07",
+        "-15432098.6250",
+        "-15432098.6250",
+        "-15432098.6250",
+        "-1.5432e+07",
+        "-1.5432e+07",
+        "-1.5432e+07",
+        "-1.54321e+07",
+        "-1.54321e+07",
+        "-1.54321e+07",
+        "-15432098.62500",
+        "-15432098.62500",
+        "-15432098.62500",
+        "-1.54321e+07",
+        "-1.54321e+07",
+        "-1.54321e+07",
+        "-1.543210e+07",
+        "-1.543210e+07",
+        "-1.543210e+07",
+        "-15432098.625000",
+        "-15432098.625000",
+        "-15432098.625000",
+        "-1.54321e+07",
+        "-1.543210e+07",
+        "-1.54321e+07",
+        "-1.5432099e+07",
+        "-1.5432099e+07",
+        "-1.5432099e+07",
+        "-15432098.6250000",
+        "-15432098.6250000",
+        "-15432098.6250000",
+        "-15432099",
+        "-15432099.",
+        "-15432099",
+        "-1.54320986e+07",
+        "-1.54320986e+07",
+        "-1.54320986e+07",
+        "-15432098.62500000",
+        "-15432098.62500000",
+        "-15432098.62500000",
+        "-15432098.6",
+        "-15432098.6",
+        "-15432098.6",
+        "-1.543209862e+07",
+        "-1.543209862e+07",
+        "-1.543209862e+07",
+        "-15432098.625000000",
+        "-15432098.625000000",
+        "-15432098.625000000",
+        "-15432098.62",
+        "-15432098.62",
+        "-15432098.62",
+        "-1.5432098625e+07",
+        "-1.5432098625e+07",
+        "-1.5432098625e+07",
+        "-15432098.6250000000",
+        "-15432098.6250000000",
+        "-15432098.6250000000",
+        "-15432098.625",
+        "-15432098.625",
+        "-15432098.625",
+        "-1.54320986250e+07",
+        "-1.54320986250e+07",
+        "-1.54320986250e+07",
+        "-15432098.62500000000",
+        "-15432098.62500000000",
+        "-15432098.62500000000",
+        "-15432098.625",
+        "-15432098.6250",
+        "-15432098.625",
+        "-1.543209862500e+07",
+        "-1.543209862500e+07",
+        "-1.543209862500e+07",
+        "-15432098.625000000000",
+        "-15432098.625000000000",
+        "-15432098.625000000000",
+        "-15432098.625",
+        "-15432098.62500",
+        "-15432098.625",
+        "-1.5432098625000e+07",
+        "-1.5432098625000e+07",
+        "-1.5432098625000e+07",
+        "-15432098.6250000000000",
+        "-15432098.6250000000000",
+        "-15432098.6250000000000",
+    }},
+    {{
+        "2e+06",
+        "2.e+06",
+        "+2e+06",
+        "1.9e+06",
+        "+1.9e+06",
+        "1.9e+06",
+        "1929012.3",
+        "1929012.3",
+        "+1929012.3",
+        "1.9e+06",
+        "1.9e+06",
+        "+1.9e+06",
+        "1.93e+06",
+        "+1.93e+06",
+        "1.93e+06",
+        "1929012.33",
+        "1929012.33",
+        "+1929012.33",
+        "1.93e+06",
+        "1.93e+06",
+        "+1.93e+06",
+        "1.929e+06",
+        "+1.929e+06",
+        "1.929e+06",
+        "1929012.328",
+        "1929012.328",
+        "+1929012.328",
+        "1.929e+06",
+        "1.929e+06",
+        "+1.929e+06",
+        "1.9290e+06",
+        "+1.9290e+06",
+        "1.9290e+06",
+        "1929012.3281",
+        "1929012.3281",
+        "+1929012.3281",
+        "1.929e+06",
+        "1.9290e+06",
+        "+1.929e+06",
+        "1.92901e+06",
+        "+1.92901e+06",
+        "1.92901e+06",
+        "1929012.32812",
+        "1929012.32812",
+        "+1929012.32812",
+        "1.92901e+06",
+        "1.92901e+06",
+        "+1.92901e+06",
+        "1.929012e+06",
+        "+1.929012e+06",
+        "1.929012e+06",
+        "1929012.328125",
+        "1929012.328125",
+        "+1929012.328125",
+        "1929012",
+        "1929012.",
+        "+1929012",
+        "1.9290123e+06",
+        "+1.9290123e+06",
+        "1.9290123e+06",
+        "1929012.3281250",
+        "1929012.3281250",
+        "+1929012.3281250",
+        "1929012.3",
+        "1929012.3",
+        "+1929012.3",
+        "1.92901233e+06",
+        "+1.92901233e+06",
+        "1.92901233e+06",
+        "1929012.32812500",
+        "1929012.32812500",
+        "+1929012.32812500",
+        "1929012.33",
+        "1929012.33",
+        "+1929012.33",
+        "1.929012328e+06",
+        "+1.929012328e+06",
+        "1.929012328e+06",
+        "1929012.328125000",
+        "1929012.328125000",
+        "+1929012.328125000",
+        "1929012.328",
+        "1929012.328",
+        "+1929012.328",
+        "1.9290123281e+06",
+        "+1.9290123281e+06",
+        "1.9290123281e+06",
+        "1929012.3281250000",
+        "1929012.3281250000",
+        "+1929012.3281250000",
+        "1929012.3281",
+        "1929012.3281",
+        "+1929012.3281",
+        "1.92901232812e+06",
+        "+1.92901232812e+06",
+        "1.92901232812e+06",
+        "1929012.32812500000",
+        "1929012.32812500000",
+        "+1929012.32812500000",
+        "1929012.32812",
+        "1929012.32812",
+        "+1929012.32812",
+        "1.929012328125e+06",
+        "+1.929012328125e+06",
+        "1.929012328125e+06",
+        "1929012.328125000000",
+        "1929012.328125000000",
+        "+1929012.328125000000",
+        "1929012.328125",
+        "1929012.328125",
+        "+1929012.328125",
+        "1.9290123281250e+06",
+        "+1.9290123281250e+06",
+        "1.9290123281250e+06",
+        "1929012.3281250000000",
+        "1929012.3281250000000",
+        "+1929012.3281250000000",
+    }},
+    {{
+        "-2e+06",
+        "-2.e+06",
+        "-2e+06",
+        "-1.9e+06",
+        "-1.9e+06",
+        "-1.9e+06",
+        "-1929012.3",
+        "-1929012.3",
+        "-1929012.3",
+        "-1.9e+06",
+        "-1.9e+06",
+        "-1.9e+06",
+        "-1.93e+06",
+        "-1.93e+06",
+        "-1.93e+06",
+        "-1929012.33",
+        "-1929012.33",
+        "-1929012.33",
+        "-1.93e+06",
+        "-1.93e+06",
+        "-1.93e+06",
+        "-1.929e+06",
+        "-1.929e+06",
+        "-1.929e+06",
+        "-1929012.328",
+        "-1929012.328",
+        "-1929012.328",
+        "-1.929e+06",
+        "-1.929e+06",
+        "-1.929e+06",
+        "-1.9290e+06",
+        "-1.9290e+06",
+        "-1.9290e+06",
+        "-1929012.3281",
+        "-1929012.3281",
+        "-1929012.3281",
+        "-1.929e+06",
+        "-1.9290e+06",
+        "-1.929e+06",
+        "-1.92901e+06",
+        "-1.92901e+06",
+        "-1.92901e+06",
+        "-1929012.32812",
+        "-1929012.32812",
+        "-1929012.32812",
+        "-1.92901e+06",
+        "-1.92901e+06",
+        "-1.92901e+06",
+        "-1.929012e+06",
+        "-1.929012e+06",
+        "-1.929012e+06",
+        "-1929012.328125",
+        "-1929012.328125",
+        "-1929012.328125",
+        "-1929012",
+        "-1929012.",
+        "-1929012",
+        "-1.9290123e+06",
+        "-1.9290123e+06",
+        "-1.9290123e+06",
+        "-1929012.3281250",
+        "-1929012.3281250",
+        "-1929012.3281250",
+        "-1929012.3",
+        "-1929012.3",
+        "-1929012.3",
+        "-1.92901233e+06",
+        "-1.92901233e+06",
+        "-1.92901233e+06",
+        "-1929012.32812500",
+        "-1929012.32812500",
+        "-1929012.32812500",
+        "-1929012.33",
+        "-1929012.33",
+        "-1929012.33",
+        "-1.929012328e+06",
+        "-1.929012328e+06",
+        "-1.929012328e+06",
+        "-1929012.328125000",
+        "-1929012.328125000",
+        "-1929012.328125000",
+        "-1929012.328",
+        "-1929012.328",
+        "-1929012.328",
+        "-1.9290123281e+06",
+        "-1.9290123281e+06",
+        "-1.9290123281e+06",
+        "-1929012.3281250000",
+        "-1929012.3281250000",
+        "-1929012.3281250000",
+        "-1929012.3281",
+        "-1929012.3281",
+        "-1929012.3281",
+        "-1.92901232812e+06",
+        "-1.92901232812e+06",
+        "-1.92901232812e+06",
+        "-1929012.32812500000",
+        "-1929012.32812500000",
+        "-1929012.32812500000",
+        "-1929012.32812",
+        "-1929012.32812",
+        "-1929012.32812",
+        "-1.929012328125e+06",
+        "-1.929012328125e+06",
+        "-1.929012328125e+06",
+        "-1929012.328125000000",
+        "-1929012.328125000000",
+        "-1929012.328125000000",
+        "-1929012.328125",
+        "-1929012.328125",
+        "-1929012.328125",
+        "-1.9290123281250e+06",
+        "-1.9290123281250e+06",
+        "-1.9290123281250e+06",
+        "-1929012.3281250000000",
+        "-1929012.3281250000000",
+        "-1929012.3281250000000",
+    }},
+    {{
+        "2e+05",
+        "2.e+05",
+        "+2e+05",
+        "2.4e+05",
+        "+2.4e+05",
+        "2.4e+05",
+        "241126.5",
+        "241126.5",
+        "+241126.5",
+        "2.4e+05",
+        "2.4e+05",
+        "+2.4e+05",
+        "2.41e+05",
+        "+2.41e+05",
+        "2.41e+05",
+        "241126.54",
+        "241126.54",
+        "+241126.54",
+        "2.41e+05",
+        "2.41e+05",
+        "+2.41e+05",
+        "2.411e+05",
+        "+2.411e+05",
+        "2.411e+05",
+        "241126.541",
+        "241126.541",
+        "+241126.541",
+        "2.411e+05",
+        "2.411e+05",
+        "+2.411e+05",
+        "2.4113e+05",
+        "+2.4113e+05",
+        "2.4113e+05",
+        "241126.5410",
+        "241126.5410",
+        "+241126.5410",
+        "2.4113e+05",
+        "2.4113e+05",
+        "+2.4113e+05",
+        "2.41127e+05",
+        "+2.41127e+05",
+        "2.41127e+05",
+        "241126.54102",
+        "241126.54102",
+        "+241126.54102",
+        "241127",
+        "241127.",
+        "+241127",
+        "2.411265e+05",
+        "+2.411265e+05",
+        "2.411265e+05",
+        "241126.541016",
+        "241126.541016",
+        "+241126.541016",
+        "241126.5",
+        "241126.5",
+        "+241126.5",
+        "2.4112654e+05",
+        "+2.4112654e+05",
+        "2.4112654e+05",
+        "241126.5410156",
+        "241126.5410156",
+        "+241126.5410156",
+        "241126.54",
+        "241126.54",
+        "+241126.54",
+        "2.41126541e+05",
+        "+2.41126541e+05",
+        "2.41126541e+05",
+        "241126.54101562",
+        "241126.54101562",
+        "+241126.54101562",
+        "241126.541",
+        "241126.541",
+        "+241126.541",
+        "2.411265410e+05",
+        "+2.411265410e+05",
+        "2.411265410e+05",
+        "241126.541015625",
+        "241126.541015625",
+        "+241126.541015625",
+        "241126.541",
+        "241126.5410",
+        "+241126.541",
+        "2.4112654102e+05",
+        "+2.4112654102e+05",
+        "2.4112654102e+05",
+        "241126.5410156250",
+        "241126.5410156250",
+        "+241126.5410156250",
+        "241126.54102",
+        "241126.54102",
+        "+241126.54102",
+        "2.41126541016e+05",
+        "+2.41126541016e+05",
+        "2.41126541016e+05",
+        "241126.54101562500",
+        "241126.54101562500",
+        "+241126.54101562500",
+        "241126.541016",
+        "241126.541016",
+        "+241126.541016",
+        "2.411265410156e+05",
+        "+2.411265410156e+05",
+        "2.411265410156e+05",
+        "241126.541015625000",
+        "241126.541015625000",
+        "+241126.541015625000",
+        "241126.5410156",
+        "241126.5410156",
+        "+241126.5410156",
+        "2.4112654101562e+05",
+        "+2.4112654101562e+05",
+        "2.4112654101562e+05",
+        "241126.5410156250000",
+        "241126.5410156250000",
+        "+241126.5410156250000",
+    }},
+    {{
+        "-2e+05",
+        "-2.e+05",
+        "-2e+05",
+        "-2.4e+05",
+        "-2.4e+05",
+        "-2.4e+05",
+        "-241126.5",
+        "-241126.5",
+        "-241126.5",
+        "-2.4e+05",
+        "-2.4e+05",
+        "-2.4e+05",
+        "-2.41e+05",
+        "-2.41e+05",
+        "-2.41e+05",
+        "-241126.54",
+        "-241126.54",
+        "-241126.54",
+        "-2.41e+05",
+        "-2.41e+05",
+        "-2.41e+05",
+        "-2.411e+05",
+        "-2.411e+05",
+        "-2.411e+05",
+        "-241126.541",
+        "-241126.541",
+        "-241126.541",
+        "-2.411e+05",
+        "-2.411e+05",
+        "-2.411e+05",
+        "-2.4113e+05",
+        "-2.4113e+05",
+        "-2.4113e+05",
+        "-241126.5410",
+        "-241126.5410",
+        "-241126.5410",
+        "-2.4113e+05",
+        "-2.4113e+05",
+        "-2.4113e+05",
+        "-2.41127e+05",
+        "-2.41127e+05",
+        "-2.41127e+05",
+        "-241126.54102",
+        "-241126.54102",
+        "-241126.54102",
+        "-241127",
+        "-241127.",
+        "-241127",
+        "-2.411265e+05",
+        "-2.411265e+05",
+        "-2.411265e+05",
+        "-241126.541016",
+        "-241126.541016",
+        "-241126.541016",
+        "-241126.5",
+        "-241126.5",
+        "-241126.5",
+        "-2.4112654e+05",
+        "-2.4112654e+05",
+        "-2.4112654e+05",
+        "-241126.5410156",
+        "-241126.5410156",
+        "-241126.5410156",
+        "-241126.54",
+        "-241126.54",
+        "-241126.54",
+        "-2.41126541e+05",
+        "-2.41126541e+05",
+        "-2.41126541e+05",
+        "-241126.54101562",
+        "-241126.54101562",
+        "-241126.54101562",
+        "-241126.541",
+        "-241126.541",
+        "-241126.541",
+        "-2.411265410e+05",
+        "-2.411265410e+05",
+        "-2.411265410e+05",
+        "-241126.541015625",
+        "-241126.541015625",
+        "-241126.541015625",
+        "-241126.541",
+        "-241126.5410",
+        "-241126.541",
+        "-2.4112654102e+05",
+        "-2.4112654102e+05",
+        "-2.4112654102e+05",
+        "-241126.5410156250",
+        "-241126.5410156250",
+        "-241126.5410156250",
+        "-241126.54102",
+        "-241126.54102",
+        "-241126.54102",
+        "-2.41126541016e+05",
+        "-2.41126541016e+05",
+        "-2.41126541016e+05",
+        "-241126.54101562500",
+        "-241126.54101562500",
+        "-241126.54101562500",
+        "-241126.541016",
+        "-241126.541016",
+        "-241126.541016",
+        "-2.411265410156e+05",
+        "-2.411265410156e+05",
+        "-2.411265410156e+05",
+        "-241126.541015625000",
+        "-241126.541015625000",
+        "-241126.541015625000",
+        "-241126.5410156",
+        "-241126.5410156",
+        "-241126.5410156",
+        "-2.4112654101562e+05",
+        "-2.4112654101562e+05",
+        "-2.4112654101562e+05",
+        "-241126.5410156250000",
+        "-241126.5410156250000",
+        "-241126.5410156250000",
+    }},
+    {{
+        "3e+04",
+        "3.e+04",
+        "+3e+04",
+        "3.0e+04",
+        "+3.0e+04",
+        "3.0e+04",
+        "30140.8",
+        "30140.8",
+        "+30140.8",
+        "3e+04",
+        "3.0e+04",
+        "+3e+04",
+        "3.01e+04",
+        "+3.01e+04",
+        "3.01e+04",
+        "30140.82",
+        "30140.82",
+        "+30140.82",
+        "3.01e+04",
+        "3.01e+04",
+        "+3.01e+04",
+        "3.014e+04",
+        "+3.014e+04",
+        "3.014e+04",
+        "30140.818",
+        "30140.818",
+        "+30140.818",
+        "3.014e+04",
+        "3.014e+04",
+        "+3.014e+04",
+        "3.0141e+04",
+        "+3.0141e+04",
+        "3.0141e+04",
+        "30140.8176",
+        "30140.8176",
+        "+30140.8176",
+        "30141",
+        "30141.",
+        "+30141",
+        "3.01408e+04",
+        "+3.01408e+04",
+        "3.01408e+04",
+        "30140.81763",
+        "30140.81763",
+        "+30140.81763",
+        "30140.8",
+        "30140.8",
+        "+30140.8",
+        "3.014082e+04",
+        "+3.014082e+04",
+        "3.014082e+04",
+        "30140.817627",
+        "30140.817627",
+        "+30140.817627",
+        "30140.82",
+        "30140.82",
+        "+30140.82",
+        "3.0140818e+04",
+        "+3.0140818e+04",
+        "3.0140818e+04",
+        "30140.8176270",
+        "30140.8176270",
+        "+30140.8176270",
+        "30140.818",
+        "30140.818",
+        "+30140.818",
+        "3.01408176e+04",
+        "+3.01408176e+04",
+        "3.01408176e+04",
+        "30140.81762695",
+        "30140.81762695",
+        "+30140.81762695",
+        "30140.8176",
+        "30140.8176",
+        "+30140.8176",
+        "3.014081763e+04",
+        "+3.014081763e+04",
+        "3.014081763e+04",
+        "30140.817626953",
+        "30140.817626953",
+        "+30140.817626953",
+        "30140.81763",
+        "30140.81763",
+        "+30140.81763",
+        "3.0140817627e+04",
+        "+3.0140817627e+04",
+        "3.0140817627e+04",
+        "30140.8176269531",
+        "30140.8176269531",
+        "+30140.8176269531",
+        "30140.817627",
+        "30140.817627",
+        "+30140.817627",
+        "3.01408176270e+04",
+        "+3.01408176270e+04",
+        "3.01408176270e+04",
+        "30140.81762695312",
+        "30140.81762695312",
+        "+30140.81762695312",
+        "30140.817627",
+        "30140.8176270",
+        "+30140.817627",
+        "3.014081762695e+04",
+        "+3.014081762695e+04",
+        "3.014081762695e+04",
+        "30140.817626953125",
+        "30140.817626953125",
+        "+30140.817626953125",
+        "30140.81762695",
+        "30140.81762695",
+        "+30140.81762695",
+        "3.0140817626953e+04",
+        "+3.0140817626953e+04",
+        "3.0140817626953e+04",
+        "30140.8176269531250",
+        "30140.8176269531250",
+        "+30140.8176269531250",
+    }},
+    {{
+        "-3e+04",
+        "-3.e+04",
+        "-3e+04",
+        "-3.0e+04",
+        "-3.0e+04",
+        "-3.0e+04",
+        "-30140.8",
+        "-30140.8",
+        "-30140.8",
+        "-3e+04",
+        "-3.0e+04",
+        "-3e+04",
+        "-3.01e+04",
+        "-3.01e+04",
+        "-3.01e+04",
+        "-30140.82",
+        "-30140.82",
+        "-30140.82",
+        "-3.01e+04",
+        "-3.01e+04",
+        "-3.01e+04",
+        "-3.014e+04",
+        "-3.014e+04",
+        "-3.014e+04",
+        "-30140.818",
+        "-30140.818",
+        "-30140.818",
+        "-3.014e+04",
+        "-3.014e+04",
+        "-3.014e+04",
+        "-3.0141e+04",
+        "-3.0141e+04",
+        "-3.0141e+04",
+        "-30140.8176",
+        "-30140.8176",
+        "-30140.8176",
+        "-30141",
+        "-30141.",
+        "-30141",
+        "-3.01408e+04",
+        "-3.01408e+04",
+        "-3.01408e+04",
+        "-30140.81763",
+        "-30140.81763",
+        "-30140.81763",
+        "-30140.8",
+        "-30140.8",
+        "-30140.8",
+        "-3.014082e+04",
+        "-3.014082e+04",
+        "-3.014082e+04",
+        "-30140.817627",
+        "-30140.817627",
+        "-30140.817627",
+        "-30140.82",
+        "-30140.82",
+        "-30140.82",
+        "-3.0140818e+04",
+        "-3.0140818e+04",
+        "-3.0140818e+04",
+        "-30140.8176270",
+        "-30140.8176270",
+        "-30140.8176270",
+        "-30140.818",
+        "-30140.818",
+        "-30140.818",
+        "-3.01408176e+04",
+        "-3.01408176e+04",
+        "-3.01408176e+04",
+        "-30140.81762695",
+        "-30140.81762695",
+        "-30140.81762695",
+        "-30140.8176",
+        "-30140.8176",
+        "-30140.8176",
+        "-3.014081763e+04",
+        "-3.014081763e+04",
+        "-3.014081763e+04",
+        "-30140.817626953",
+        "-30140.817626953",
+        "-30140.817626953",
+        "-30140.81763",
+        "-30140.81763",
+        "-30140.81763",
+        "-3.0140817627e+04",
+        "-3.0140817627e+04",
+        "-3.0140817627e+04",
+        "-30140.8176269531",
+        "-30140.8176269531",
+        "-30140.8176269531",
+        "-30140.817627",
+        "-30140.817627",
+        "-30140.817627",
+        "-3.01408176270e+04",
+        "-3.01408176270e+04",
+        "-3.01408176270e+04",
+        "-30140.81762695312",
+        "-30140.81762695312",
+        "-30140.81762695312",
+        "-30140.817627",
+        "-30140.8176270",
+        "-30140.817627",
+        "-3.014081762695e+04",
+        "-3.014081762695e+04",
+        "-3.014081762695e+04",
+        "-30140.817626953125",
+        "-30140.817626953125",
+        "-30140.817626953125",
+        "-30140.81762695",
+        "-30140.81762695",
+        "-30140.81762695",
+        "-3.0140817626953e+04",
+        "-3.0140817626953e+04",
+        "-3.0140817626953e+04",
+        "-30140.8176269531250",
+        "-30140.8176269531250",
+        "-30140.8176269531250",
+    }},
+    {{
+        "4e+03",
+        "4.e+03",
+        "+4e+03",
+        "3.8e+03",
+        "+3.8e+03",
+        "3.8e+03",
+        "3767.6",
+        "3767.6",
+        "+3767.6",
+        "3.8e+03",
+        "3.8e+03",
+        "+3.8e+03",
+        "3.77e+03",
+        "+3.77e+03",
+        "3.77e+03",
+        "3767.60",
+        "3767.60",
+        "+3767.60",
+        "3.77e+03",
+        "3.77e+03",
+        "+3.77e+03",
+        "3.768e+03",
+        "+3.768e+03",
+        "3.768e+03",
+        "3767.602",
+        "3767.602",
+        "+3767.602",
+        "3768",
+        "3768.",
+        "+3768",
+        "3.7676e+03",
+        "+3.7676e+03",
+        "3.7676e+03",
+        "3767.6022",
+        "3767.6022",
+        "+3767.6022",
+        "3767.6",
+        "3767.6",
+        "+3767.6",
+        "3.76760e+03",
+        "+3.76760e+03",
+        "3.76760e+03",
+        "3767.60220",
+        "3767.60220",
+        "+3767.60220",
+        "3767.6",
+        "3767.60",
+        "+3767.6",
+        "3.767602e+03",
+        "+3.767602e+03",
+        "3.767602e+03",
+        "3767.602203",
+        "3767.602203",
+        "+3767.602203",
+        "3767.602",
+        "3767.602",
+        "+3767.602",
+        "3.7676022e+03",
+        "+3.7676022e+03",
+        "3.7676022e+03",
+        "3767.6022034",
+        "3767.6022034",
+        "+3767.6022034",
+        "3767.6022",
+        "3767.6022",
+        "+3767.6022",
+        "3.76760220e+03",
+        "+3.76760220e+03",
+        "3.76760220e+03",
+        "3767.60220337",
+        "3767.60220337",
+        "+3767.60220337",
+        "3767.6022",
+        "3767.60220",
+        "+3767.6022",
+        "3.767602203e+03",
+        "+3.767602203e+03",
+        "3.767602203e+03",
+        "3767.602203369",
+        "3767.602203369",
+        "+3767.602203369",
+        "3767.602203",
+        "3767.602203",
+        "+3767.602203",
+        "3.7676022034e+03",
+        "+3.7676022034e+03",
+        "3.7676022034e+03",
+        "3767.6022033691",
+        "3767.6022033691",
+        "+3767.6022033691",
+        "3767.6022034",
+        "3767.6022034",
+        "+3767.6022034",
+        "3.76760220337e+03",
+        "+3.76760220337e+03",
+        "3.76760220337e+03",
+        "3767.60220336914",
+        "3767.60220336914",
+        "+3767.60220336914",
+        "3767.60220337",
+        "3767.60220337",
+        "+3767.60220337",
+        "3.767602203369e+03",
+        "+3.767602203369e+03",
+        "3.767602203369e+03",
+        "3767.602203369141",
+        "3767.602203369141",
+        "+3767.602203369141",
+        "3767.602203369",
+        "3767.602203369",
+        "+3767.602203369",
+        "3.7676022033691e+03",
+        "+3.7676022033691e+03",
+        "3.7676022033691e+03",
+        "3767.6022033691406",
+        "3767.6022033691406",
+        "+3767.6022033691406",
+    }},
+    {{
+        "-4e+03",
+        "-4.e+03",
+        "-4e+03",
+        "-3.8e+03",
+        "-3.8e+03",
+        "-3.8e+03",
+        "-3767.6",
+        "-3767.6",
+        "-3767.6",
+        "-3.8e+03",
+        "-3.8e+03",
+        "-3.8e+03",
+        "-3.77e+03",
+        "-3.77e+03",
+        "-3.77e+03",
+        "-3767.60",
+        "-3767.60",
+        "-3767.60",
+        "-3.77e+03",
+        "-3.77e+03",
+        "-3.77e+03",
+        "-3.768e+03",
+        "-3.768e+03",
+        "-3.768e+03",
+        "-3767.602",
+        "-3767.602",
+        "-3767.602",
+        "-3768",
+        "-3768.",
+        "-3768",
+        "-3.7676e+03",
+        "-3.7676e+03",
+        "-3.7676e+03",
+        "-3767.6022",
+        "-3767.6022",
+        "-3767.6022",
+        "-3767.6",
+        "-3767.6",
+        "-3767.6",
+        "-3.76760e+03",
+        "-3.76760e+03",
+        "-3.76760e+03",
+        "-3767.60220",
+        "-3767.60220",
+        "-3767.60220",
+        "-3767.6",
+        "-3767.60",
+        "-3767.6",
+        "-3.767602e+03",
+        "-3.767602e+03",
+        "-3.767602e+03",
+        "-3767.602203",
+        "-3767.602203",
+        "-3767.602203",
+        "-3767.602",
+        "-3767.602",
+        "-3767.602",
+        "-3.7676022e+03",
+        "-3.7676022e+03",
+        "-3.7676022e+03",
+        "-3767.6022034",
+        "-3767.6022034",
+        "-3767.6022034",
+        "-3767.6022",
+        "-3767.6022",
+        "-3767.6022",
+        "-3.76760220e+03",
+        "-3.76760220e+03",
+        "-3.76760220e+03",
+        "-3767.60220337",
+        "-3767.60220337",
+        "-3767.60220337",
+        "-3767.6022",
+        "-3767.60220",
+        "-3767.6022",
+        "-3.767602203e+03",
+        "-3.767602203e+03",
+        "-3.767602203e+03",
+        "-3767.602203369",
+        "-3767.602203369",
+        "-3767.602203369",
+        "-3767.602203",
+        "-3767.602203",
+        "-3767.602203",
+        "-3.7676022034e+03",
+        "-3.7676022034e+03",
+        "-3.7676022034e+03",
+        "-3767.6022033691",
+        "-3767.6022033691",
+        "-3767.6022033691",
+        "-3767.6022034",
+        "-3767.6022034",
+        "-3767.6022034",
+        "-3.76760220337e+03",
+        "-3.76760220337e+03",
+        "-3.76760220337e+03",
+        "-3767.60220336914",
+        "-3767.60220336914",
+        "-3767.60220336914",
+        "-3767.60220337",
+        "-3767.60220337",
+        "-3767.60220337",
+        "-3.767602203369e+03",
+        "-3.767602203369e+03",
+        "-3.767602203369e+03",
+        "-3767.602203369141",
+        "-3767.602203369141",
+        "-3767.602203369141",
+        "-3767.602203369",
+        "-3767.602203369",
+        "-3767.602203369",
+        "-3.7676022033691e+03",
+        "-3.7676022033691e+03",
+        "-3.7676022033691e+03",
+        "-3767.6022033691406",
+        "-3767.6022033691406",
+        "-3767.6022033691406",
+    }},
+    {{
+        "5e+02",
+        "5.e+02",
+        "+5e+02",
+        "4.7e+02",
+        "+4.7e+02",
+        "4.7e+02",
+        "471.0",
+        "471.0",
+        "+471.0",
+        "4.7e+02",
+        "4.7e+02",
+        "+4.7e+02",
+        "4.71e+02",
+        "+4.71e+02",
+        "4.71e+02",
+        "470.95",
+        "470.95",
+        "+470.95",
+        "471",
+        "471.",
+        "+471",
+        "4.710e+02",
+        "+4.710e+02",
+        "4.710e+02",
+        "470.950",
+        "470.950",
+        "+470.950",
+        "471",
+        "471.0",
+        "+471",
+        "4.7095e+02",
+        "+4.7095e+02",
+        "4.7095e+02",
+        "470.9503",
+        "470.9503",
+        "+470.9503",
+        "470.95",
+        "470.95",
+        "+470.95",
+        "4.70950e+02",
+        "+4.70950e+02",
+        "4.70950e+02",
+        "470.95028",
+        "470.95028",
+        "+470.95028",
+        "470.95",
+        "470.950",
+        "+470.95",
+        "4.709503e+02",
+        "+4.709503e+02",
+        "4.709503e+02",
+        "470.950275",
+        "470.950275",
+        "+470.950275",
+        "470.9503",
+        "470.9503",
+        "+470.9503",
+        "4.7095028e+02",
+        "+4.7095028e+02",
+        "4.7095028e+02",
+        "470.9502754",
+        "470.9502754",
+        "+470.9502754",
+        "470.95028",
+        "470.95028",
+        "+470.95028",
+        "4.70950275e+02",
+        "+4.70950275e+02",
+        "4.70950275e+02",
+        "470.95027542",
+        "470.95027542",
+        "+470.95027542",
+        "470.950275",
+        "470.950275",
+        "+470.950275",
+        "4.709502754e+02",
+        "+4.709502754e+02",
+        "4.709502754e+02",
+        "470.950275421",
+        "470.950275421",
+        "+470.950275421",
+        "470.9502754",
+        "470.9502754",
+        "+470.9502754",
+        "4.7095027542e+02",
+        "+4.7095027542e+02",
+        "4.7095027542e+02",
+        "470.9502754211",
+        "470.9502754211",
+        "+470.9502754211",
+        "470.95027542",
+        "470.95027542",
+        "+470.95027542",
+        "4.70950275421e+02",
+        "+4.70950275421e+02",
+        "4.70950275421e+02",
+        "470.95027542114",
+        "470.95027542114",
+        "+470.95027542114",
+        "470.950275421",
+        "470.950275421",
+        "+470.950275421",
+        "4.709502754211e+02",
+        "+4.709502754211e+02",
+        "4.709502754211e+02",
+        "470.950275421143",
+        "470.950275421143",
+        "+470.950275421143",
+        "470.9502754211",
+        "470.9502754211",
+        "+470.9502754211",
+        "4.7095027542114e+02",
+        "+4.7095027542114e+02",
+        "4.7095027542114e+02",
+        "470.9502754211426",
+        "470.9502754211426",
+        "+470.9502754211426",
+    }},
+    {{
+        "-5e+02",
+        "-5.e+02",
+        "-5e+02",
+        "-4.7e+02",
+        "-4.7e+02",
+        "-4.7e+02",
+        "-471.0",
+        "-471.0",
+        "-471.0",
+        "-4.7e+02",
+        "-4.7e+02",
+        "-4.7e+02",
+        "-4.71e+02",
+        "-4.71e+02",
+        "-4.71e+02",
+        "-470.95",
+        "-470.95",
+        "-470.95",
+        "-471",
+        "-471.",
+        "-471",
+        "-4.710e+02",
+        "-4.710e+02",
+        "-4.710e+02",
+        "-470.950",
+        "-470.950",
+        "-470.950",
+        "-471",
+        "-471.0",
+        "-471",
+        "-4.7095e+02",
+        "-4.7095e+02",
+        "-4.7095e+02",
+        "-470.9503",
+        "-470.9503",
+        "-470.9503",
+        "-470.95",
+        "-470.95",
+        "-470.95",
+        "-4.70950e+02",
+        "-4.70950e+02",
+        "-4.70950e+02",
+        "-470.95028",
+        "-470.95028",
+        "-470.95028",
+        "-470.95",
+        "-470.950",
+        "-470.95",
+        "-4.709503e+02",
+        "-4.709503e+02",
+        "-4.709503e+02",
+        "-470.950275",
+        "-470.950275",
+        "-470.950275",
+        "-470.9503",
+        "-470.9503",
+        "-470.9503",
+        "-4.7095028e+02",
+        "-4.7095028e+02",
+        "-4.7095028e+02",
+        "-470.9502754",
+        "-470.9502754",
+        "-470.9502754",
+        "-470.95028",
+        "-470.95028",
+        "-470.95028",
+        "-4.70950275e+02",
+        "-4.70950275e+02",
+        "-4.70950275e+02",
+        "-470.95027542",
+        "-470.95027542",
+        "-470.95027542",
+        "-470.950275",
+        "-470.950275",
+        "-470.950275",
+        "-4.709502754e+02",
+        "-4.709502754e+02",
+        "-4.709502754e+02",
+        "-470.950275421",
+        "-470.950275421",
+        "-470.950275421",
+        "-470.9502754",
+        "-470.9502754",
+        "-470.9502754",
+        "-4.7095027542e+02",
+        "-4.7095027542e+02",
+        "-4.7095027542e+02",
+        "-470.9502754211",
+        "-470.9502754211",
+        "-470.9502754211",
+        "-470.95027542",
+        "-470.95027542",
+        "-470.95027542",
+        "-4.70950275421e+02",
+        "-4.70950275421e+02",
+        "-4.70950275421e+02",
+        "-470.95027542114",
+        "-470.95027542114",
+        "-470.95027542114",
+        "-470.950275421",
+        "-470.950275421",
+        "-470.950275421",
+        "-4.709502754211e+02",
+        "-4.709502754211e+02",
+        "-4.709502754211e+02",
+        "-470.950275421143",
+        "-470.950275421143",
+        "-470.950275421143",
+        "-470.9502754211",
+        "-470.9502754211",
+        "-470.9502754211",
+        "-4.7095027542114e+02",
+        "-4.7095027542114e+02",
+        "-4.7095027542114e+02",
+        "-470.9502754211426",
+        "-470.9502754211426",
+        "-470.9502754211426",
+    }},
+    {{
+        "6e+01",
+        "6.e+01",
+        "+6e+01",
+        "5.9e+01",
+        "+5.9e+01",
+        "5.9e+01",
+        "58.9",
+        "58.9",
+        "+58.9",
+        "59",
+        "59.",
+        "+59",
+        "5.89e+01",
+        "+5.89e+01",
+        "5.89e+01",
+        "58.87",
+        "58.87",
+        "+58.87",
+        "58.9",
+        "58.9",
+        "+58.9",
+        "5.887e+01",
+        "+5.887e+01",
+        "5.887e+01",
+        "58.869",
+        "58.869",
+        "+58.869",
+        "58.87",
+        "58.87",
+        "+58.87",
+        "5.8869e+01",
+        "+5.8869e+01",
+        "5.8869e+01",
+        "58.8688",
+        "58.8688",
+        "+58.8688",
+        "58.869",
+        "58.869",
+        "+58.869",
+        "5.88688e+01",
+        "+5.88688e+01",
+        "5.88688e+01",
+        "58.86878",
+        "58.86878",
+        "+58.86878",
+        "58.8688",
+        "58.8688",
+        "+58.8688",
+        "5.886878e+01",
+        "+5.886878e+01",
+        "5.886878e+01",
+        "58.868784",
+        "58.868784",
+        "+58.868784",
+        "58.86878",
+        "58.86878",
+        "+58.86878",
+        "5.8868784e+01",
+        "+5.8868784e+01",
+        "5.8868784e+01",
+        "58.8687844",
+        "58.8687844",
+        "+58.8687844",
+        "58.868784",
+        "58.868784",
+        "+58.868784",
+        "5.88687844e+01",
+        "+5.88687844e+01",
+        "5.88687844e+01",
+        "58.86878443",
+        "58.86878443",
+        "+58.86878443",
+        "58.8687844",
+        "58.8687844",
+        "+58.8687844",
+        "5.886878443e+01",
+        "+5.886878443e+01",
+        "5.886878443e+01",
+        "58.868784428",
+        "58.868784428",
+        "+58.868784428",
+        "58.86878443",
+        "58.86878443",
+        "+58.86878443",
+        "5.8868784428e+01",
+        "+5.8868784428e+01",
+        "5.8868784428e+01",
+        "58.8687844276",
+        "58.8687844276",
+        "+58.8687844276",
+        "58.868784428",
+        "58.868784428",
+        "+58.868784428",
+        "5.88687844276e+01",
+        "+5.88687844276e+01",
+        "5.88687844276e+01",
+        "58.86878442764",
+        "58.86878442764",
+        "+58.86878442764",
+        "58.8687844276",
+        "58.8687844276",
+        "+58.8687844276",
+        "5.886878442764e+01",
+        "+5.886878442764e+01",
+        "5.886878442764e+01",
+        "58.868784427643",
+        "58.868784427643",
+        "+58.868784427643",
+        "58.86878442764",
+        "58.86878442764",
+        "+58.86878442764",
+        "5.8868784427643e+01",
+        "+5.8868784427643e+01",
+        "5.8868784427643e+01",
+        "58.8687844276428",
+        "58.8687844276428",
+        "+58.8687844276428",
+    }},
+    {{
+        "-6e+01",
+        "-6.e+01",
+        "-6e+01",
+        "-5.9e+01",
+        "-5.9e+01",
+        "-5.9e+01",
+        "-58.9",
+        "-58.9",
+        "-58.9",
+        "-59",
+        "-59.",
+        "-59",
+        "-5.89e+01",
+        "-5.89e+01",
+        "-5.89e+01",
+        "-58.87",
+        "-58.87",
+        "-58.87",
+        "-58.9",
+        "-58.9",
+        "-58.9",
+        "-5.887e+01",
+        "-5.887e+01",
+        "-5.887e+01",
+        "-58.869",
+        "-58.869",
+        "-58.869",
+        "-58.87",
+        "-58.87",
+        "-58.87",
+        "-5.8869e+01",
+        "-5.8869e+01",
+        "-5.8869e+01",
+        "-58.8688",
+        "-58.8688",
+        "-58.8688",
+        "-58.869",
+        "-58.869",
+        "-58.869",
+        "-5.88688e+01",
+        "-5.88688e+01",
+        "-5.88688e+01",
+        "-58.86878",
+        "-58.86878",
+        "-58.86878",
+        "-58.8688",
+        "-58.8688",
+        "-58.8688",
+        "-5.886878e+01",
+        "-5.886878e+01",
+        "-5.886878e+01",
+        "-58.868784",
+        "-58.868784",
+        "-58.868784",
+        "-58.86878",
+        "-58.86878",
+        "-58.86878",
+        "-5.8868784e+01",
+        "-5.8868784e+01",
+        "-5.8868784e+01",
+        "-58.8687844",
+        "-58.8687844",
+        "-58.8687844",
+        "-58.868784",
+        "-58.868784",
+        "-58.868784",
+        "-5.88687844e+01",
+        "-5.88687844e+01",
+        "-5.88687844e+01",
+        "-58.86878443",
+        "-58.86878443",
+        "-58.86878443",
+        "-58.8687844",
+        "-58.8687844",
+        "-58.8687844",
+        "-5.886878443e+01",
+        "-5.886878443e+01",
+        "-5.886878443e+01",
+        "-58.868784428",
+        "-58.868784428",
+        "-58.868784428",
+        "-58.86878443",
+        "-58.86878443",
+        "-58.86878443",
+        "-5.8868784428e+01",
+        "-5.8868784428e+01",
+        "-5.8868784428e+01",
+        "-58.8687844276",
+        "-58.8687844276",
+        "-58.8687844276",
+        "-58.868784428",
+        "-58.868784428",
+        "-58.868784428",
+        "-5.88687844276e+01",
+        "-5.88687844276e+01",
+        "-5.88687844276e+01",
+        "-58.86878442764",
+        "-58.86878442764",
+        "-58.86878442764",
+        "-58.8687844276",
+        "-58.8687844276",
+        "-58.8687844276",
+        "-5.886878442764e+01",
+        "-5.886878442764e+01",
+        "-5.886878442764e+01",
+        "-58.868784427643",
+        "-58.868784427643",
+        "-58.868784427643",
+        "-58.86878442764",
+        "-58.86878442764",
+        "-58.86878442764",
+        "-5.8868784427643e+01",
+        "-5.8868784427643e+01",
+        "-5.8868784427643e+01",
+        "-58.8687844276428",
+        "-58.8687844276428",
+        "-58.8687844276428",
+    }},
+    {{
+        "7",
+        "7.",
+        "+7",
+        "7.4e+00",
+        "+7.4e+00",
+        "7.4e+00",
+        "7.4",
+        "7.4",
+        "+7.4",
+        "7.4",
+        "7.4",
+        "+7.4",
+        "7.36e+00",
+        "+7.36e+00",
+        "7.36e+00",
+        "7.36",
+        "7.36",
+        "+7.36",
+        "7.36",
+        "7.36",
+        "+7.36",
+        "7.359e+00",
+        "+7.359e+00",
+        "7.359e+00",
+        "7.359",
+        "7.359",
+        "+7.359",
+        "7.359",
+        "7.359",
+        "+7.359",
+        "7.3586e+00",
+        "+7.3586e+00",
+        "7.3586e+00",
+        "7.3586",
+        "7.3586",
+        "+7.3586",
+        "7.3586",
+        "7.3586",
+        "+7.3586",
+        "7.35860e+00",
+        "+7.35860e+00",
+        "7.35860e+00",
+        "7.35860",
+        "7.35860",
+        "+7.35860",
+        "7.3586",
+        "7.35860",
+        "+7.3586",
+        "7.358598e+00",
+        "+7.358598e+00",
+        "7.358598e+00",
+        "7.358598",
+        "7.358598",
+        "+7.358598",
+        "7.358598",
+        "7.358598",
+        "+7.358598",
+        "7.3585981e+00",
+        "+7.3585981e+00",
+        "7.3585981e+00",
+        "7.3585981",
+        "7.3585981",
+        "+7.3585981",
+        "7.3585981",
+        "7.3585981",
+        "+7.3585981",
+        "7.35859805e+00",
+        "+7.35859805e+00",
+        "7.35859805e+00",
+        "7.35859805",
+        "7.35859805",
+        "+7.35859805",
+        "7.35859805",
+        "7.35859805",
+        "+7.35859805",
+        "7.358598053e+00",
+        "+7.358598053e+00",
+        "7.358598053e+00",
+        "7.358598053",
+        "7.358598053",
+        "+7.358598053",
+        "7.358598053",
+        "7.358598053",
+        "+7.358598053",
+        "7.3585980535e+00",
+        "+7.3585980535e+00",
+        "7.3585980535e+00",
+        "7.3585980535",
+        "7.3585980535",
+        "+7.3585980535",
+        "7.3585980535",
+        "7.3585980535",
+        "+7.3585980535",
+        "7.35859805346e+00",
+        "+7.35859805346e+00",
+        "7.35859805346e+00",
+        "7.35859805346",
+        "7.35859805346",
+        "+7.35859805346",
+        "7.35859805346",
+        "7.35859805346",
+        "+7.35859805346",
+        "7.358598053455e+00",
+        "+7.358598053455e+00",
+        "7.358598053455e+00",
+        "7.358598053455",
+        "7.358598053455",
+        "+7.358598053455",
+        "7.358598053455",
+        "7.358598053455",
+        "+7.358598053455",
+        "7.3585980534554e+00",
+        "+7.3585980534554e+00",
+        "7.3585980534554e+00",
+        "7.3585980534554",
+        "7.3585980534554",
+        "+7.3585980534554",
+    }},
+    {{
+        "-7",
+        "-7.",
+        "-7",
+        "-7.4e+00",
+        "-7.4e+00",
+        "-7.4e+00",
+        "-7.4",
+        "-7.4",
+        "-7.4",
+        "-7.4",
+        "-7.4",
+        "-7.4",
+        "-7.36e+00",
+        "-7.36e+00",
+        "-7.36e+00",
+        "-7.36",
+        "-7.36",
+        "-7.36",
+        "-7.36",
+        "-7.36",
+        "-7.36",
+        "-7.359e+00",
+        "-7.359e+00",
+        "-7.359e+00",
+        "-7.359",
+        "-7.359",
+        "-7.359",
+        "-7.359",
+        "-7.359",
+        "-7.359",
+        "-7.3586e+00",
+        "-7.3586e+00",
+        "-7.3586e+00",
+        "-7.3586",
+        "-7.3586",
+        "-7.3586",
+        "-7.3586",
+        "-7.3586",
+        "-7.3586",
+        "-7.35860e+00",
+        "-7.35860e+00",
+        "-7.35860e+00",
+        "-7.35860",
+        "-7.35860",
+        "-7.35860",
+        "-7.3586",
+        "-7.35860",
+        "-7.3586",
+        "-7.358598e+00",
+        "-7.358598e+00",
+        "-7.358598e+00",
+        "-7.358598",
+        "-7.358598",
+        "-7.358598",
+        "-7.358598",
+        "-7.358598",
+        "-7.358598",
+        "-7.3585981e+00",
+        "-7.3585981e+00",
+        "-7.3585981e+00",
+        "-7.3585981",
+        "-7.3585981",
+        "-7.3585981",
+        "-7.3585981",
+        "-7.3585981",
+        "-7.3585981",
+        "-7.35859805e+00",
+        "-7.35859805e+00",
+        "-7.35859805e+00",
+        "-7.35859805",
+        "-7.35859805",
+        "-7.35859805",
+        "-7.35859805",
+        "-7.35859805",
+        "-7.35859805",
+        "-7.358598053e+00",
+        "-7.358598053e+00",
+        "-7.358598053e+00",
+        "-7.358598053",
+        "-7.358598053",
+        "-7.358598053",
+        "-7.358598053",
+        "-7.358598053",
+        "-7.358598053",
+        "-7.3585980535e+00",
+        "-7.3585980535e+00",
+        "-7.3585980535e+00",
+        "-7.3585980535",
+        "-7.3585980535",
+        "-7.3585980535",
+        "-7.3585980535",
+        "-7.3585980535",
+        "-7.3585980535",
+        "-7.35859805346e+00",
+        "-7.35859805346e+00",
+        "-7.35859805346e+00",
+        "-7.35859805346",
+        "-7.35859805346",
+        "-7.35859805346",
+        "-7.35859805346",
+        "-7.35859805346",
+        "-7.35859805346",
+        "-7.358598053455e+00",
+        "-7.358598053455e+00",
+        "-7.358598053455e+00",
+        "-7.358598053455",
+        "-7.358598053455",
+        "-7.358598053455",
+        "-7.358598053455",
+        "-7.358598053455",
+        "-7.358598053455",
+        "-7.3585980534554e+00",
+        "-7.3585980534554e+00",
+        "-7.3585980534554e+00",
+        "-7.3585980534554",
+        "-7.3585980534554",
+        "-7.3585980534554",
+    }},
+    {{
+        "0.9",
+        "0.9",
+        "+0.9",
+        "9.2e-01",
+        "+9.2e-01",
+        "9.2e-01",
+        "0.9",
+        "0.9",
+        "+0.9",
+        "0.92",
+        "0.92",
+        "+0.92",
+        "9.20e-01",
+        "+9.20e-01",
+        "9.20e-01",
+        "0.92",
+        "0.92",
+        "+0.92",
+        "0.92",
+        "0.920",
+        "+0.92",
+        "9.198e-01",
+        "+9.198e-01",
+        "9.198e-01",
+        "0.920",
+        "0.920",
+        "+0.920",
+        "0.9198",
+        "0.9198",
+        "+0.9198",
+        "9.1982e-01",
+        "+9.1982e-01",
+        "9.1982e-01",
+        "0.9198",
+        "0.9198",
+        "+0.9198",
+        "0.91982",
+        "0.91982",
+        "+0.91982",
+        "9.19825e-01",
+        "+9.19825e-01",
+        "9.19825e-01",
+        "0.91982",
+        "0.91982",
+        "+0.91982",
+        "0.919825",
+        "0.919825",
+        "+0.919825",
+        "9.198248e-01",
+        "+9.198248e-01",
+        "9.198248e-01",
+        "0.919825",
+        "0.919825",
+        "+0.919825",
+        "0.9198248",
+        "0.9198248",
+        "+0.9198248",
+        "9.1982476e-01",
+        "+9.1982476e-01",
+        "9.1982476e-01",
+        "0.9198248",
+        "0.9198248",
+        "+0.9198248",
+        "0.91982476",
+        "0.91982476",
+        "+0.91982476",
+        "9.19824757e-01",
+        "+9.19824757e-01",
+        "9.19824757e-01",
+        "0.91982476",
+        "0.91982476",
+        "+0.91982476",
+        "0.919824757",
+        "0.919824757",
+        "+0.919824757",
+        "9.198247567e-01",
+        "+9.198247567e-01",
+        "9.198247567e-01",
+        "0.919824757",
+        "0.919824757",
+        "+0.919824757",
+        "0.9198247567",
+        "0.9198247567",
+        "+0.9198247567",
+        "9.1982475668e-01",
+        "+9.1982475668e-01",
+        "9.1982475668e-01",
+        "0.9198247567",
+        "0.9198247567",
+        "+0.9198247567",
+        "0.91982475668",
+        "0.91982475668",
+        "+0.91982475668",
+        "9.19824756682e-01",
+        "+9.19824756682e-01",
+        "9.19824756682e-01",
+        "0.91982475668",
+        "0.91982475668",
+        "+0.91982475668",
+        "0.919824756682",
+        "0.919824756682",
+        "+0.919824756682",
+        "9.198247566819e-01",
+        "+9.198247566819e-01",
+        "9.198247566819e-01",
+        "0.919824756682",
+        "0.919824756682",
+        "+0.919824756682",
+        "0.9198247566819",
+        "0.9198247566819",
+        "+0.9198247566819",
+        "9.1982475668192e-01",
+        "+9.1982475668192e-01",
+        "9.1982475668192e-01",
+        "0.9198247566819",
+        "0.9198247566819",
+        "+0.9198247566819",
+    }},
+    {{
+        "-0.9",
+        "-0.9",
+        "-0.9",
+        "-9.2e-01",
+        "-9.2e-01",
+        "-9.2e-01",
+        "-0.9",
+        "-0.9",
+        "-0.9",
+        "-0.92",
+        "-0.92",
+        "-0.92",
+        "-9.20e-01",
+        "-9.20e-01",
+        "-9.20e-01",
+        "-0.92",
+        "-0.92",
+        "-0.92",
+        "-0.92",
+        "-0.920",
+        "-0.92",
+        "-9.198e-01",
+        "-9.198e-01",
+        "-9.198e-01",
+        "-0.920",
+        "-0.920",
+        "-0.920",
+        "-0.9198",
+        "-0.9198",
+        "-0.9198",
+        "-9.1982e-01",
+        "-9.1982e-01",
+        "-9.1982e-01",
+        "-0.9198",
+        "-0.9198",
+        "-0.9198",
+        "-0.91982",
+        "-0.91982",
+        "-0.91982",
+        "-9.19825e-01",
+        "-9.19825e-01",
+        "-9.19825e-01",
+        "-0.91982",
+        "-0.91982",
+        "-0.91982",
+        "-0.919825",
+        "-0.919825",
+        "-0.919825",
+        "-9.198248e-01",
+        "-9.198248e-01",
+        "-9.198248e-01",
+        "-0.919825",
+        "-0.919825",
+        "-0.919825",
+        "-0.9198248",
+        "-0.9198248",
+        "-0.9198248",
+        "-9.1982476e-01",
+        "-9.1982476e-01",
+        "-9.1982476e-01",
+        "-0.9198248",
+        "-0.9198248",
+        "-0.9198248",
+        "-0.91982476",
+        "-0.91982476",
+        "-0.91982476",
+        "-9.19824757e-01",
+        "-9.19824757e-01",
+        "-9.19824757e-01",
+        "-0.91982476",
+        "-0.91982476",
+        "-0.91982476",
+        "-0.919824757",
+        "-0.919824757",
+        "-0.919824757",
+        "-9.198247567e-01",
+        "-9.198247567e-01",
+        "-9.198247567e-01",
+        "-0.919824757",
+        "-0.919824757",
+        "-0.919824757",
+        "-0.9198247567",
+        "-0.9198247567",
+        "-0.9198247567",
+        "-9.1982475668e-01",
+        "-9.1982475668e-01",
+        "-9.1982475668e-01",
+        "-0.9198247567",
+        "-0.9198247567",
+        "-0.9198247567",
+        "-0.91982475668",
+        "-0.91982475668",
+        "-0.91982475668",
+        "-9.19824756682e-01",
+        "-9.19824756682e-01",
+        "-9.19824756682e-01",
+        "-0.91982475668",
+        "-0.91982475668",
+        "-0.91982475668",
+        "-0.919824756682",
+        "-0.919824756682",
+        "-0.919824756682",
+        "-9.198247566819e-01",
+        "-9.198247566819e-01",
+        "-9.198247566819e-01",
+        "-0.919824756682",
+        "-0.919824756682",
+        "-0.919824756682",
+        "-0.9198247566819",
+        "-0.9198247566819",
+        "-0.9198247566819",
+        "-9.1982475668192e-01",
+        "-9.1982475668192e-01",
+        "-9.1982475668192e-01",
+        "-0.9198247566819",
+        "-0.9198247566819",
+        "-0.9198247566819",
+    }},
+    {{
+        "0.1",
+        "0.1",
+        "+0.1",
+        "1.1e-01",
+        "+1.1e-01",
+        "1.1e-01",
+        "0.1",
+        "0.1",
+        "+0.1",
+        "0.11",
+        "0.11",
+        "+0.11",
+        "1.15e-01",
+        "+1.15e-01",
+        "1.15e-01",
+        "0.11",
+        "0.11",
+        "+0.11",
+        "0.115",
+        "0.115",
+        "+0.115",
+        "1.150e-01",
+        "+1.150e-01",
+        "1.150e-01",
+        "0.115",
+        "0.115",
+        "+0.115",
+        "0.115",
+        "0.1150",
+        "+0.115",
+        "1.1498e-01",
+        "+1.1498e-01",
+        "1.1498e-01",
+        "0.1150",
+        "0.1150",
+        "+0.1150",
+        "0.11498",
+        "0.11498",
+        "+0.11498",
+        "1.14978e-01",
+        "+1.14978e-01",
+        "1.14978e-01",
+        "0.11498",
+        "0.11498",
+        "+0.11498",
+        "0.114978",
+        "0.114978",
+        "+0.114978",
+        "1.149781e-01",
+        "+1.149781e-01",
+        "1.149781e-01",
+        "0.114978",
+        "0.114978",
+        "+0.114978",
+        "0.1149781",
+        "0.1149781",
+        "+0.1149781",
+        "1.1497809e-01",
+        "+1.1497809e-01",
+        "1.1497809e-01",
+        "0.1149781",
+        "0.1149781",
+        "+0.1149781",
+        "0.11497809",
+        "0.11497809",
+        "+0.11497809",
+        "1.14978095e-01",
+        "+1.14978095e-01",
+        "1.14978095e-01",
+        "0.11497809",
+        "0.11497809",
+        "+0.11497809",
+        "0.114978095",
+        "0.114978095",
+        "+0.114978095",
+        "1.149780946e-01",
+        "+1.149780946e-01",
+        "1.149780946e-01",
+        "0.114978095",
+        "0.114978095",
+        "+0.114978095",
+        "0.1149780946",
+        "0.1149780946",
+        "+0.1149780946",
+        "1.1497809459e-01",
+        "+1.1497809459e-01",
+        "1.1497809459e-01",
+        "0.1149780946",
+        "0.1149780946",
+        "+0.1149780946",
+        "0.11497809459",
+        "0.11497809459",
+        "+0.11497809459",
+        "1.14978094585e-01",
+        "+1.14978094585e-01",
+        "1.14978094585e-01",
+        "0.11497809459",
+        "0.11497809459",
+        "+0.11497809459",
+        "0.114978094585",
+        "0.114978094585",
+        "+0.114978094585",
+        "1.149780945852e-01",
+        "+1.149780945852e-01",
+        "1.149780945852e-01",
+        "0.114978094585",
+        "0.114978094585",
+        "+0.114978094585",
+        "0.1149780945852",
+        "0.1149780945852",
+        "+0.1149780945852",
+        "1.1497809458524e-01",
+        "+1.1497809458524e-01",
+        "1.1497809458524e-01",
+        "0.1149780945852",
+        "0.1149780945852",
+        "+0.1149780945852",
+    }},
+    {{
+        "-0.1",
+        "-0.1",
+        "-0.1",
+        "-1.1e-01",
+        "-1.1e-01",
+        "-1.1e-01",
+        "-0.1",
+        "-0.1",
+        "-0.1",
+        "-0.11",
+        "-0.11",
+        "-0.11",
+        "-1.15e-01",
+        "-1.15e-01",
+        "-1.15e-01",
+        "-0.11",
+        "-0.11",
+        "-0.11",
+        "-0.115",
+        "-0.115",
+        "-0.115",
+        "-1.150e-01",
+        "-1.150e-01",
+        "-1.150e-01",
+        "-0.115",
+        "-0.115",
+        "-0.115",
+        "-0.115",
+        "-0.1150",
+        "-0.115",
+        "-1.1498e-01",
+        "-1.1498e-01",
+        "-1.1498e-01",
+        "-0.1150",
+        "-0.1150",
+        "-0.1150",
+        "-0.11498",
+        "-0.11498",
+        "-0.11498",
+        "-1.14978e-01",
+        "-1.14978e-01",
+        "-1.14978e-01",
+        "-0.11498",
+        "-0.11498",
+        "-0.11498",
+        "-0.114978",
+        "-0.114978",
+        "-0.114978",
+        "-1.149781e-01",
+        "-1.149781e-01",
+        "-1.149781e-01",
+        "-0.114978",
+        "-0.114978",
+        "-0.114978",
+        "-0.1149781",
+        "-0.1149781",
+        "-0.1149781",
+        "-1.1497809e-01",
+        "-1.1497809e-01",
+        "-1.1497809e-01",
+        "-0.1149781",
+        "-0.1149781",
+        "-0.1149781",
+        "-0.11497809",
+        "-0.11497809",
+        "-0.11497809",
+        "-1.14978095e-01",
+        "-1.14978095e-01",
+        "-1.14978095e-01",
+        "-0.11497809",
+        "-0.11497809",
+        "-0.11497809",
+        "-0.114978095",
+        "-0.114978095",
+        "-0.114978095",
+        "-1.149780946e-01",
+        "-1.149780946e-01",
+        "-1.149780946e-01",
+        "-0.114978095",
+        "-0.114978095",
+        "-0.114978095",
+        "-0.1149780946",
+        "-0.1149780946",
+        "-0.1149780946",
+        "-1.1497809459e-01",
+        "-1.1497809459e-01",
+        "-1.1497809459e-01",
+        "-0.1149780946",
+        "-0.1149780946",
+        "-0.1149780946",
+        "-0.11497809459",
+        "-0.11497809459",
+        "-0.11497809459",
+        "-1.14978094585e-01",
+        "-1.14978094585e-01",
+        "-1.14978094585e-01",
+        "-0.11497809459",
+        "-0.11497809459",
+        "-0.11497809459",
+        "-0.114978094585",
+        "-0.114978094585",
+        "-0.114978094585",
+        "-1.149780945852e-01",
+        "-1.149780945852e-01",
+        "-1.149780945852e-01",
+        "-0.114978094585",
+        "-0.114978094585",
+        "-0.114978094585",
+        "-0.1149780945852",
+        "-0.1149780945852",
+        "-0.1149780945852",
+        "-1.1497809458524e-01",
+        "-1.1497809458524e-01",
+        "-1.1497809458524e-01",
+        "-0.1149780945852",
+        "-0.1149780945852",
+        "-0.1149780945852",
+    }},
+    {{
+        "0.01",
+        "0.01",
+        "+0.01",
+        "1.4e-02",
+        "+1.4e-02",
+        "1.4e-02",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "0.014",
+        "0.014",
+        "+0.014",
+        "1.44e-02",
+        "+1.44e-02",
+        "1.44e-02",
+        "0.01",
+        "0.01",
+        "+0.01",
+        "0.0144",
+        "0.0144",
+        "+0.0144",
+        "1.437e-02",
+        "+1.437e-02",
+        "1.437e-02",
+        "0.014",
+        "0.014",
+        "+0.014",
+        "0.01437",
+        "0.01437",
+        "+0.01437",
+        "1.4372e-02",
+        "+1.4372e-02",
+        "1.4372e-02",
+        "0.0144",
+        "0.0144",
+        "+0.0144",
+        "0.014372",
+        "0.014372",
+        "+0.014372",
+        "1.43723e-02",
+        "+1.43723e-02",
+        "1.43723e-02",
+        "0.01437",
+        "0.01437",
+        "+0.01437",
+        "0.0143723",
+        "0.0143723",
+        "+0.0143723",
+        "1.437226e-02",
+        "+1.437226e-02",
+        "1.437226e-02",
+        "0.014372",
+        "0.014372",
+        "+0.014372",
+        "0.01437226",
+        "0.01437226",
+        "+0.01437226",
+        "1.4372262e-02",
+        "+1.4372262e-02",
+        "1.4372262e-02",
+        "0.0143723",
+        "0.0143723",
+        "+0.0143723",
+        "0.014372262",
+        "0.014372262",
+        "+0.014372262",
+        "1.43722618e-02",
+        "+1.43722618e-02",
+        "1.43722618e-02",
+        "0.01437226",
+        "0.01437226",
+        "+0.01437226",
+        "0.0143722618",
+        "0.0143722618",
+        "+0.0143722618",
+        "1.437226182e-02",
+        "+1.437226182e-02",
+        "1.437226182e-02",
+        "0.014372262",
+        "0.014372262",
+        "+0.014372262",
+        "0.01437226182",
+        "0.01437226182",
+        "+0.01437226182",
+        "1.4372261823e-02",
+        "+1.4372261823e-02",
+        "1.4372261823e-02",
+        "0.0143722618",
+        "0.0143722618",
+        "+0.0143722618",
+        "0.014372261823",
+        "0.014372261823",
+        "+0.014372261823",
+        "1.43722618232e-02",
+        "+1.43722618232e-02",
+        "1.43722618232e-02",
+        "0.01437226182",
+        "0.01437226182",
+        "+0.01437226182",
+        "0.0143722618232",
+        "0.0143722618232",
+        "+0.0143722618232",
+        "1.437226182315e-02",
+        "+1.437226182315e-02",
+        "1.437226182315e-02",
+        "0.014372261823",
+        "0.014372261823",
+        "+0.014372261823",
+        "0.01437226182315",
+        "0.01437226182315",
+        "+0.01437226182315",
+        "1.4372261823155e-02",
+        "+1.4372261823155e-02",
+        "1.4372261823155e-02",
+        "0.0143722618232",
+        "0.0143722618232",
+        "+0.0143722618232",
+    }},
+    {{
+        "-0.01",
+        "-0.01",
+        "-0.01",
+        "-1.4e-02",
+        "-1.4e-02",
+        "-1.4e-02",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-0.014",
+        "-0.014",
+        "-0.014",
+        "-1.44e-02",
+        "-1.44e-02",
+        "-1.44e-02",
+        "-0.01",
+        "-0.01",
+        "-0.01",
+        "-0.0144",
+        "-0.0144",
+        "-0.0144",
+        "-1.437e-02",
+        "-1.437e-02",
+        "-1.437e-02",
+        "-0.014",
+        "-0.014",
+        "-0.014",
+        "-0.01437",
+        "-0.01437",
+        "-0.01437",
+        "-1.4372e-02",
+        "-1.4372e-02",
+        "-1.4372e-02",
+        "-0.0144",
+        "-0.0144",
+        "-0.0144",
+        "-0.014372",
+        "-0.014372",
+        "-0.014372",
+        "-1.43723e-02",
+        "-1.43723e-02",
+        "-1.43723e-02",
+        "-0.01437",
+        "-0.01437",
+        "-0.01437",
+        "-0.0143723",
+        "-0.0143723",
+        "-0.0143723",
+        "-1.437226e-02",
+        "-1.437226e-02",
+        "-1.437226e-02",
+        "-0.014372",
+        "-0.014372",
+        "-0.014372",
+        "-0.01437226",
+        "-0.01437226",
+        "-0.01437226",
+        "-1.4372262e-02",
+        "-1.4372262e-02",
+        "-1.4372262e-02",
+        "-0.0143723",
+        "-0.0143723",
+        "-0.0143723",
+        "-0.014372262",
+        "-0.014372262",
+        "-0.014372262",
+        "-1.43722618e-02",
+        "-1.43722618e-02",
+        "-1.43722618e-02",
+        "-0.01437226",
+        "-0.01437226",
+        "-0.01437226",
+        "-0.0143722618",
+        "-0.0143722618",
+        "-0.0143722618",
+        "-1.437226182e-02",
+        "-1.437226182e-02",
+        "-1.437226182e-02",
+        "-0.014372262",
+        "-0.014372262",
+        "-0.014372262",
+        "-0.01437226182",
+        "-0.01437226182",
+        "-0.01437226182",
+        "-1.4372261823e-02",
+        "-1.4372261823e-02",
+        "-1.4372261823e-02",
+        "-0.0143722618",
+        "-0.0143722618",
+        "-0.0143722618",
+        "-0.014372261823",
+        "-0.014372261823",
+        "-0.014372261823",
+        "-1.43722618232e-02",
+        "-1.43722618232e-02",
+        "-1.43722618232e-02",
+        "-0.01437226182",
+        "-0.01437226182",
+        "-0.01437226182",
+        "-0.0143722618232",
+        "-0.0143722618232",
+        "-0.0143722618232",
+        "-1.437226182315e-02",
+        "-1.437226182315e-02",
+        "-1.437226182315e-02",
+        "-0.014372261823",
+        "-0.014372261823",
+        "-0.014372261823",
+        "-0.01437226182315",
+        "-0.01437226182315",
+        "-0.01437226182315",
+        "-1.4372261823155e-02",
+        "-1.4372261823155e-02",
+        "-1.4372261823155e-02",
+        "-0.0143722618232",
+        "-0.0143722618232",
+        "-0.0143722618232",
+    }},
+    {{
+        "0.002",
+        "0.002",
+        "+0.002",
+        "1.8e-03",
+        "+1.8e-03",
+        "1.8e-03",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "0.0018",
+        "0.0018",
+        "+0.0018",
+        "1.80e-03",
+        "+1.80e-03",
+        "1.80e-03",
+        "0.00",
+        "0.00",
+        "+0.00",
+        "0.0018",
+        "0.00180",
+        "+0.0018",
+        "1.797e-03",
+        "+1.797e-03",
+        "1.797e-03",
+        "0.002",
+        "0.002",
+        "+0.002",
+        "0.001797",
+        "0.001797",
+        "+0.001797",
+        "1.7965e-03",
+        "+1.7965e-03",
+        "1.7965e-03",
+        "0.0018",
+        "0.0018",
+        "+0.0018",
+        "0.0017965",
+        "0.0017965",
+        "+0.0017965",
+        "1.79653e-03",
+        "+1.79653e-03",
+        "1.79653e-03",
+        "0.00180",
+        "0.00180",
+        "+0.00180",
+        "0.00179653",
+        "0.00179653",
+        "+0.00179653",
+        "1.796533e-03",
+        "+1.796533e-03",
+        "1.796533e-03",
+        "0.001797",
+        "0.001797",
+        "+0.001797",
+        "0.001796533",
+        "0.001796533",
+        "+0.001796533",
+        "1.7965327e-03",
+        "+1.7965327e-03",
+        "1.7965327e-03",
+        "0.0017965",
+        "0.0017965",
+        "+0.0017965",
+        "0.0017965327",
+        "0.0017965327",
+        "+0.0017965327",
+        "1.79653273e-03",
+        "+1.79653273e-03",
+        "1.79653273e-03",
+        "0.00179653",
+        "0.00179653",
+        "+0.00179653",
+        "0.00179653273",
+        "0.00179653273",
+        "+0.00179653273",
+        "1.796532728e-03",
+        "+1.796532728e-03",
+        "1.796532728e-03",
+        "0.001796533",
+        "0.001796533",
+        "+0.001796533",
+        "0.001796532728",
+        "0.001796532728",
+        "+0.001796532728",
+        "1.7965327279e-03",
+        "+1.7965327279e-03",
+        "1.7965327279e-03",
+        "0.0017965327",
+        "0.0017965327",
+        "+0.0017965327",
+        "0.0017965327279",
+        "0.0017965327279",
+        "+0.0017965327279",
+        "1.79653272789e-03",
+        "+1.79653272789e-03",
+        "1.79653272789e-03",
+        "0.00179653273",
+        "0.00179653273",
+        "+0.00179653273",
+        "0.00179653272789",
+        "0.00179653272789",
+        "+0.00179653272789",
+        "1.796532727894e-03",
+        "+1.796532727894e-03",
+        "1.796532727894e-03",
+        "0.001796532728",
+        "0.001796532728",
+        "+0.001796532728",
+        "0.001796532727894",
+        "0.001796532727894",
+        "+0.001796532727894",
+        "1.7965327278944e-03",
+        "+1.7965327278944e-03",
+        "1.7965327278944e-03",
+        "0.0017965327279",
+        "0.0017965327279",
+        "+0.0017965327279",
+    }},
+    {{
+        "-0.002",
+        "-0.002",
+        "-0.002",
+        "-1.8e-03",
+        "-1.8e-03",
+        "-1.8e-03",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-0.0018",
+        "-0.0018",
+        "-0.0018",
+        "-1.80e-03",
+        "-1.80e-03",
+        "-1.80e-03",
+        "-0.00",
+        "-0.00",
+        "-0.00",
+        "-0.0018",
+        "-0.00180",
+        "-0.0018",
+        "-1.797e-03",
+        "-1.797e-03",
+        "-1.797e-03",
+        "-0.002",
+        "-0.002",
+        "-0.002",
+        "-0.001797",
+        "-0.001797",
+        "-0.001797",
+        "-1.7965e-03",
+        "-1.7965e-03",
+        "-1.7965e-03",
+        "-0.0018",
+        "-0.0018",
+        "-0.0018",
+        "-0.0017965",
+        "-0.0017965",
+        "-0.0017965",
+        "-1.79653e-03",
+        "-1.79653e-03",
+        "-1.79653e-03",
+        "-0.00180",
+        "-0.00180",
+        "-0.00180",
+        "-0.00179653",
+        "-0.00179653",
+        "-0.00179653",
+        "-1.796533e-03",
+        "-1.796533e-03",
+        "-1.796533e-03",
+        "-0.001797",
+        "-0.001797",
+        "-0.001797",
+        "-0.001796533",
+        "-0.001796533",
+        "-0.001796533",
+        "-1.7965327e-03",
+        "-1.7965327e-03",
+        "-1.7965327e-03",
+        "-0.0017965",
+        "-0.0017965",
+        "-0.0017965",
+        "-0.0017965327",
+        "-0.0017965327",
+        "-0.0017965327",
+        "-1.79653273e-03",
+        "-1.79653273e-03",
+        "-1.79653273e-03",
+        "-0.00179653",
+        "-0.00179653",
+        "-0.00179653",
+        "-0.00179653273",
+        "-0.00179653273",
+        "-0.00179653273",
+        "-1.796532728e-03",
+        "-1.796532728e-03",
+        "-1.796532728e-03",
+        "-0.001796533",
+        "-0.001796533",
+        "-0.001796533",
+        "-0.001796532728",
+        "-0.001796532728",
+        "-0.001796532728",
+        "-1.7965327279e-03",
+        "-1.7965327279e-03",
+        "-1.7965327279e-03",
+        "-0.0017965327",
+        "-0.0017965327",
+        "-0.0017965327",
+        "-0.0017965327279",
+        "-0.0017965327279",
+        "-0.0017965327279",
+        "-1.79653272789e-03",
+        "-1.79653272789e-03",
+        "-1.79653272789e-03",
+        "-0.00179653273",
+        "-0.00179653273",
+        "-0.00179653273",
+        "-0.00179653272789",
+        "-0.00179653272789",
+        "-0.00179653272789",
+        "-1.796532727894e-03",
+        "-1.796532727894e-03",
+        "-1.796532727894e-03",
+        "-0.001796532728",
+        "-0.001796532728",
+        "-0.001796532728",
+        "-0.001796532727894",
+        "-0.001796532727894",
+        "-0.001796532727894",
+        "-1.7965327278944e-03",
+        "-1.7965327278944e-03",
+        "-1.7965327278944e-03",
+        "-0.0017965327279",
+        "-0.0017965327279",
+        "-0.0017965327279",
+    }},
+    {{
+        "0.0002",
+        "0.0002",
+        "+0.0002",
+        "2.2e-04",
+        "+2.2e-04",
+        "2.2e-04",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "0.00022",
+        "0.00022",
+        "+0.00022",
+        "2.25e-04",
+        "+2.25e-04",
+        "2.25e-04",
+        "0.00",
+        "0.00",
+        "+0.00",
+        "0.000225",
+        "0.000225",
+        "+0.000225",
+        "2.246e-04",
+        "+2.246e-04",
+        "2.246e-04",
+        "0.000",
+        "0.000",
+        "+0.000",
+        "0.0002246",
+        "0.0002246",
+        "+0.0002246",
+        "2.2457e-04",
+        "+2.2457e-04",
+        "2.2457e-04",
+        "0.0002",
+        "0.0002",
+        "+0.0002",
+        "0.00022457",
+        "0.00022457",
+        "+0.00022457",
+        "2.24567e-04",
+        "+2.24567e-04",
+        "2.24567e-04",
+        "0.00022",
+        "0.00022",
+        "+0.00022",
+        "0.000224567",
+        "0.000224567",
+        "+0.000224567",
+        "2.245666e-04",
+        "+2.245666e-04",
+        "2.245666e-04",
+        "0.000225",
+        "0.000225",
+        "+0.000225",
+        "0.0002245666",
+        "0.0002245666",
+        "+0.0002245666",
+        "2.2456659e-04",
+        "+2.2456659e-04",
+        "2.2456659e-04",
+        "0.0002246",
+        "0.0002246",
+        "+0.0002246",
+        "0.00022456659",
+        "0.00022456659",
+        "+0.00022456659",
+        "2.24566591e-04",
+        "+2.24566591e-04",
+        "2.24566591e-04",
+        "0.00022457",
+        "0.00022457",
+        "+0.00022457",
+        "0.000224566591",
+        "0.000224566591",
+        "+0.000224566591",
+        "2.245665910e-04",
+        "+2.245665910e-04",
+        "2.245665910e-04",
+        "0.000224567",
+        "0.000224567",
+        "+0.000224567",
+        "0.000224566591",
+        "0.0002245665910",
+        "+0.000224566591",
+        "2.2456659099e-04",
+        "+2.2456659099e-04",
+        "2.2456659099e-04",
+        "0.0002245666",
+        "0.0002245666",
+        "+0.0002245666",
+        "0.00022456659099",
+        "0.00022456659099",
+        "+0.00022456659099",
+        "2.24566590987e-04",
+        "+2.24566590987e-04",
+        "2.24566590987e-04",
+        "0.00022456659",
+        "0.00022456659",
+        "+0.00022456659",
+        "0.000224566590987",
+        "0.000224566590987",
+        "+0.000224566590987",
+        "2.245665909868e-04",
+        "+2.245665909868e-04",
+        "2.245665909868e-04",
+        "0.000224566591",
+        "0.000224566591",
+        "+0.000224566591",
+        "0.0002245665909868",
+        "0.0002245665909868",
+        "+0.0002245665909868",
+        "2.2456659098680e-04",
+        "+2.2456659098680e-04",
+        "2.2456659098680e-04",
+        "0.0002245665910",
+        "0.0002245665910",
+        "+0.0002245665910",
+    }},
+    {{
+        "-0.0002",
+        "-0.0002",
+        "-0.0002",
+        "-2.2e-04",
+        "-2.2e-04",
+        "-2.2e-04",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-0.00022",
+        "-0.00022",
+        "-0.00022",
+        "-2.25e-04",
+        "-2.25e-04",
+        "-2.25e-04",
+        "-0.00",
+        "-0.00",
+        "-0.00",
+        "-0.000225",
+        "-0.000225",
+        "-0.000225",
+        "-2.246e-04",
+        "-2.246e-04",
+        "-2.246e-04",
+        "-0.000",
+        "-0.000",
+        "-0.000",
+        "-0.0002246",
+        "-0.0002246",
+        "-0.0002246",
+        "-2.2457e-04",
+        "-2.2457e-04",
+        "-2.2457e-04",
+        "-0.0002",
+        "-0.0002",
+        "-0.0002",
+        "-0.00022457",
+        "-0.00022457",
+        "-0.00022457",
+        "-2.24567e-04",
+        "-2.24567e-04",
+        "-2.24567e-04",
+        "-0.00022",
+        "-0.00022",
+        "-0.00022",
+        "-0.000224567",
+        "-0.000224567",
+        "-0.000224567",
+        "-2.245666e-04",
+        "-2.245666e-04",
+        "-2.245666e-04",
+        "-0.000225",
+        "-0.000225",
+        "-0.000225",
+        "-0.0002245666",
+        "-0.0002245666",
+        "-0.0002245666",
+        "-2.2456659e-04",
+        "-2.2456659e-04",
+        "-2.2456659e-04",
+        "-0.0002246",
+        "-0.0002246",
+        "-0.0002246",
+        "-0.00022456659",
+        "-0.00022456659",
+        "-0.00022456659",
+        "-2.24566591e-04",
+        "-2.24566591e-04",
+        "-2.24566591e-04",
+        "-0.00022457",
+        "-0.00022457",
+        "-0.00022457",
+        "-0.000224566591",
+        "-0.000224566591",
+        "-0.000224566591",
+        "-2.245665910e-04",
+        "-2.245665910e-04",
+        "-2.245665910e-04",
+        "-0.000224567",
+        "-0.000224567",
+        "-0.000224567",
+        "-0.000224566591",
+        "-0.0002245665910",
+        "-0.000224566591",
+        "-2.2456659099e-04",
+        "-2.2456659099e-04",
+        "-2.2456659099e-04",
+        "-0.0002245666",
+        "-0.0002245666",
+        "-0.0002245666",
+        "-0.00022456659099",
+        "-0.00022456659099",
+        "-0.00022456659099",
+        "-2.24566590987e-04",
+        "-2.24566590987e-04",
+        "-2.24566590987e-04",
+        "-0.00022456659",
+        "-0.00022456659",
+        "-0.00022456659",
+        "-0.000224566590987",
+        "-0.000224566590987",
+        "-0.000224566590987",
+        "-2.245665909868e-04",
+        "-2.245665909868e-04",
+        "-2.245665909868e-04",
+        "-0.000224566591",
+        "-0.000224566591",
+        "-0.000224566591",
+        "-0.0002245665909868",
+        "-0.0002245665909868",
+        "-0.0002245665909868",
+        "-2.2456659098680e-04",
+        "-2.2456659098680e-04",
+        "-2.2456659098680e-04",
+        "-0.0002245665910",
+        "-0.0002245665910",
+        "-0.0002245665910",
+    }},
+    {{
+        "3e-05",
+        "3.e-05",
+        "+3e-05",
+        "2.8e-05",
+        "+2.8e-05",
+        "2.8e-05",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "2.8e-05",
+        "2.8e-05",
+        "+2.8e-05",
+        "2.81e-05",
+        "+2.81e-05",
+        "2.81e-05",
+        "0.00",
+        "0.00",
+        "+0.00",
+        "2.81e-05",
+        "2.81e-05",
+        "+2.81e-05",
+        "2.807e-05",
+        "+2.807e-05",
+        "2.807e-05",
+        "0.000",
+        "0.000",
+        "+0.000",
+        "2.807e-05",
+        "2.807e-05",
+        "+2.807e-05",
+        "2.8071e-05",
+        "+2.8071e-05",
+        "2.8071e-05",
+        "0.0000",
+        "0.0000",
+        "+0.0000",
+        "2.8071e-05",
+        "2.8071e-05",
+        "+2.8071e-05",
+        "2.80708e-05",
+        "+2.80708e-05",
+        "2.80708e-05",
+        "0.00003",
+        "0.00003",
+        "+0.00003",
+        "2.80708e-05",
+        "2.80708e-05",
+        "+2.80708e-05",
+        "2.807082e-05",
+        "+2.807082e-05",
+        "2.807082e-05",
+        "0.000028",
+        "0.000028",
+        "+0.000028",
+        "2.807082e-05",
+        "2.807082e-05",
+        "+2.807082e-05",
+        "2.8070824e-05",
+        "+2.8070824e-05",
+        "2.8070824e-05",
+        "0.0000281",
+        "0.0000281",
+        "+0.0000281",
+        "2.8070824e-05",
+        "2.8070824e-05",
+        "+2.8070824e-05",
+        "2.80708239e-05",
+        "+2.80708239e-05",
+        "2.80708239e-05",
+        "0.00002807",
+        "0.00002807",
+        "+0.00002807",
+        "2.80708239e-05",
+        "2.80708239e-05",
+        "+2.80708239e-05",
+        "2.807082387e-05",
+        "+2.807082387e-05",
+        "2.807082387e-05",
+        "0.000028071",
+        "0.000028071",
+        "+0.000028071",
+        "2.807082387e-05",
+        "2.807082387e-05",
+        "+2.807082387e-05",
+        "2.8070823873e-05",
+        "+2.8070823873e-05",
+        "2.8070823873e-05",
+        "0.0000280708",
+        "0.0000280708",
+        "+0.0000280708",
+        "2.8070823873e-05",
+        "2.8070823873e-05",
+        "+2.8070823873e-05",
+        "2.80708238733e-05",
+        "+2.80708238733e-05",
+        "2.80708238733e-05",
+        "0.00002807082",
+        "0.00002807082",
+        "+0.00002807082",
+        "2.80708238733e-05",
+        "2.80708238733e-05",
+        "+2.80708238733e-05",
+        "2.807082387335e-05",
+        "+2.807082387335e-05",
+        "2.807082387335e-05",
+        "0.000028070824",
+        "0.000028070824",
+        "+0.000028070824",
+        "2.807082387335e-05",
+        "2.807082387335e-05",
+        "+2.807082387335e-05",
+        "2.8070823873350e-05",
+        "+2.8070823873350e-05",
+        "2.8070823873350e-05",
+        "0.0000280708239",
+        "0.0000280708239",
+        "+0.0000280708239",
+    }},
+    {{
+        "-3e-05",
+        "-3.e-05",
+        "-3e-05",
+        "-2.8e-05",
+        "-2.8e-05",
+        "-2.8e-05",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-2.8e-05",
+        "-2.8e-05",
+        "-2.8e-05",
+        "-2.81e-05",
+        "-2.81e-05",
+        "-2.81e-05",
+        "-0.00",
+        "-0.00",
+        "-0.00",
+        "-2.81e-05",
+        "-2.81e-05",
+        "-2.81e-05",
+        "-2.807e-05",
+        "-2.807e-05",
+        "-2.807e-05",
+        "-0.000",
+        "-0.000",
+        "-0.000",
+        "-2.807e-05",
+        "-2.807e-05",
+        "-2.807e-05",
+        "-2.8071e-05",
+        "-2.8071e-05",
+        "-2.8071e-05",
+        "-0.0000",
+        "-0.0000",
+        "-0.0000",
+        "-2.8071e-05",
+        "-2.8071e-05",
+        "-2.8071e-05",
+        "-2.80708e-05",
+        "-2.80708e-05",
+        "-2.80708e-05",
+        "-0.00003",
+        "-0.00003",
+        "-0.00003",
+        "-2.80708e-05",
+        "-2.80708e-05",
+        "-2.80708e-05",
+        "-2.807082e-05",
+        "-2.807082e-05",
+        "-2.807082e-05",
+        "-0.000028",
+        "-0.000028",
+        "-0.000028",
+        "-2.807082e-05",
+        "-2.807082e-05",
+        "-2.807082e-05",
+        "-2.8070824e-05",
+        "-2.8070824e-05",
+        "-2.8070824e-05",
+        "-0.0000281",
+        "-0.0000281",
+        "-0.0000281",
+        "-2.8070824e-05",
+        "-2.8070824e-05",
+        "-2.8070824e-05",
+        "-2.80708239e-05",
+        "-2.80708239e-05",
+        "-2.80708239e-05",
+        "-0.00002807",
+        "-0.00002807",
+        "-0.00002807",
+        "-2.80708239e-05",
+        "-2.80708239e-05",
+        "-2.80708239e-05",
+        "-2.807082387e-05",
+        "-2.807082387e-05",
+        "-2.807082387e-05",
+        "-0.000028071",
+        "-0.000028071",
+        "-0.000028071",
+        "-2.807082387e-05",
+        "-2.807082387e-05",
+        "-2.807082387e-05",
+        "-2.8070823873e-05",
+        "-2.8070823873e-05",
+        "-2.8070823873e-05",
+        "-0.0000280708",
+        "-0.0000280708",
+        "-0.0000280708",
+        "-2.8070823873e-05",
+        "-2.8070823873e-05",
+        "-2.8070823873e-05",
+        "-2.80708238733e-05",
+        "-2.80708238733e-05",
+        "-2.80708238733e-05",
+        "-0.00002807082",
+        "-0.00002807082",
+        "-0.00002807082",
+        "-2.80708238733e-05",
+        "-2.80708238733e-05",
+        "-2.80708238733e-05",
+        "-2.807082387335e-05",
+        "-2.807082387335e-05",
+        "-2.807082387335e-05",
+        "-0.000028070824",
+        "-0.000028070824",
+        "-0.000028070824",
+        "-2.807082387335e-05",
+        "-2.807082387335e-05",
+        "-2.807082387335e-05",
+        "-2.8070823873350e-05",
+        "-2.8070823873350e-05",
+        "-2.8070823873350e-05",
+        "-0.0000280708239",
+        "-0.0000280708239",
+        "-0.0000280708239",
+    }},
+    {{
+        "4e-06",
+        "4.e-06",
+        "+4e-06",
+        "3.5e-06",
+        "+3.5e-06",
+        "3.5e-06",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "3.5e-06",
+        "3.5e-06",
+        "+3.5e-06",
+        "3.51e-06",
+        "+3.51e-06",
+        "3.51e-06",
+        "0.00",
+        "0.00",
+        "+0.00",
+        "3.51e-06",
+        "3.51e-06",
+        "+3.51e-06",
+        "3.509e-06",
+        "+3.509e-06",
+        "3.509e-06",
+        "0.000",
+        "0.000",
+        "+0.000",
+        "3.509e-06",
+        "3.509e-06",
+        "+3.509e-06",
+        "3.5089e-06",
+        "+3.5089e-06",
+        "3.5089e-06",
+        "0.0000",
+        "0.0000",
+        "+0.0000",
+        "3.5089e-06",
+        "3.5089e-06",
+        "+3.5089e-06",
+        "3.50885e-06",
+        "+3.50885e-06",
+        "3.50885e-06",
+        "0.00000",
+        "0.00000",
+        "+0.00000",
+        "3.50885e-06",
+        "3.50885e-06",
+        "+3.50885e-06",
+        "3.508853e-06",
+        "+3.508853e-06",
+        "3.508853e-06",
+        "0.000004",
+        "0.000004",
+        "+0.000004",
+        "3.508853e-06",
+        "3.508853e-06",
+        "+3.508853e-06",
+        "3.5088530e-06",
+        "+3.5088530e-06",
+        "3.5088530e-06",
+        "0.0000035",
+        "0.0000035",
+        "+0.0000035",
+        "3.508853e-06",
+        "3.5088530e-06",
+        "+3.508853e-06",
+        "3.50885298e-06",
+        "+3.50885298e-06",
+        "3.50885298e-06",
+        "0.00000351",
+        "0.00000351",
+        "+0.00000351",
+        "3.50885298e-06",
+        "3.50885298e-06",
+        "+3.50885298e-06",
+        "3.508852984e-06",
+        "+3.508852984e-06",
+        "3.508852984e-06",
+        "0.000003509",
+        "0.000003509",
+        "+0.000003509",
+        "3.508852984e-06",
+        "3.508852984e-06",
+        "+3.508852984e-06",
+        "3.5088529842e-06",
+        "+3.5088529842e-06",
+        "3.5088529842e-06",
+        "0.0000035089",
+        "0.0000035089",
+        "+0.0000035089",
+        "3.5088529842e-06",
+        "3.5088529842e-06",
+        "+3.5088529842e-06",
+        "3.50885298417e-06",
+        "+3.50885298417e-06",
+        "3.50885298417e-06",
+        "0.00000350885",
+        "0.00000350885",
+        "+0.00000350885",
+        "3.50885298417e-06",
+        "3.50885298417e-06",
+        "+3.50885298417e-06",
+        "3.508852984169e-06",
+        "+3.508852984169e-06",
+        "3.508852984169e-06",
+        "0.000003508853",
+        "0.000003508853",
+        "+0.000003508853",
+        "3.508852984169e-06",
+        "3.508852984169e-06",
+        "+3.508852984169e-06",
+        "3.5088529841687e-06",
+        "+3.5088529841687e-06",
+        "3.5088529841687e-06",
+        "0.0000035088530",
+        "0.0000035088530",
+        "+0.0000035088530",
+    }},
+    {{
+        "-4e-06",
+        "-4.e-06",
+        "-4e-06",
+        "-3.5e-06",
+        "-3.5e-06",
+        "-3.5e-06",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-3.5e-06",
+        "-3.5e-06",
+        "-3.5e-06",
+        "-3.51e-06",
+        "-3.51e-06",
+        "-3.51e-06",
+        "-0.00",
+        "-0.00",
+        "-0.00",
+        "-3.51e-06",
+        "-3.51e-06",
+        "-3.51e-06",
+        "-3.509e-06",
+        "-3.509e-06",
+        "-3.509e-06",
+        "-0.000",
+        "-0.000",
+        "-0.000",
+        "-3.509e-06",
+        "-3.509e-06",
+        "-3.509e-06",
+        "-3.5089e-06",
+        "-3.5089e-06",
+        "-3.5089e-06",
+        "-0.0000",
+        "-0.0000",
+        "-0.0000",
+        "-3.5089e-06",
+        "-3.5089e-06",
+        "-3.5089e-06",
+        "-3.50885e-06",
+        "-3.50885e-06",
+        "-3.50885e-06",
+        "-0.00000",
+        "-0.00000",
+        "-0.00000",
+        "-3.50885e-06",
+        "-3.50885e-06",
+        "-3.50885e-06",
+        "-3.508853e-06",
+        "-3.508853e-06",
+        "-3.508853e-06",
+        "-0.000004",
+        "-0.000004",
+        "-0.000004",
+        "-3.508853e-06",
+        "-3.508853e-06",
+        "-3.508853e-06",
+        "-3.5088530e-06",
+        "-3.5088530e-06",
+        "-3.5088530e-06",
+        "-0.0000035",
+        "-0.0000035",
+        "-0.0000035",
+        "-3.508853e-06",
+        "-3.5088530e-06",
+        "-3.508853e-06",
+        "-3.50885298e-06",
+        "-3.50885298e-06",
+        "-3.50885298e-06",
+        "-0.00000351",
+        "-0.00000351",
+        "-0.00000351",
+        "-3.50885298e-06",
+        "-3.50885298e-06",
+        "-3.50885298e-06",
+        "-3.508852984e-06",
+        "-3.508852984e-06",
+        "-3.508852984e-06",
+        "-0.000003509",
+        "-0.000003509",
+        "-0.000003509",
+        "-3.508852984e-06",
+        "-3.508852984e-06",
+        "-3.508852984e-06",
+        "-3.5088529842e-06",
+        "-3.5088529842e-06",
+        "-3.5088529842e-06",
+        "-0.0000035089",
+        "-0.0000035089",
+        "-0.0000035089",
+        "-3.5088529842e-06",
+        "-3.5088529842e-06",
+        "-3.5088529842e-06",
+        "-3.50885298417e-06",
+        "-3.50885298417e-06",
+        "-3.50885298417e-06",
+        "-0.00000350885",
+        "-0.00000350885",
+        "-0.00000350885",
+        "-3.50885298417e-06",
+        "-3.50885298417e-06",
+        "-3.50885298417e-06",
+        "-3.508852984169e-06",
+        "-3.508852984169e-06",
+        "-3.508852984169e-06",
+        "-0.000003508853",
+        "-0.000003508853",
+        "-0.000003508853",
+        "-3.508852984169e-06",
+        "-3.508852984169e-06",
+        "-3.508852984169e-06",
+        "-3.5088529841687e-06",
+        "-3.5088529841687e-06",
+        "-3.5088529841687e-06",
+        "-0.0000035088530",
+        "-0.0000035088530",
+        "-0.0000035088530",
+    }},
+    {{
+        "4e-07",
+        "4.e-07",
+        "+4e-07",
+        "4.4e-07",
+        "+4.4e-07",
+        "4.4e-07",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "4.4e-07",
+        "4.4e-07",
+        "+4.4e-07",
+        "4.39e-07",
+        "+4.39e-07",
+        "4.39e-07",
+        "0.00",
+        "0.00",
+        "+0.00",
+        "4.39e-07",
+        "4.39e-07",
+        "+4.39e-07",
+        "4.386e-07",
+        "+4.386e-07",
+        "4.386e-07",
+        "0.000",
+        "0.000",
+        "+0.000",
+        "4.386e-07",
+        "4.386e-07",
+        "+4.386e-07",
+        "4.3861e-07",
+        "+4.3861e-07",
+        "4.3861e-07",
+        "0.0000",
+        "0.0000",
+        "+0.0000",
+        "4.3861e-07",
+        "4.3861e-07",
+        "+4.3861e-07",
+        "4.38607e-07",
+        "+4.38607e-07",
+        "4.38607e-07",
+        "0.00000",
+        "0.00000",
+        "+0.00000",
+        "4.38607e-07",
+        "4.38607e-07",
+        "+4.38607e-07",
+        "4.386066e-07",
+        "+4.386066e-07",
+        "4.386066e-07",
+        "0.000000",
+        "0.000000",
+        "+0.000000",
+        "4.386066e-07",
+        "4.386066e-07",
+        "+4.386066e-07",
+        "4.3860662e-07",
+        "+4.3860662e-07",
+        "4.3860662e-07",
+        "0.0000004",
+        "0.0000004",
+        "+0.0000004",
+        "4.3860662e-07",
+        "4.3860662e-07",
+        "+4.3860662e-07",
+        "4.38606623e-07",
+        "+4.38606623e-07",
+        "4.38606623e-07",
+        "0.00000044",
+        "0.00000044",
+        "+0.00000044",
+        "4.38606623e-07",
+        "4.38606623e-07",
+        "+4.38606623e-07",
+        "4.386066230e-07",
+        "+4.386066230e-07",
+        "4.386066230e-07",
+        "0.000000439",
+        "0.000000439",
+        "+0.000000439",
+        "4.38606623e-07",
+        "4.386066230e-07",
+        "+4.38606623e-07",
+        "4.3860662302e-07",
+        "+4.3860662302e-07",
+        "4.3860662302e-07",
+        "0.0000004386",
+        "0.0000004386",
+        "+0.0000004386",
+        "4.3860662302e-07",
+        "4.3860662302e-07",
+        "+4.3860662302e-07",
+        "4.38606623021e-07",
+        "+4.38606623021e-07",
+        "4.38606623021e-07",
+        "0.00000043861",
+        "0.00000043861",
+        "+0.00000043861",
+        "4.38606623021e-07",
+        "4.38606623021e-07",
+        "+4.38606623021e-07",
+        "4.386066230211e-07",
+        "+4.386066230211e-07",
+        "4.386066230211e-07",
+        "0.000000438607",
+        "0.000000438607",
+        "+0.000000438607",
+        "4.386066230211e-07",
+        "4.386066230211e-07",
+        "+4.386066230211e-07",
+        "4.3860662302109e-07",
+        "+4.3860662302109e-07",
+        "4.3860662302109e-07",
+        "0.0000004386066",
+        "0.0000004386066",
+        "+0.0000004386066",
+    }},
+    {{
+        "-4e-07",
+        "-4.e-07",
+        "-4e-07",
+        "-4.4e-07",
+        "-4.4e-07",
+        "-4.4e-07",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-4.4e-07",
+        "-4.4e-07",
+        "-4.4e-07",
+        "-4.39e-07",
+        "-4.39e-07",
+        "-4.39e-07",
+        "-0.00",
+        "-0.00",
+        "-0.00",
+        "-4.39e-07",
+        "-4.39e-07",
+        "-4.39e-07",
+        "-4.386e-07",
+        "-4.386e-07",
+        "-4.386e-07",
+        "-0.000",
+        "-0.000",
+        "-0.000",
+        "-4.386e-07",
+        "-4.386e-07",
+        "-4.386e-07",
+        "-4.3861e-07",
+        "-4.3861e-07",
+        "-4.3861e-07",
+        "-0.0000",
+        "-0.0000",
+        "-0.0000",
+        "-4.3861e-07",
+        "-4.3861e-07",
+        "-4.3861e-07",
+        "-4.38607e-07",
+        "-4.38607e-07",
+        "-4.38607e-07",
+        "-0.00000",
+        "-0.00000",
+        "-0.00000",
+        "-4.38607e-07",
+        "-4.38607e-07",
+        "-4.38607e-07",
+        "-4.386066e-07",
+        "-4.386066e-07",
+        "-4.386066e-07",
+        "-0.000000",
+        "-0.000000",
+        "-0.000000",
+        "-4.386066e-07",
+        "-4.386066e-07",
+        "-4.386066e-07",
+        "-4.3860662e-07",
+        "-4.3860662e-07",
+        "-4.3860662e-07",
+        "-0.0000004",
+        "-0.0000004",
+        "-0.0000004",
+        "-4.3860662e-07",
+        "-4.3860662e-07",
+        "-4.3860662e-07",
+        "-4.38606623e-07",
+        "-4.38606623e-07",
+        "-4.38606623e-07",
+        "-0.00000044",
+        "-0.00000044",
+        "-0.00000044",
+        "-4.38606623e-07",
+        "-4.38606623e-07",
+        "-4.38606623e-07",
+        "-4.386066230e-07",
+        "-4.386066230e-07",
+        "-4.386066230e-07",
+        "-0.000000439",
+        "-0.000000439",
+        "-0.000000439",
+        "-4.38606623e-07",
+        "-4.386066230e-07",
+        "-4.38606623e-07",
+        "-4.3860662302e-07",
+        "-4.3860662302e-07",
+        "-4.3860662302e-07",
+        "-0.0000004386",
+        "-0.0000004386",
+        "-0.0000004386",
+        "-4.3860662302e-07",
+        "-4.3860662302e-07",
+        "-4.3860662302e-07",
+        "-4.38606623021e-07",
+        "-4.38606623021e-07",
+        "-4.38606623021e-07",
+        "-0.00000043861",
+        "-0.00000043861",
+        "-0.00000043861",
+        "-4.38606623021e-07",
+        "-4.38606623021e-07",
+        "-4.38606623021e-07",
+        "-4.386066230211e-07",
+        "-4.386066230211e-07",
+        "-4.386066230211e-07",
+        "-0.000000438607",
+        "-0.000000438607",
+        "-0.000000438607",
+        "-4.386066230211e-07",
+        "-4.386066230211e-07",
+        "-4.386066230211e-07",
+        "-4.3860662302109e-07",
+        "-4.3860662302109e-07",
+        "-4.3860662302109e-07",
+        "-0.0000004386066",
+        "-0.0000004386066",
+        "-0.0000004386066",
+    }},
+    {{
+        "5e-08",
+        "5.e-08",
+        "+5e-08",
+        "5.5e-08",
+        "+5.5e-08",
+        "5.5e-08",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "5.5e-08",
+        "5.5e-08",
+        "+5.5e-08",
+        "5.48e-08",
+        "+5.48e-08",
+        "5.48e-08",
+        "0.00",
+        "0.00",
+        "+0.00",
+        "5.48e-08",
+        "5.48e-08",
+        "+5.48e-08",
+        "5.483e-08",
+        "+5.483e-08",
+        "5.483e-08",
+        "0.000",
+        "0.000",
+        "+0.000",
+        "5.483e-08",
+        "5.483e-08",
+        "+5.483e-08",
+        "5.4826e-08",
+        "+5.4826e-08",
+        "5.4826e-08",
+        "0.0000",
+        "0.0000",
+        "+0.0000",
+        "5.4826e-08",
+        "5.4826e-08",
+        "+5.4826e-08",
+        "5.48258e-08",
+        "+5.48258e-08",
+        "5.48258e-08",
+        "0.00000",
+        "0.00000",
+        "+0.00000",
+        "5.48258e-08",
+        "5.48258e-08",
+        "+5.48258e-08",
+        "5.482583e-08",
+        "+5.482583e-08",
+        "5.482583e-08",
+        "0.000000",
+        "0.000000",
+        "+0.000000",
+        "5.482583e-08",
+        "5.482583e-08",
+        "+5.482583e-08",
+        "5.4825828e-08",
+        "+5.4825828e-08",
+        "5.4825828e-08",
+        "0.0000001",
+        "0.0000001",
+        "+0.0000001",
+        "5.4825828e-08",
+        "5.4825828e-08",
+        "+5.4825828e-08",
+        "5.48258279e-08",
+        "+5.48258279e-08",
+        "5.48258279e-08",
+        "0.00000005",
+        "0.00000005",
+        "+0.00000005",
+        "5.48258279e-08",
+        "5.48258279e-08",
+        "+5.48258279e-08",
+        "5.482582788e-08",
+        "+5.482582788e-08",
+        "5.482582788e-08",
+        "0.000000055",
+        "0.000000055",
+        "+0.000000055",
+        "5.482582788e-08",
+        "5.482582788e-08",
+        "+5.482582788e-08",
+        "5.4825827878e-08",
+        "+5.4825827878e-08",
+        "5.4825827878e-08",
+        "0.0000000548",
+        "0.0000000548",
+        "+0.0000000548",
+        "5.4825827878e-08",
+        "5.4825827878e-08",
+        "+5.4825827878e-08",
+        "5.48258278776e-08",
+        "+5.48258278776e-08",
+        "5.48258278776e-08",
+        "0.00000005483",
+        "0.00000005483",
+        "+0.00000005483",
+        "5.48258278776e-08",
+        "5.48258278776e-08",
+        "+5.48258278776e-08",
+        "5.482582787764e-08",
+        "+5.482582787764e-08",
+        "5.482582787764e-08",
+        "0.000000054826",
+        "0.000000054826",
+        "+0.000000054826",
+        "5.482582787764e-08",
+        "5.482582787764e-08",
+        "+5.482582787764e-08",
+        "5.4825827877636e-08",
+        "+5.4825827877636e-08",
+        "5.4825827877636e-08",
+        "0.0000000548258",
+        "0.0000000548258",
+        "+0.0000000548258",
+    }},
+    {{
+        "-5e-08",
+        "-5.e-08",
+        "-5e-08",
+        "-5.5e-08",
+        "-5.5e-08",
+        "-5.5e-08",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-5.5e-08",
+        "-5.5e-08",
+        "-5.5e-08",
+        "-5.48e-08",
+        "-5.48e-08",
+        "-5.48e-08",
+        "-0.00",
+        "-0.00",
+        "-0.00",
+        "-5.48e-08",
+        "-5.48e-08",
+        "-5.48e-08",
+        "-5.483e-08",
+        "-5.483e-08",
+        "-5.483e-08",
+        "-0.000",
+        "-0.000",
+        "-0.000",
+        "-5.483e-08",
+        "-5.483e-08",
+        "-5.483e-08",
+        "-5.4826e-08",
+        "-5.4826e-08",
+        "-5.4826e-08",
+        "-0.0000",
+        "-0.0000",
+        "-0.0000",
+        "-5.4826e-08",
+        "-5.4826e-08",
+        "-5.4826e-08",
+        "-5.48258e-08",
+        "-5.48258e-08",
+        "-5.48258e-08",
+        "-0.00000",
+        "-0.00000",
+        "-0.00000",
+        "-5.48258e-08",
+        "-5.48258e-08",
+        "-5.48258e-08",
+        "-5.482583e-08",
+        "-5.482583e-08",
+        "-5.482583e-08",
+        "-0.000000",
+        "-0.000000",
+        "-0.000000",
+        "-5.482583e-08",
+        "-5.482583e-08",
+        "-5.482583e-08",
+        "-5.4825828e-08",
+        "-5.4825828e-08",
+        "-5.4825828e-08",
+        "-0.0000001",
+        "-0.0000001",
+        "-0.0000001",
+        "-5.4825828e-08",
+        "-5.4825828e-08",
+        "-5.4825828e-08",
+        "-5.48258279e-08",
+        "-5.48258279e-08",
+        "-5.48258279e-08",
+        "-0.00000005",
+        "-0.00000005",
+        "-0.00000005",
+        "-5.48258279e-08",
+        "-5.48258279e-08",
+        "-5.48258279e-08",
+        "-5.482582788e-08",
+        "-5.482582788e-08",
+        "-5.482582788e-08",
+        "-0.000000055",
+        "-0.000000055",
+        "-0.000000055",
+        "-5.482582788e-08",
+        "-5.482582788e-08",
+        "-5.482582788e-08",
+        "-5.4825827878e-08",
+        "-5.4825827878e-08",
+        "-5.4825827878e-08",
+        "-0.0000000548",
+        "-0.0000000548",
+        "-0.0000000548",
+        "-5.4825827878e-08",
+        "-5.4825827878e-08",
+        "-5.4825827878e-08",
+        "-5.48258278776e-08",
+        "-5.48258278776e-08",
+        "-5.48258278776e-08",
+        "-0.00000005483",
+        "-0.00000005483",
+        "-0.00000005483",
+        "-5.48258278776e-08",
+        "-5.48258278776e-08",
+        "-5.48258278776e-08",
+        "-5.482582787764e-08",
+        "-5.482582787764e-08",
+        "-5.482582787764e-08",
+        "-0.000000054826",
+        "-0.000000054826",
+        "-0.000000054826",
+        "-5.482582787764e-08",
+        "-5.482582787764e-08",
+        "-5.482582787764e-08",
+        "-5.4825827877636e-08",
+        "-5.4825827877636e-08",
+        "-5.4825827877636e-08",
+        "-0.0000000548258",
+        "-0.0000000548258",
+        "-0.0000000548258",
+    }},
+    {{
+        "7e-09",
+        "7.e-09",
+        "+7e-09",
+        "6.9e-09",
+        "+6.9e-09",
+        "6.9e-09",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "6.9e-09",
+        "6.9e-09",
+        "+6.9e-09",
+        "6.85e-09",
+        "+6.85e-09",
+        "6.85e-09",
+        "0.00",
+        "0.00",
+        "+0.00",
+        "6.85e-09",
+        "6.85e-09",
+        "+6.85e-09",
+        "6.853e-09",
+        "+6.853e-09",
+        "6.853e-09",
+        "0.000",
+        "0.000",
+        "+0.000",
+        "6.853e-09",
+        "6.853e-09",
+        "+6.853e-09",
+        "6.8532e-09",
+        "+6.8532e-09",
+        "6.8532e-09",
+        "0.0000",
+        "0.0000",
+        "+0.0000",
+        "6.8532e-09",
+        "6.8532e-09",
+        "+6.8532e-09",
+        "6.85323e-09",
+        "+6.85323e-09",
+        "6.85323e-09",
+        "0.00000",
+        "0.00000",
+        "+0.00000",
+        "6.85323e-09",
+        "6.85323e-09",
+        "+6.85323e-09",
+        "6.853228e-09",
+        "+6.853228e-09",
+        "6.853228e-09",
+        "0.000000",
+        "0.000000",
+        "+0.000000",
+        "6.853228e-09",
+        "6.853228e-09",
+        "+6.853228e-09",
+        "6.8532285e-09",
+        "+6.8532285e-09",
+        "6.8532285e-09",
+        "0.0000000",
+        "0.0000000",
+        "+0.0000000",
+        "6.8532285e-09",
+        "6.8532285e-09",
+        "+6.8532285e-09",
+        "6.85322848e-09",
+        "+6.85322848e-09",
+        "6.85322848e-09",
+        "0.00000001",
+        "0.00000001",
+        "+0.00000001",
+        "6.85322848e-09",
+        "6.85322848e-09",
+        "+6.85322848e-09",
+        "6.853228485e-09",
+        "+6.853228485e-09",
+        "6.853228485e-09",
+        "0.000000007",
+        "0.000000007",
+        "+0.000000007",
+        "6.853228485e-09",
+        "6.853228485e-09",
+        "+6.853228485e-09",
+        "6.8532284847e-09",
+        "+6.8532284847e-09",
+        "6.8532284847e-09",
+        "0.0000000069",
+        "0.0000000069",
+        "+0.0000000069",
+        "6.8532284847e-09",
+        "6.8532284847e-09",
+        "+6.8532284847e-09",
+        "6.85322848470e-09",
+        "+6.85322848470e-09",
+        "6.85322848470e-09",
+        "0.00000000685",
+        "0.00000000685",
+        "+0.00000000685",
+        "6.8532284847e-09",
+        "6.85322848470e-09",
+        "+6.8532284847e-09",
+        "6.853228484704e-09",
+        "+6.853228484704e-09",
+        "6.853228484704e-09",
+        "0.000000006853",
+        "0.000000006853",
+        "+0.000000006853",
+        "6.853228484704e-09",
+        "6.853228484704e-09",
+        "+6.853228484704e-09",
+        "6.8532284847045e-09",
+        "+6.8532284847045e-09",
+        "6.8532284847045e-09",
+        "0.0000000068532",
+        "0.0000000068532",
+        "+0.0000000068532",
+    }},
+    {{
+        "-7e-09",
+        "-7.e-09",
+        "-7e-09",
+        "-6.9e-09",
+        "-6.9e-09",
+        "-6.9e-09",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-6.9e-09",
+        "-6.9e-09",
+        "-6.9e-09",
+        "-6.85e-09",
+        "-6.85e-09",
+        "-6.85e-09",
+        "-0.00",
+        "-0.00",
+        "-0.00",
+        "-6.85e-09",
+        "-6.85e-09",
+        "-6.85e-09",
+        "-6.853e-09",
+        "-6.853e-09",
+        "-6.853e-09",
+        "-0.000",
+        "-0.000",
+        "-0.000",
+        "-6.853e-09",
+        "-6.853e-09",
+        "-6.853e-09",
+        "-6.8532e-09",
+        "-6.8532e-09",
+        "-6.8532e-09",
+        "-0.0000",
+        "-0.0000",
+        "-0.0000",
+        "-6.8532e-09",
+        "-6.8532e-09",
+        "-6.8532e-09",
+        "-6.85323e-09",
+        "-6.85323e-09",
+        "-6.85323e-09",
+        "-0.00000",
+        "-0.00000",
+        "-0.00000",
+        "-6.85323e-09",
+        "-6.85323e-09",
+        "-6.85323e-09",
+        "-6.853228e-09",
+        "-6.853228e-09",
+        "-6.853228e-09",
+        "-0.000000",
+        "-0.000000",
+        "-0.000000",
+        "-6.853228e-09",
+        "-6.853228e-09",
+        "-6.853228e-09",
+        "-6.8532285e-09",
+        "-6.8532285e-09",
+        "-6.8532285e-09",
+        "-0.0000000",
+        "-0.0000000",
+        "-0.0000000",
+        "-6.8532285e-09",
+        "-6.8532285e-09",
+        "-6.8532285e-09",
+        "-6.85322848e-09",
+        "-6.85322848e-09",
+        "-6.85322848e-09",
+        "-0.00000001",
+        "-0.00000001",
+        "-0.00000001",
+        "-6.85322848e-09",
+        "-6.85322848e-09",
+        "-6.85322848e-09",
+        "-6.853228485e-09",
+        "-6.853228485e-09",
+        "-6.853228485e-09",
+        "-0.000000007",
+        "-0.000000007",
+        "-0.000000007",
+        "-6.853228485e-09",
+        "-6.853228485e-09",
+        "-6.853228485e-09",
+        "-6.8532284847e-09",
+        "-6.8532284847e-09",
+        "-6.8532284847e-09",
+        "-0.0000000069",
+        "-0.0000000069",
+        "-0.0000000069",
+        "-6.8532284847e-09",
+        "-6.8532284847e-09",
+        "-6.8532284847e-09",
+        "-6.85322848470e-09",
+        "-6.85322848470e-09",
+        "-6.85322848470e-09",
+        "-0.00000000685",
+        "-0.00000000685",
+        "-0.00000000685",
+        "-6.8532284847e-09",
+        "-6.85322848470e-09",
+        "-6.8532284847e-09",
+        "-6.853228484704e-09",
+        "-6.853228484704e-09",
+        "-6.853228484704e-09",
+        "-0.000000006853",
+        "-0.000000006853",
+        "-0.000000006853",
+        "-6.853228484704e-09",
+        "-6.853228484704e-09",
+        "-6.853228484704e-09",
+        "-6.8532284847045e-09",
+        "-6.8532284847045e-09",
+        "-6.8532284847045e-09",
+        "-0.0000000068532",
+        "-0.0000000068532",
+        "-0.0000000068532",
+    }},
+    {{
+        "9e-10",
+        "9.e-10",
+        "+9e-10",
+        "8.6e-10",
+        "+8.6e-10",
+        "8.6e-10",
+        "0.0",
+        "0.0",
+        "+0.0",
+        "8.6e-10",
+        "8.6e-10",
+        "+8.6e-10",
+        "8.57e-10",
+        "+8.57e-10",
+        "8.57e-10",
+        "0.00",
+        "0.00",
+        "+0.00",
+        "8.57e-10",
+        "8.57e-10",
+        "+8.57e-10",
+        "8.567e-10",
+        "+8.567e-10",
+        "8.567e-10",
+        "0.000",
+        "0.000",
+        "+0.000",
+        "8.567e-10",
+        "8.567e-10",
+        "+8.567e-10",
+        "8.5665e-10",
+        "+8.5665e-10",
+        "8.5665e-10",
+        "0.0000",
+        "0.0000",
+        "+0.0000",
+        "8.5665e-10",
+        "8.5665e-10",
+        "+8.5665e-10",
+        "8.56654e-10",
+        "+8.56654e-10",
+        "8.56654e-10",
+        "0.00000",
+        "0.00000",
+        "+0.00000",
+        "8.56654e-10",
+        "8.56654e-10",
+        "+8.56654e-10",
+        "8.566536e-10",
+        "+8.566536e-10",
+        "8.566536e-10",
+        "0.000000",
+        "0.000000",
+        "+0.000000",
+        "8.566536e-10",
+        "8.566536e-10",
+        "+8.566536e-10",
+        "8.5665356e-10",
+        "+8.5665356e-10",
+        "8.5665356e-10",
+        "0.0000000",
+        "0.0000000",
+        "+0.0000000",
+        "8.5665356e-10",
+        "8.5665356e-10",
+        "+8.5665356e-10",
+        "8.56653561e-10",
+        "+8.56653561e-10",
+        "8.56653561e-10",
+        "0.00000000",
+        "0.00000000",
+        "+0.00000000",
+        "8.56653561e-10",
+        "8.56653561e-10",
+        "+8.56653561e-10",
+        "8.566535606e-10",
+        "+8.566535606e-10",
+        "8.566535606e-10",
+        "0.000000001",
+        "0.000000001",
+        "+0.000000001",
+        "8.566535606e-10",
+        "8.566535606e-10",
+        "+8.566535606e-10",
+        "8.5665356059e-10",
+        "+8.5665356059e-10",
+        "8.5665356059e-10",
+        "0.0000000009",
+        "0.0000000009",
+        "+0.0000000009",
+        "8.5665356059e-10",
+        "8.5665356059e-10",
+        "+8.5665356059e-10",
+        "8.56653560588e-10",
+        "+8.56653560588e-10",
+        "8.56653560588e-10",
+        "0.00000000086",
+        "0.00000000086",
+        "+0.00000000086",
+        "8.56653560588e-10",
+        "8.56653560588e-10",
+        "+8.56653560588e-10",
+        "8.566535605881e-10",
+        "+8.566535605881e-10",
+        "8.566535605881e-10",
+        "0.000000000857",
+        "0.000000000857",
+        "+0.000000000857",
+        "8.566535605881e-10",
+        "8.566535605881e-10",
+        "+8.566535605881e-10",
+        "8.5665356058806e-10",
+        "+8.5665356058806e-10",
+        "8.5665356058806e-10",
+        "0.0000000008567",
+        "0.0000000008567",
+        "+0.0000000008567",
+    }},
+    {{
+        "-9e-10",
+        "-9.e-10",
+        "-9e-10",
+        "-8.6e-10",
+        "-8.6e-10",
+        "-8.6e-10",
+        "-0.0",
+        "-0.0",
+        "-0.0",
+        "-8.6e-10",
+        "-8.6e-10",
+        "-8.6e-10",
+        "-8.57e-10",
+        "-8.57e-10",
+        "-8.57e-10",
+        "-0.00",
+        "-0.00",
+        "-0.00",
+        "-8.57e-10",
+        "-8.57e-10",
+        "-8.57e-10",
+        "-8.567e-10",
+        "-8.567e-10",
+        "-8.567e-10",
+        "-0.000",
+        "-0.000",
+        "-0.000",
+        "-8.567e-10",
+        "-8.567e-10",
+        "-8.567e-10",
+        "-8.5665e-10",
+        "-8.5665e-10",
+        "-8.5665e-10",
+        "-0.0000",
+        "-0.0000",
+        "-0.0000",
+        "-8.5665e-10",
+        "-8.5665e-10",
+        "-8.5665e-10",
+        "-8.56654e-10",
+        "-8.56654e-10",
+        "-8.56654e-10",
+        "-0.00000",
+        "-0.00000",
+        "-0.00000",
+        "-8.56654e-10",
+        "-8.56654e-10",
+        "-8.56654e-10",
+        "-8.566536e-10",
+        "-8.566536e-10",
+        "-8.566536e-10",
+        "-0.000000",
+        "-0.000000",
+        "-0.000000",
+        "-8.566536e-10",
+        "-8.566536e-10",
+        "-8.566536e-10",
+        "-8.5665356e-10",
+        "-8.5665356e-10",
+        "-8.5665356e-10",
+        "-0.0000000",
+        "-0.0000000",
+        "-0.0000000",
+        "-8.5665356e-10",
+        "-8.5665356e-10",
+        "-8.5665356e-10",
+        "-8.56653561e-10",
+        "-8.56653561e-10",
+        "-8.56653561e-10",
+        "-0.00000000",
+        "-0.00000000",
+        "-0.00000000",
+        "-8.56653561e-10",
+        "-8.56653561e-10",
+        "-8.56653561e-10",
+        "-8.566535606e-10",
+        "-8.566535606e-10",
+        "-8.566535606e-10",
+        "-0.000000001",
+        "-0.000000001",
+        "-0.000000001",
+        "-8.566535606e-10",
+        "-8.566535606e-10",
+        "-8.566535606e-10",
+        "-8.5665356059e-10",
+        "-8.5665356059e-10",
+        "-8.5665356059e-10",
+        "-0.0000000009",
+        "-0.0000000009",
+        "-0.0000000009",
+        "-8.5665356059e-10",
+        "-8.5665356059e-10",
+        "-8.5665356059e-10",
+        "-8.56653560588e-10",
+        "-8.56653560588e-10",
+        "-8.56653560588e-10",
+        "-0.00000000086",
+        "-0.00000000086",
+        "-0.00000000086",
+        "-8.56653560588e-10",
+        "-8.56653560588e-10",
+        "-8.56653560588e-10",
+        "-8.566535605881e-10",
+        "-8.566535605881e-10",
+        "-8.566535605881e-10",
+        "-0.000000000857",
+        "-0.000000000857",
+        "-0.000000000857",
+        "-8.566535605881e-10",
+        "-8.566535605881e-10",
+        "-8.566535605881e-10",
+        "-8.5665356058806e-10",
+        "-8.5665356058806e-10",
+        "-8.5665356058806e-10",
+        "-0.0000000008567",
+        "-0.0000000008567",
+        "-0.0000000008567",
+    }},
diff --git a/test/test_1F1.hpp b/test/test_1F1.hpp
index 52f1f1b62a..e4ab8151cb 100644
--- a/test/test_1F1.hpp
+++ b/test/test_1F1.hpp
@@ -162,7 +162,7 @@ void test_spots5(T, const char* type_name)
 template <class T>
 void test_spots6(T, const char* type_name)
 {
-   static const std::array<std::array<T, 4>, 183> hypergeometric_1F1_bugs = { {
+   static const std::array<std::array<T, 4>, 186> hypergeometric_1F1_bugs = { {
         { { static_cast<double>(17955.561660766602), static_cast<double>(9.6968994205831605e-09), static_cast<double>(-82.406154185533524), SC_(6.98056008378736714088730927132364938220428678e-11) }},
         { { static_cast<double>(17955.561660766602), static_cast<double>(-9.6968994205831605e-09), static_cast<double>(-82.406154185533524), SC_(-6.98055306629610746072607353939306734740549551e-11) }},
         { { static_cast<double>(-17955.561660766602), static_cast<double>(-9.6968994205831605e-09), static_cast<double>(82.406154185533524), SC_(-42897094853118832762870100.8669248353530950866) }} ,
@@ -390,6 +390,11 @@ void test_spots6(T, const char* type_name)
       { { -28, 28, 28, SC_(-6.2125286411657869483728921158018766e-9) } }, 
       { { -29, 29, 29, SC_(-1.3521578972057573423569167878458172e-9) } }, 
       {{ -30, 30, 30, SC_(8.2238878884841599031462003461115991e-10) } },
+
+      // https://github.com/boostorg/math/issues/1034
+      {{ 13, 1.5f, 61, SC_(1.35508577094765660270265300640877455638098585524020525369044e39)}},
+      {{ 13, 1.5f - T(1)/128, 61, SC_(1.40067238333701986992154961431485209677766220602448290643906e39)}},
+      {{ 13, 1.5f + T(1)/128, 61, SC_(1.31105748771677778012064837998217769289913724450105998963999e39)}},
    } };
    static const std::array<std::array<T, 4>, 2> hypergeometric_1F1_big_bugs = { {
 #if DBL_MAX_EXP == LDBL_MAX_EXP
diff --git a/test/test_1F1_log.cpp b/test/test_1F1_log.cpp
index 621a5d9432..b0ea07332b 100644
--- a/test/test_1F1_log.cpp
+++ b/test/test_1F1_log.cpp
@@ -160,11 +160,6 @@ BOOST_AUTO_TEST_CASE( test_main )
    expected_results();
    BOOST_MATH_CONTROL_FP;
 
-#if !defined(TEST) || (TEST == 1)
-   test_hypergeometric_mellin_transform<double>();
-   test_hypergeometric_laplace_transform<double>();
-#endif
-
 #ifndef BOOST_MATH_BUGGY_LARGE_FLOAT_CONSTANTS
 #if !defined(TEST) || (TEST == 2)
    test_spots(0.0F, "float");
diff --git a/test/test_1F1_log.hpp b/test/test_1F1_log.hpp
index 28ec4c0d5b..d3b20fe248 100644
--- a/test/test_1F1_log.hpp
+++ b/test/test_1F1_log.hpp
@@ -77,10 +77,28 @@ void test_spots2(T, const char* type_name)
    do_test_1F1<T>(hypergeometric_1f1_log_large_unsolved, type_name, "Large random values - log - unsolved");
 }
 
+template <class T>
+void test_spots_bugs(T, const char* type_name)
+{
+   static const std::array<std::array<T, 4>, 7> hypergeometric_1F1_bugs = { {
+    // Found while investigating https://github.com/boostorg/math/issues/1034
+    {{ 21156.0f, 21156.0f, 11322, SC_(11322.0)}},
+    {{ 21156.0f, 21155.0f, 11322, SC_(11322.428655862323560632951631114666466652986288119296800531328684)}},
+    {{ 21156.0f, 21154.0f, 11322, SC_(11322.857338938931770780542471014439235046236959098048505808665509)}},
+    {{ 21156.0f, 21154.5f, 11322, SC_(11322.642993998700652342915766513423502332460377941025163971463001)}},
+    {{ 21156.0f, 21155.0f - 1.0f / 128, 11322, SC_(11322.43200484338133063401686149227756707)}},
+    {{ 21156.0f, 21154.5f - 1.0f / 128, 11322, SC_(11322.646343086066466097278446364687150256282052775170519455915995)}},
+    {{ 21156.0f, 21154.0f + 1.0f / 128, 11322, SC_(11322.85398974691465958225700429672975704)}},
+   } };
+
+   do_test_1F1<T>(hypergeometric_1F1_bugs, type_name, "Large random values - log - bug cases");
+}
+
 template <class T>
 void test_spots(T z, const char* type_name)
 {
    test_spots1(z, type_name);
+   test_spots_bugs(z, type_name);
 #ifdef TEST_UNSOLVED
    test_spots2(z, type_name);
 #endif
diff --git a/test/test_autodiff_7.cpp b/test/test_autodiff_7.cpp
index c41d806ae4..cbf81c6566 100644
--- a/test/test_autodiff_7.cpp
+++ b/test/test_autodiff_7.cpp
@@ -23,45 +23,4 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(expm1_hpp, T, all_float_types) {
   }
 }
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(fpclassify_hpp, T, all_float_types) {
-  using boost::math::fpclassify;
-  using boost::math::isfinite;
-  using boost::math::isinf;
-  using boost::math::isnan;
-  using boost::math::isnormal;
-  using boost::multiprecision::fpclassify;
-  using boost::multiprecision::isfinite;
-  using boost::multiprecision::isinf;
-  using boost::multiprecision::isnan;
-  using boost::multiprecision::isnormal;
-
-  using test_constants = test_constants_t<T>;
-  static constexpr auto m = test_constants::order;
-  test_detail::RandomSample<T> x_sampler{-1000, 1000};
-  for (auto i : boost::irange(test_constants::n_samples)) {
-    std::ignore = i;
-
-    BOOST_CHECK_EQUAL(fpclassify(make_fvar<T, m>(0)), FP_ZERO);
-    BOOST_CHECK_EQUAL(fpclassify(make_fvar<T, m>(10)), FP_NORMAL);
-    BOOST_CHECK_EQUAL(
-        fpclassify(make_fvar<T, m>(std::numeric_limits<T>::infinity())),
-        FP_INFINITE);
-    BOOST_CHECK_EQUAL(
-        fpclassify(make_fvar<T, m>(std::numeric_limits<T>::quiet_NaN())),
-        FP_NAN);
-    if (std::numeric_limits<T>::has_denorm != std::denorm_absent) {
-      BOOST_CHECK_EQUAL(
-          fpclassify(make_fvar<T, m>(std::numeric_limits<T>::denorm_min())),
-          FP_SUBNORMAL);
-    }
-
-    BOOST_CHECK(isfinite(make_fvar<T, m>(0)));
-    BOOST_CHECK(isnormal(make_fvar<T, m>((std::numeric_limits<T>::min)())));
-    BOOST_CHECK(
-        !isnormal(make_fvar<T, m>(std::numeric_limits<T>::denorm_min())));
-    BOOST_CHECK(isinf(make_fvar<T, m>(std::numeric_limits<T>::infinity())));
-    BOOST_CHECK(isnan(make_fvar<T, m>(std::numeric_limits<T>::quiet_NaN())));
-  }
-}
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/test_binomial.cpp b/test/test_binomial.cpp
index fa50da7f5a..6a8f077f34 100644
--- a/test/test_binomial.cpp
+++ b/test/test_binomial.cpp
@@ -716,6 +716,15 @@ void test_spots(RealType T)
 
    check_out_of_range<boost::math::binomial_distribution<RealType> >(1, 1); // (All) valid constructor parameter values.
 
+   // See bug reported here: https://github.com/boostorg/math/pull/1007
+   {
+      using namespace boost::math::policies;
+      typedef policy<discrete_quantile<integer_round_outwards> > Policy;
+      binomial_distribution<RealType, Policy> dist(9079765771874083840, 0.561815);
+      // Accuracy is not too important here; the main purpose is to
+      // make sure it is not stuck.
+      BOOST_CHECK_CLOSE(quantile(dist, 0.0365346), 5101148604445670400, 1e12);
+   }
 
 } // template <class RealType>void test_spots(RealType)
 
diff --git a/test/test_classify.cpp b/test/test_classify.cpp
index d7a7c4d249..609a355b04 100644
--- a/test/test_classify.cpp
+++ b/test/test_classify.cpp
@@ -11,11 +11,14 @@
 #include <boost/limits.hpp>
 #include <boost/math/concepts/real_concept.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/math/special_functions/next.hpp>  // for has_denorm_now
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
 #include <iostream>
 #include <iomanip>
 
+#include "test_autodiff.hpp"
+
 #ifdef _MSC_VER
 #pragma warning(disable: 4127 4146) //  conditional expression is constant
 #endif
@@ -103,7 +106,7 @@ void test_classify(T t, const char* type)
          }
       }
    }
-   if(std::numeric_limits<T>::has_denorm)
+   if(boost::math::detail::has_denorm_now<T>())
    {
       t = (std::numeric_limits<T>::min)();
       t /= 2;
@@ -256,6 +259,9 @@ void test_classify(T t, const char* type)
 #endif
 }
 
+
+BOOST_AUTO_TEST_SUITE(test_fpclassify)
+
 BOOST_AUTO_TEST_CASE( test_main )
 {
    BOOST_MATH_CONTROL_FP;
@@ -288,6 +294,16 @@ BOOST_AUTO_TEST_CASE( test_main )
    test_classify(unsigned(0), "unsigned");
 }
 
+BOOST_AUTO_TEST_CASE_TEMPLATE(fpclassify_autodiff, T, all_float_types) {
+   test_classify(boost::math::differentiation::make_fvar<T, 1>(0), "autodiff float");
+   test_classify(boost::math::differentiation::make_fvar<T, 2>(0), "autodiff float");
+   test_classify(boost::math::differentiation::make_fvar<T, 3>(0), "autodiff float");
+   test_classify(boost::math::differentiation::make_fvar<T, 7>(0), "autodiff float");
+   test_classify(boost::math::differentiation::make_fvar<T, 12>(0), "autodiff float");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
 /*
 Autorun "i:\Boost-sandbox\math_toolkit\libs\math\test\MSVC80\debug\test_classify.exe"
 Running 1 test case...
diff --git a/test/test_difference.cpp b/test/test_difference.cpp
index b64f2835c4..7f4ff4f8f2 100644
--- a/test/test_difference.cpp
+++ b/test/test_difference.cpp
@@ -90,7 +90,7 @@ void test_values(const T& val, const char* name)
    test_value(-boost::math::tools::epsilon<T>(), name);
    test_value(boost::math::tools::min_value<T>(), name);
    test_value(-boost::math::tools::min_value<T>(), name);
-   if (std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present) && ((std::numeric_limits<T>::min)() / 2 != 0))
+   if (std::numeric_limits<T>::is_specialized && boost::math::detail::has_denorm_now<T>() && ((std::numeric_limits<T>::min)() / 2 != 0))
    {
       test_value(z, name);
       test_value(-z, name);
diff --git a/test/test_float_io.cpp b/test/test_float_io.cpp
new file mode 100644
index 0000000000..5bf308e3de
--- /dev/null
+++ b/test/test_float_io.cpp
@@ -0,0 +1,450 @@
+// Copyright John Maddock 2023.
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifdef _MSC_VER
+#define _SCL_SECURE_NO_WARNINGS
+#endif
+
+#include <boost/cstdfloat.hpp>
+#include <boost/math/special_functions/next.hpp>
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/random/uniform_int.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/array.hpp>
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+
+#ifdef BOOST_FLOAT128_C
+#if defined(__INTEL_COMPILER) || defined(BOOST_MATH_TEST_IO_AS_INTEL_QUAD)
+bool has_bad_bankers_rounding(const boost::float128_t&)
+{
+   return true;
+}
+#endif
+#endif
+
+template <class T>
+bool has_bad_bankers_rounding(const T&)
+{
+   return false;
+}
+
+enum
+{
+   warn_on_fail,
+   error_on_fail,
+   abort_on_fail
+};
+
+inline std::ostream& report_where(const char* file, int line, const char* function)
+{
+   if (function)
+      BOOST_LIGHTWEIGHT_TEST_OSTREAM << "In function: " << function << std::endl;
+   BOOST_LIGHTWEIGHT_TEST_OSTREAM << file << ":" << line;
+   return BOOST_LIGHTWEIGHT_TEST_OSTREAM;
+}
+
+#define BOOST_MP_REPORT_WHERE report_where(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION)
+
+inline void report_severity(int severity)
+{
+   if (severity == error_on_fail)
+      ++boost::detail::test_errors();
+   else if (severity == abort_on_fail)
+   {
+      ++boost::detail::test_errors();
+      abort();
+   }
+}
+
+#define BOOST_MP_REPORT_SEVERITY(severity) report_severity(severity)
+
+template <class E>
+void report_unexpected_exception(const E& e, int severity, const char* file, int line, const char* function)
+{
+   report_where(file, line, function) << " Unexpected exception of type " << typeid(e).name() << std::endl;
+   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Errot message was: " << e.what() << std::endl;
+   BOOST_MP_REPORT_SEVERITY(severity);
+}
+
+#ifdef BOOST_HAS_INT128
+
+std::ostream& operator<<(std::ostream& os, boost::int128_type val)
+{
+   std::stringstream ss;
+   ss << std::hex << "0x" << static_cast<std::uint64_t>(static_cast<boost::uint128_type>(val) >> 64) << static_cast<std::uint64_t>(val);
+   return os << ss.str();
+}
+
+std::ostream& operator<<(std::ostream& os, boost::uint128_type val)
+{
+   std::stringstream ss;
+   ss << std::hex << "0x" << static_cast<std::uint64_t>(val >> 64) << static_cast<std::uint64_t>(val);
+   return os << ss.str();
+}
+
+#endif
+
+#ifndef BOOST_NO_EXCEPTIONS
+#define BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)                                       \
+   catch (const std::exception& e)                                                          \
+   {                                                                                        \
+      report_unexpected_exception(e, severity, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+   }                                                                                        \
+   catch (...)                                                                              \
+   {                                                                                        \
+      std::cout << "Exception of unknown type was thrown" << std::endl;                     \
+      report_severity(severity);                                                            \
+   }
+#define BOOST_MP_TEST_TRY try
+#else
+#define BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+#define BOOST_MP_TEST_TRY
+#endif
+
+#define BOOST_CHECK_IMP(x, severity)                                                        \
+   BOOST_MP_TEST_TRY                                                                             \
+   {                                                                                        \
+      if (x)                                                                                \
+      {                                                                                     \
+      }                                                                                     \
+      else                                                                                  \
+      {                                                                                     \
+         BOOST_MP_REPORT_WHERE << " Failed predicate: " << BOOST_STRINGIZE(x) << std::endl; \
+         BOOST_MP_REPORT_SEVERITY(severity);                                                \
+      }                                                                                     \
+   }                                                                                        \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+
+#define BOOST_CHECK(x) BOOST_CHECK_IMP(x, error_on_fail)
+#define BOOST_WARN(x) BOOST_CHECK_IMP(x, warn_on_fail)
+#define BOOST_REQUIRE(x) BOOST_CHECK_IMP(x, abort_on_fail)
+
+#define BOOST_CLOSE_IMP(x, y, tol, severity)                                                \
+   BOOST_MP_TEST_TRY                                                                             \
+   {                                                                                        \
+      if (relative_error(x, y) > tol)                                                       \
+      {                                                                                     \
+         BOOST_MP_REPORT_WHERE << " Failed check for closeness: \n"                         \
+                               << std::setprecision(std::numeric_limits<decltype(x)>::max_digits10) << std::scientific        \
+                               << "Value of LHS was: " << x << "\n"                         \
+                               << "Value of RHS was: " << y << "\n"                         \
+                               << std::setprecision(5) << std::fixed                        \
+                               << "Relative error was: " << relative_error(x, y) << "eps\n" \
+                               << "Tolerance was: " << tol << "eps" << std::endl;           \
+         BOOST_MP_REPORT_SEVERITY(severity);                                                \
+      }                                                                                     \
+   }                                                                                        \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+
+#define BOOST_EQUAL_IMP(x, y, severity)                                              \
+   BOOST_MP_TEST_TRY                                                                      \
+   {                                                                                 \
+      if (!((x) == (y)))                                                             \
+      {                                                                              \
+         BOOST_MP_REPORT_WHERE << " Failed check for equality: \n"                   \
+                               << std::setprecision(std::numeric_limits<decltype(x)>::max_digits10) << std::scientific \
+                               << "Value of LHS was: " << (x) << "\n"                \
+                               << "Value of RHS was: " << (y) << "\n"                \
+                               << std::setprecision(3) << std::endl;                 \
+         BOOST_MP_REPORT_SEVERITY(severity);                                         \
+      }                                                                              \
+   }                                                                                 \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+
+#define BOOST_NE_IMP(x, y, severity)                                                 \
+   BOOST_MP_TEST_TRY                                                                      \
+   {                                                                                 \
+      if (!(x != y))                                                                 \
+      {                                                                              \
+         BOOST_MP_REPORT_WHERE << " Failed check for non-equality: \n"               \
+                               << std::setprecision(std::numeric_limits<decltype(x)>::max_digits10) << std::scientific \
+                               << "Value of LHS was: " << x << "\n"                  \
+                               << "Value of RHS was: " << y << "\n"                  \
+                               << std::setprecision(3) << std::endl;                 \
+         BOOST_MP_REPORT_SEVERITY(severity);                                         \
+      }                                                                              \
+   }                                                                                 \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+
+#define BOOST_LT_IMP(x, y, severity)                                                 \
+   BOOST_MP_TEST_TRY                                                                      \
+   {                                                                                 \
+      if (!(x < y))                                                                  \
+      {                                                                              \
+         BOOST_MP_REPORT_WHERE << " Failed check for less than: \n"                  \
+                               << std::setprecision(std::numeric_limits<decltype(x)>::max_digits10) << std::scientific \
+                               << "Value of LHS was: " << x << "\n"                  \
+                               << "Value of RHS was: " << y << "\n"                  \
+                               << std::setprecision(3) << std::endl;                 \
+         BOOST_MP_REPORT_SEVERITY(severity);                                         \
+      }                                                                              \
+   }                                                                                 \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+
+#define BOOST_GT_IMP(x, y, severity)                                                 \
+   BOOST_MP_TEST_TRY                                                                      \
+   {                                                                                 \
+      if (!(x > y))                                                                  \
+      {                                                                              \
+         BOOST_MP_REPORT_WHERE << " Failed check for greater than: \n"               \
+                               << std::setprecision(std::numeric_limits<decltype(x)>::max_digits10) << std::scientific \
+                               << "Value of LHS was: " << x << "\n"                  \
+                               << "Value of RHS was: " << y << "\n"                  \
+                               << std::setprecision(3) << std::endl;                 \
+         BOOST_MP_REPORT_SEVERITY(severity);                                         \
+      }                                                                              \
+   }                                                                                 \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+
+#define BOOST_LE_IMP(x, y, severity)                                                 \
+   BOOST_MP_TEST_TRY                                                                      \
+   {                                                                                 \
+      if (!(x <= y))                                                                 \
+      {                                                                              \
+         BOOST_MP_REPORT_WHERE << " Failed check for less-than-equal-to: \n"         \
+                               << std::setprecision(std::numeric_limits<decltype(x)>::max_digits10) << std::scientific \
+                               << "Value of LHS was: " << x << "\n"                  \
+                               << "Value of RHS was: " << y << "\n"                  \
+                               << std::setprecision(3) << std::endl;                 \
+         BOOST_MP_REPORT_SEVERITY(severity);                                         \
+      }                                                                              \
+   }                                                                                 \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+
+#define BOOST_GE_IMP(x, y, severity)                                                 \
+   BOOST_MP_TEST_TRY                                                                      \
+   {                                                                                 \
+      if (!(x >= y))                                                                 \
+      {                                                                              \
+         BOOST_MP_REPORT_WHERE << " Failed check for greater-than-equal-to \n"       \
+                               << std::setprecision(std::numeric_limits<decltype(x)>::max_digits10) << std::scientific \
+                               << "Value of LHS was: " << x << "\n"                  \
+                               << "Value of RHS was: " << y << "\n"                  \
+                               << std::setprecision(3) << std::endl;                 \
+         BOOST_MP_REPORT_SEVERITY(severity);                                         \
+      }                                                                              \
+   }                                                                                 \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+
+#ifndef BOOST_NO_EXCEPTIONS
+#define BOOST_MT_CHECK_THROW_IMP(x, E, severity)                                                                   \
+   BOOST_MP_TEST_TRY                                                                                                    \
+   {                                                                                                               \
+      x;                                                                                                           \
+      BOOST_MP_REPORT_WHERE << " Expected exception not thrown in expression " << BOOST_STRINGIZE(x) << std::endl; \
+      BOOST_MP_REPORT_SEVERITY(severity);                                                                          \
+   }                                                                                                               \
+   catch (const E&) {}                                                                                             \
+   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
+#else
+#define BOOST_MT_CHECK_THROW_IMP(x, E, severity)
+#endif
+
+#define BOOST_CHECK_EQUAL(x, y) BOOST_EQUAL_IMP(x, y, error_on_fail)
+#define BOOST_WARN_EQUAL(x, y) BOOST_EQUAL_IMP(x, y, warn_on_fail)
+#define BOOST_REQUIRE_EQUAL(x, y) BOOST_EQUAL_IMP(x, y, abort_on_fail)
+
+void print_flags(std::ios_base::fmtflags f)
+{
+   std::cout << "Formatting flags were: ";
+   if (f & std::ios_base::scientific)
+      std::cout << "scientific ";
+   if (f & std::ios_base::fixed)
+      std::cout << "fixed ";
+   if (f & std::ios_base::showpoint)
+      std::cout << "showpoint ";
+   if (f & std::ios_base::showpos)
+      std::cout << "showpos ";
+   std::cout << std::endl;
+}
+
+bool is_bankers_rounding_error(const std::string& s, const char* expect)
+{
+   // This check isn't foolproof: that would require *much* more sophisticated code!!!
+   std::string::size_type l = std::strlen(expect);
+   if (l != s.size())
+      return false;
+   std::string::size_type len = s.find('e');
+   if (len == std::string::npos)
+      len = l - 1;
+   else
+      --len;
+   if (s.compare(0, len, expect, len))
+      return false;
+   if (s[len] != expect[len] + 1)
+      return false;
+   return true;
+}
+
+template <class T>
+bool is_bankers_rounding_error(T new_val, T val)
+{
+   // This check isn't foolproof: that would require *much* more sophisticated code!!!
+   auto n = boost::math::float_distance(new_val, val) == 1;
+   std::cout << "Distance was: " << n << std::endl;
+   return std::abs(n) <= 1;
+}
+
+template <class T>
+void test()
+{
+   typedef T                                mp_t;
+   boost::array<std::ios_base::fmtflags, 9> f =
+       {{std::ios_base::fmtflags(0), std::ios_base::showpoint, std::ios_base::showpos, std::ios_base::scientific, std::ios_base::scientific | std::ios_base::showpos,
+         std::ios_base::scientific | std::ios_base::showpoint, std::ios_base::fixed, std::ios_base::fixed | std::ios_base::showpoint,
+         std::ios_base::fixed | std::ios_base::showpos}};
+
+   boost::array<boost::array<const char*, 13 * 9>, 40> string_data = {{
+#include "libs/math/test/string_data.ipp"
+   }};
+
+   double num   = 123456789.0;
+   double denom = 1;
+   double val   = num;
+   for (unsigned j = 0; j < 40; ++j)
+   {
+      unsigned col = 0;
+      for (unsigned prec = 1; prec < 14; ++prec)
+      {
+         for (unsigned i = 0; i < f.size(); ++i, ++col)
+         {
+            std::stringstream ss;
+            ss.precision(prec);
+            ss.flags(f[i]);
+            ss << mp_t(val);
+            const char* expect = string_data[j][col];
+            if (ss.str() != expect)
+            {
+               if (has_bad_bankers_rounding(mp_t()) && is_bankers_rounding_error(ss.str(), expect))
+               {
+                  std::cout << "Ignoring bankers-rounding error with Intel _Quad.\n";
+               }
+               else
+               {
+                  std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
+                  print_flags(f[i]);
+                  std::cout << "Precision is: " << prec << std::endl;
+                  std::cout << "Got:      " << ss.str() << std::endl;
+                  std::cout << "Expected: " << expect << std::endl;
+                  ++boost::detail::test_errors();
+               }
+            }
+         }
+      }
+      num = -num;
+      if (j & 1)
+         denom *= 8;
+      val = num / denom;
+   }
+
+   boost::array<const char*, 13 * 9> zeros =
+       {{"0", "0.", "+0", "0.0e+00", "+0.0e+00", "0.0e+00", "0.0", "0.0", "+0.0", "0", "0.0", "+0", "0.00e+00", "+0.00e+00", "0.00e+00", "0.00", "0.00", "+0.00", "0", "0.00", "+0", "0.000e+00", "+0.000e+00", "0.000e+00", "0.000", "0.000", "+0.000", "0", "0.000", "+0", "0.0000e+00", "+0.0000e+00", "0.0000e+00", "0.0000", "0.0000", "+0.0000", "0", "0.0000", "+0", "0.00000e+00", "+0.00000e+00", "0.00000e+00", "0.00000", "0.00000", "+0.00000", "0", "0.00000", "+0", "0.000000e+00", "+0.000000e+00", "0.000000e+00", "0.000000", "0.000000", "+0.000000", "0", "0.000000", "+0", "0.0000000e+00", "+0.0000000e+00", "0.0000000e+00", "0.0000000", "0.0000000", "+0.0000000", "0", "0.0000000", "+0", "0.00000000e+00", "+0.00000000e+00", "0.00000000e+00", "0.00000000", "0.00000000", "+0.00000000", "0", "0.00000000", "+0", "0.000000000e+00", "+0.000000000e+00", "0.000000000e+00", "0.000000000", "0.000000000", "+0.000000000", "0", "0.000000000", "+0", "0.0000000000e+00", "+0.0000000000e+00", "0.0000000000e+00", "0.0000000000", "0.0000000000", "+0.0000000000", "0", "0.0000000000", "+0", "0.00000000000e+00", "+0.00000000000e+00", "0.00000000000e+00", "0.00000000000", "0.00000000000", "+0.00000000000", "0", "0.00000000000", "+0", "0.000000000000e+00", "+0.000000000000e+00", "0.000000000000e+00", "0.000000000000", "0.000000000000", "+0.000000000000", "0", "0.000000000000", "+0", "0.0000000000000e+00", "+0.0000000000000e+00", "0.0000000000000e+00", "0.0000000000000", "0.0000000000000", "+0.0000000000000"}};
+
+   unsigned col = 0;
+   val          = 0;
+   for (unsigned prec = 1; prec < 14; ++prec)
+   {
+      for (unsigned i = 0; i < f.size(); ++i, ++col)
+      {
+         std::stringstream ss;
+         ss.precision(prec);
+         ss.flags(f[i]);
+         ss << mp_t(val);
+         const char* expect = zeros[col];
+         if (ss.str() != expect)
+         {
+            std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
+            print_flags(f[i]);
+            std::cout << "Precision is: " << prec << std::endl;
+            std::cout << "Got:      " << ss.str() << std::endl;
+            std::cout << "Expected: " << expect << std::endl;
+            ++boost::detail::test_errors();
+         }
+      }
+   }
+}
+
+template <class T>
+T generate_random()
+{
+   typedef int                                     e_type;
+   static boost::random::mt19937                   gen;
+   T                                               val      = gen();
+   T                                               prev_val = -1;
+   while (val != prev_val)
+   {
+      val *= (gen.max)();
+      prev_val = val;
+      val += gen();
+   }
+   e_type e;
+   val = frexp(val, &e);
+
+   static boost::random::uniform_int_distribution<e_type> ui(0, std::numeric_limits<T>::max_exponent - 10);
+   return ldexp(val, ui(gen));
+}
+
+template <class T>
+void do_round_trip(const T& val, std::ios_base::fmtflags f)
+{
+   std::stringstream ss;
+   ss << std::setprecision(std::numeric_limits<T>::max_digits10);
+   ss.flags(f);
+   ss << val;
+   T new_val;
+   ss >> new_val;
+   if (new_val != val)
+   {
+      if (has_bad_bankers_rounding(T()) && is_bankers_rounding_error(new_val, val))
+      {
+         std::cout << "Ignoring bankers-rounding error with Intel _Quad mp_f.\n";
+      }
+      else
+      {
+         BOOST_CHECK_EQUAL(new_val, val);
+      }
+   }
+}
+
+template <class T>
+void do_round_trip(const T& val)
+{
+   do_round_trip(val, std::ios_base::fmtflags(0));
+   do_round_trip(val, std::ios_base::fmtflags(std::ios_base::scientific));
+   if ((fabs(val) > 1) && (fabs(val) < 1e100))
+      do_round_trip(val, std::ios_base::fmtflags(std::ios_base::fixed));
+}
+
+template <class T>
+void test_round_trip()
+{
+   for (unsigned i = 0; i < 1000; ++i)
+   {
+      T val = generate_random<T>();
+      do_round_trip(val);
+      do_round_trip(T(-val));
+      do_round_trip(T(1 / val));
+      do_round_trip(T(-1 / val));
+   }
+}
+
+int main()
+{
+   test<double>();
+   test<boost::float64_t>();
+
+   test_round_trip<double>();
+   test_round_trip<boost::float64_t>();
+
+#ifdef BOOST_FLOAT128_C
+   test<boost::float128_t>();
+   test_round_trip<boost::float128_t>();
+#endif
+   return boost::report_errors();
+}
diff --git a/test/test_gamma.hpp b/test/test_gamma.hpp
index 5b8c2724e7..c21573dac6 100644
--- a/test/test_gamma.hpp
+++ b/test/test_gamma.hpp
@@ -11,6 +11,7 @@
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
 #include <boost/test/tools/floating_point_comparison.hpp>
+#include <boost/math/special_functions/next.hpp>  // for has_denorm_now
 #include <boost/math/tools/stats.hpp>
 #include <boost/math/tools/test.hpp>
 #include <boost/math/constants/constants.hpp>
@@ -319,7 +320,7 @@ void test_spots(T, const char* name)
       BOOST_CHECK(sign == -1);
    }
 
-   if(std::numeric_limits<T>::has_denorm && std::numeric_limits<T>::has_infinity && (boost::math::isinf)(1 / std::numeric_limits<T>::denorm_min()))
+   if(boost::math::detail::has_denorm_now<T>() && std::numeric_limits<T>::has_infinity && (boost::math::isinf)(1 / std::numeric_limits<T>::denorm_min()))
    {
       BOOST_CHECK_EQUAL(boost::math::tgamma(-std::numeric_limits<T>::denorm_min()), -std::numeric_limits<T>::infinity());
       BOOST_CHECK_EQUAL(boost::math::tgamma(std::numeric_limits<T>::denorm_min()), std::numeric_limits<T>::infinity());
@@ -336,7 +337,7 @@ void test_spots(T, const char* name)
    //
    // Super small values may cause spurious overflow:
    //
-   if (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::has_denorm)
+   if (std::numeric_limits<T>::is_specialized && boost::math::detail::has_denorm_now<T>())
    {
       T value = (std::numeric_limits<T>::min)();
       while (value != 0)
diff --git a/test/test_ibeta_inv.hpp b/test/test_ibeta_inv.hpp
index 9e303e9235..ba98901773 100644
--- a/test/test_ibeta_inv.hpp
+++ b/test/test_ibeta_inv.hpp
@@ -8,6 +8,7 @@
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
 #include <boost/test/tools/floating_point_comparison.hpp>
+#include <boost/math/special_functions/next.hpp>  // for has_denorm_now
 #include <boost/math/special_functions/math_fwd.hpp>
 #include <boost/math/tools/stats.hpp>
 #include <boost/math/tools/test.hpp>
@@ -305,7 +306,7 @@ void test_spots(T)
       BOOST_MATH_CHECK_THROW(::boost::math::ibeta_inv(static_cast<T>(2.125), -n, static_cast<T>(0.125)), std::domain_error);
       BOOST_MATH_CHECK_THROW(::boost::math::ibeta_inv(static_cast<T>(2.125), static_cast<T>(1.125), -n), std::domain_error);
    }
-   if (std::numeric_limits<T>::has_denorm)
+   if (boost::math::detail::has_denorm_now<T>())
    {
       T m = std::numeric_limits<T>::denorm_min();
       T small = 2 * (std::numeric_limits<T>::min)();
diff --git a/test/test_lambert_w.cpp b/test/test_lambert_w.cpp
index 6841f8d6fa..33269e68dd 100644
--- a/test/test_lambert_w.cpp
+++ b/test/test_lambert_w.cpp
@@ -491,7 +491,7 @@ void test_spots(RealType)
   }
 
   // denorm - but might be == min or zero?
-  if (std::numeric_limits<RealType>::has_denorm == true)
+  if (boost::math::detail::has_denorm_now<RealType>())
   { // Might also return infinity like z == 0?
     BOOST_CHECK_THROW(lambert_wm1(std::numeric_limits<RealType>::denorm_min()), std::overflow_error);
   }
diff --git a/test/test_nc_t.hpp b/test/test_nc_t.hpp
index 8fb6accdf3..b04b10ba6f 100644
--- a/test/test_nc_t.hpp
+++ b/test/test_nc_t.hpp
@@ -320,6 +320,15 @@ void test_spots(RealType)
       BOOST_CHECK(boost::math::isnan(pdf(d2, 0.5)));
       BOOST_CHECK(boost::math::isnan(cdf(d2, 0.5)));
    }
+
+   // Bug cases, 
+   // https://github.com/scipy/scipy/issues/19348
+   //
+   {
+      distro1 d(8.0f, 8.5f);
+      BOOST_CHECK_CLOSE(pdf(d, -1), static_cast<RealType>(6.1747948083757028903541988987716621647020752431287e-20), 2e-5);  // Can we do better on accuracy here?
+   }
+
 } // template <class RealType>void test_spots(RealType)
 
 template <class T>
diff --git a/test/test_next.cpp b/test/test_next.cpp
index 305dd8fee2..b4f05b4379 100644
--- a/test/test_next.cpp
+++ b/test/test_next.cpp
@@ -56,7 +56,7 @@ void test_value(const T& val, const char* name)
 
    BOOST_CHECK_EQUAL(float_distance(float_advance(val, 4), val), -4);
    BOOST_CHECK_EQUAL(float_distance(float_advance(val, -4), val), 4);
-   if(std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present))
+   if(std::numeric_limits<T>::is_specialized && boost::math::detail::has_denorm_now<T>())
    {
       BOOST_CHECK_EQUAL(float_distance(float_advance(float_next(float_next(val)), 4), float_next(float_next(val))), -4);
       BOOST_CHECK_EQUAL(float_distance(float_advance(float_next(float_next(val)), -4), float_next(float_next(val))), 4);
@@ -122,7 +122,7 @@ void test_values(const T& val, const char* name)
    test_value(-boost::math::tools::epsilon<T>(), name);
    test_value(boost::math::tools::min_value<T>(), name);
    test_value(-boost::math::tools::min_value<T>(), name);
-   if (std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present) && ((std::numeric_limits<T>::min)() / 2 != 0))
+   if (std::numeric_limits<T>::is_specialized && boost::math::detail::has_denorm_now<T>() && ((std::numeric_limits<T>::min)() / 2 != 0))
    {
       test_value(z, name);
       test_value(-z, name);
@@ -135,7 +135,7 @@ void test_values(const T& val, const char* name)
    if((_mm_getcsr() & (_MM_FLUSH_ZERO_ON | 0x40)) == 0)
    {
 #endif
-      if(std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present) && ((std::numeric_limits<T>::min)() / 2 != 0))
+      if(std::numeric_limits<T>::is_specialized && boost::math::detail::has_denorm_now<T>() && ((std::numeric_limits<T>::min)() / 2 != 0))
       {
          test_value(std::numeric_limits<T>::denorm_min(), name);
          test_value(-std::numeric_limits<T>::denorm_min(), name);
diff --git a/test/test_next_decimal.cpp b/test/test_next_decimal.cpp
index 3d532335bc..07d59aa877 100644
--- a/test/test_next_decimal.cpp
+++ b/test/test_next_decimal.cpp
@@ -61,7 +61,7 @@ void test_value(const T& val, const char* name)
    }
    BOOST_CHECK_EQUAL(float_distance(float_advance(val, 4), val), -4);
    BOOST_CHECK_EQUAL(float_distance(float_advance(val, -4), val), 4);
-   if(std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present))
+   if(std::numeric_limits<T>::is_specialized && boost::math::detail::has_denorm_now<T>())
    {
       BOOST_CHECK_EQUAL(float_distance(float_advance(float_next(float_next(val)), 4), float_next(float_next(val))), -4);
       BOOST_CHECK_EQUAL(float_distance(float_advance(float_next(float_next(val)), -4), float_next(float_next(val))), 4);
@@ -132,7 +132,7 @@ void test_values(const T& val, const char* name)
    test_value(T(-boost::math::tools::epsilon<T>()), name);
    test_value(boost::math::tools::min_value<T>(), name);
    test_value(T(-boost::math::tools::min_value<T>()), name);
-   if (std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present) && ((std::numeric_limits<T>::min)() / 2 != 0))
+   if (std::numeric_limits<T>::is_specialized && boost::math::detail::has_denorm_now<T>() && ((std::numeric_limits<T>::min)() / 2 != 0))
    {
       test_value(z, name);
       test_value(T(-z), name);
@@ -142,7 +142,7 @@ void test_values(const T& val, const char* name)
    test_value(radix, name);
    test_value(T(-radix), name);
 
-   if(std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::has_denorm == std::denorm_present) && ((std::numeric_limits<T>::min)() / 2 != 0))
+   if(std::numeric_limits<T>::is_specialized && boost::math::detail::has_denorm_now<T>() && ((std::numeric_limits<T>::min)() / 2 != 0))
    {
       test_value(std::numeric_limits<T>::denorm_min(), name);
       test_value(T(-std::numeric_limits<T>::denorm_min()), name);
diff --git a/test/test_roots.cpp b/test/test_roots.cpp
index dda14c2e6f..e4e68e24b8 100644
--- a/test/test_roots.cpp
+++ b/test/test_roots.cpp
@@ -654,6 +654,10 @@ BOOST_AUTO_TEST_CASE( test_main )
 
    test_beta(0.1, "double");
 
+   // bug reports:
+   boost::math::skew_normal_distribution<> dist(2.0, 1.0, -2.5);
+   BOOST_CHECK(boost::math::isfinite(quantile(dist, 0.075)));
+
 #if !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_CXX11_LAMBDAS)
    test_complex_newton<std::complex<float>>();
    test_complex_newton<std::complex<double>>();
diff --git a/test/test_students_t.cpp b/test/test_students_t.cpp
index 59e3fc1860..ad4dc4187b 100644
--- a/test/test_students_t.cpp
+++ b/test/test_students_t.cpp
@@ -21,6 +21,7 @@
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp> // Boost.Test
 #include <boost/test/tools/floating_point_comparison.hpp>
+#include <boost/math/special_functions/next.hpp>  // for has_denorm_now
 
 #include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/tools/test.hpp> // for real_concept
@@ -390,7 +391,7 @@ void test_spots(RealType)
          //
          // Bug cases:
          //
-         if (std::numeric_limits<RealType>::is_specialized && std::numeric_limits<RealType>::has_denorm)
+         if (std::numeric_limits<RealType>::is_specialized && boost::math::detail::has_denorm_now<RealType>())
          {
             BOOST_CHECK_THROW(boost::math::quantile(students_t_distribution<RealType>((std::numeric_limits<RealType>::min)() / 2), static_cast<RealType>(0.0025f)), std::overflow_error);
          }