diff --git a/include/automatic.hpp b/include/automatic.hpp
index 493ad37..38fe4b8 100644
--- a/include/automatic.hpp
+++ b/include/automatic.hpp
@@ -19,12 +19,11 @@
 
 #include <limits>
 #include <cstdint>     // (u)intmax_t,
-#include <type_traits> // true_type, false_type
+#include <type_traits> // true_type, false_type, is_same
 #include <boost/mpl/if.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
 
 #include "safe_common.hpp"
+#include "checked_result.hpp"
 #include "interval.hpp"
 #include "safe_range.hpp"
 
@@ -147,13 +146,13 @@ struct automatic {
         SAFE_NUMERIC_CONSTEXPR static const interval< max_t> r
             = operator+<max_t>(t, u);
 
-        SAFE_NUMERIC_CONSTEXPR static const max_t newmin = r.l.is_valid() ?
+        SAFE_NUMERIC_CONSTEXPR static const max_t newmin = r.l.no_exception() ?
             static_cast<max_t>(r.l)
         :
             std::numeric_limits<max_t>::min()
         ;
 
-        SAFE_NUMERIC_CONSTEXPR static const max_t newmax = r.u.is_valid() ?
+        SAFE_NUMERIC_CONSTEXPR static const max_t newmax = r.u.no_exception() ?
             static_cast<max_t>(r.u)
         :
             std::numeric_limits<max_t>::max()
@@ -209,25 +208,24 @@ struct automatic {
         };
 
         typedef calculate_max_t<T, U> max_t;
+        // typedef typename print<max_t>::type p_max_t;
 
         SAFE_NUMERIC_CONSTEXPR static const interval< max_t> r
             = operator-<max_t>(t, u);
 
-        SAFE_NUMERIC_CONSTEXPR static const max_t newmin = r.l.is_valid() ?
+        SAFE_NUMERIC_CONSTEXPR static const max_t newmin = r.l.no_exception() ?
             static_cast<max_t>(r.l)
         :
             std::numeric_limits<max_t>::min()
         ;
+        // typedef print<std::integral_constant<max_t, newmin>> p_newmin;
 
-        SAFE_NUMERIC_CONSTEXPR static const max_t newmax = r.u.is_valid() ?
+        SAFE_NUMERIC_CONSTEXPR static const max_t newmax = r.u.no_exception() ?
             static_cast<max_t>(r.u)
         :
             std::numeric_limits<max_t>::max()
         ;
-
-        // typedef typename print<max_t>::type p_max_t;
-        // typedef typename print<std::integral_constant<max_t, newmin>>::type p_newmin;
-        // typedef typename print<std::integral_constant<max_t, newmax>>::type p_newmax;
+        // typedef print<std::integral_constant<max_t, newmax>> p_newmax;
 
         static_assert(
             newmin < newmax,
@@ -268,13 +266,13 @@ struct automatic {
         SAFE_NUMERIC_CONSTEXPR static const interval< max_t> r
             = operator*<max_t>(t, u);
 
-        SAFE_NUMERIC_CONSTEXPR static const max_t newmin = r.l.is_valid() ?
+        SAFE_NUMERIC_CONSTEXPR static const max_t newmin = r.l.no_exception() ?
             static_cast<max_t>(r.l)
         :
             std::numeric_limits<max_t>::min()
         ;
 
-        SAFE_NUMERIC_CONSTEXPR static const max_t newmax = r.u.is_valid() ?
+        SAFE_NUMERIC_CONSTEXPR static const max_t newmax = r.u.no_exception() ?
             static_cast<max_t>(r.u)
         :
             std::numeric_limits<max_t>::max()
@@ -304,23 +302,197 @@ struct automatic {
     };
     template<typename T, typename U, typename P, typename E>
     struct division_result {
-        typedef typename base_type<T>::type t_base_type;
-        typedef typename base_type<U>::type u_base_type;
-        SAFE_NUMERIC_CONSTEXPR static const interval<t_base_type> t = {
+        typedef typename base_type<T>::type base_type_t;
+        static_assert(
+            std::is_literal_type< interval<base_type_t> >::value,
+            "interval<base_type_t> is not literal type"
+        );
+        typedef typename base_type<U>::type base_type_u;
+        static_assert(
+            std::is_literal_type< interval<base_type_u> >::value,
+            "interval<base_type_u> is not tliteral type"
+        );
+
+        SAFE_NUMERIC_CONSTEXPR static interval<base_type_t> t(){
+            return interval<base_type_t>(
+                base_value(std::numeric_limits<T>::min()),
+                base_value(std::numeric_limits<T>::max())
+            );
+        };
+        SAFE_NUMERIC_CONSTEXPR static interval<base_type_u> u(){
+            return interval<base_type_u>(
+                base_value(std::numeric_limits<U>::min()),
+                base_value(std::numeric_limits<U>::max())
+            );
+        };
+        /*
+        SAFE_NUMERIC_CONSTEXPR static const interval<base_type_t> t = {
             base_value(std::numeric_limits<T>::min()),
             base_value(std::numeric_limits<T>::max())
         };
-        SAFE_NUMERIC_CONSTEXPR static const interval<u_base_type> u = {
+        SAFE_NUMERIC_CONSTEXPR static const interval<base_type_u> u = {
             base_value(std::numeric_limits<U>::min()),
             base_value(std::numeric_limits<U>::max())
         };
-        typedef decltype(t_base_type() / u_base_type()) r_base_type;
+        */
 
-        SAFE_NUMERIC_CONSTEXPR static const interval<r_base_type> r
-            = operator/<r_base_type>(t, u);
+        /*
+        typedef calculate_max_t<T, U> max_t;
+        //typedef print<max_t> p_max_t;
+        */
+        using max_t = typename boost::mpl::if_c<
+            std::numeric_limits<base_type_t>::is_signed
+            || std::numeric_limits<base_type_u>::is_signed,
+            std::intmax_t,
+            std::uintmax_t
+        >::type;
 
-        typedef safe_base<r_base_type, r.l, r.u, P, E> type;
+        template<typename Tx>
+        SAFE_NUMERIC_CONSTEXPR static const interval<Tx> r_upper(const interval<Tx> & t){
+            static_assert(
+                std::is_literal_type< interval<Tx> >::value,
+                "interval<Tx> is not literal type"
+            );
+            return interval<Tx>(
+                max(checked_result<Tx>(1), t.l),
+                t.u
+            );
+        }
+        template<typename Tx>
+        SAFE_NUMERIC_CONSTEXPR static const interval<Tx> r_lower(const interval<Tx> & t){
+            static_assert(
+                std::is_literal_type< interval<Tx> >::value,
+                "interval<Tx> is not literal type"
+            );
+            return interval<Tx>(
+                t.l,
+                min(checked_result<Tx>(-1), t.u)
+            );
+        }
+
+        // result unsigned
+        template<class R, typename Tx, typename Ux>
+        static typename boost::enable_if_c<
+            ! std::numeric_limits<Ux>::is_signed,
+            const interval<R>
+        >::type
+        SAFE_NUMERIC_CONSTEXPR r(
+            const interval<Tx> & t,
+            const interval<Ux> & u
+        ){
+            if(u.l > 0)
+                return operator/<R>(t, u);
+            else
+                return operator/<R>(t, r_upper(u)) ;
+        };
+
+        // result signed
+        template<class R, typename Tx, typename Ux>
+        static typename boost::enable_if_c<
+            std::numeric_limits<Ux>::is_signed,
+            const interval<R>
+        >::type
+        SAFE_NUMERIC_CONSTEXPR r(
+            const interval<Tx> & t,
+            const interval<Ux> & u
+        ){
+            if(u.l > 0 || u.u < 0){
+                auto retval = operator/<R>(t, u);
+                return retval;
+            }
+            else{
+                auto lower = operator/<R>(t,r_lower(u));
+                auto upper = operator/<R>(t,r_upper(u));
+                return
+                    interval<R>(
+                        min(lower.l, upper.l),
+                        max(lower.u, upper.u)
+                    );
+            }
+        }
+
+        /*
+        template<typename Tx, typename Ux>
+        SAFE_NUMERIC_CONSTEXPR static const interval<max_t> r(
+            const interval<Tx> & t,
+            const interval<Ux> & u
+        ){
+            typedef print<Tx> p_Tx_t;
+            typedef print<Ux> p_Ux_t;
+            if(std::numeric_limits<Ux>::is_signed){
+                typedef print<max_t> p_max_t;
+                static_assert(
+                    std::numeric_limits<max_t>::is_signed,
+                    "signed type expected"
+                );
+                if(u.l > 0 || u.u < 0){
+                    auto retval = operator/<max_t>(t, u);
+                    // typedef print<decltype(retval)> p_retval;
+                    return retval;
+                    //return operator/<max_t>(t, u);
+                }
+                else{
+                    auto lower = operator/<max_t>(t,r_lower(u));
+                    // typedef print<decltype(lower)> p_lower;
+                    auto upper = operator/<max_t>(t,r_upper(u));
+                    // typedef print<decltype(upper)> p_lower;
+                    return
+                        interval< max_t>(
+                            min(lower.l, upper.l),
+                            max(lower.u, upper.u)
+                        );
+                }
+            }
+            else{ // u is unsigned
+                if(u.l > 0)
+                    return operator/<max_t>(t, u);
+                else
+                    return operator/<max_t>(t, r_upper(u)) ;
+            };
+        };
+        */
+
+        //typedef print<std::integral_constant<bool,  (u.l > 0) >> p_ulgt0;
+        //typedef print<std::integral_constant<bool,  (u.u < 0) >> p_uult0;
+
+        constexpr const static interval<max_t> ni = r<max_t>(t(), u());
+
+        //static_assert(ni.l.no_exception(), "invalid lower bound");
+        //static_assert(ni.u.no_exception(), "invalid upper bound");
+
+        SAFE_NUMERIC_CONSTEXPR static const max_t newmin = ni.l.no_exception() ?
+            static_cast<max_t>(ni.l)
+        :
+            std::numeric_limits<max_t>::min()
+        ;
+        //typedef print<std::integral_constant<max_t, newmin>> p_newmin;
+
+        SAFE_NUMERIC_CONSTEXPR static const max_t newmax = ni.u.no_exception() ?
+            static_cast<max_t>(ni.u)
+        :
+            std::numeric_limits<max_t>::max()
+        ;
+        //typedef print<std::integral_constant<max_t, newmax>> p_newmax;
+
+        static_assert(
+            newmin <= newmax,
+            "new minimumum must be less than new maximum"
+        );
+
+        static_assert(
+            std::numeric_limits<max_t>::min() >= 0 || std::is_signed<max_t>::value,
+            "newmin < 0 and unsigned can't happen"
+        );
+
+        typedef typename safe_range<
+            max_t,
+            newmin,
+            newmax,
+            P,
+            E
+        >::type type;
     };
+
     template<typename T, typename U, typename P, typename E>
     struct modulus_result {
         typedef typename base_type<T>::type t_base_type;
diff --git a/include/checked.hpp b/include/checked.hpp
index 5f4b38d..5f10fc9 100644
--- a/include/checked.hpp
+++ b/include/checked.hpp
@@ -16,9 +16,11 @@
 // C++ types.
 
 #include <limits>
-#include <type_traits> // is_integral
+#include <type_traits> // is_integral, make_unsigned
 
 #include <boost/utility/enable_if.hpp>
+#include <boost/integer.hpp>
+#include <boost/mpl/if.hpp>
 
 #include "safe_common.hpp"
 #include "checked_result.hpp"
@@ -455,42 +457,514 @@ SAFE_NUMERIC_CONSTEXPR checked_result<R> multiply(
 
 ////////////////////////////////
 // safe division on unsafe types
+
 namespace detail {
 
-template<class R>
+template<class R, class T, class U>
 typename boost::enable_if_c<
-    std::is_unsigned<R>::value,
+    ! std::is_signed<T>::value && ! std::is_signed<U>::value,
     checked_result<R>
 >::type
 SAFE_NUMERIC_CONSTEXPR divide(
-    const R & minr,
-    const R & maxr,
-    const R t,
-    const R u
-) {
+    const T & t,
+    const U & u
+){
     return checked_result<R>(t / u);
 }
 
-template<class R>
+template<class R, class T, class U>
 typename boost::enable_if_c<
-    std::is_signed<R>::value,
+    std::is_signed<T>::value && std::is_signed<U>::value,
     checked_result<R>
 >::type
 SAFE_NUMERIC_CONSTEXPR divide(
-    const R & minr,
-    const R & maxr,
-    const R t,
-    const R u
+    const T & t,
+    const U & u
 ){
     return
-        // note presumption of two's complement arithmetic
-        (u < 0 && t == std::numeric_limits<R>::min()) ?
+        (u == -1 && t == std::numeric_limits<R>::min()) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "result cannot be represented"
+            )
+        :
+            checked_result<R>(static_cast<R>(t) / u)
+    ;
+}
+
+template<class R, class T, class U>
+typename boost::enable_if_c<
+    ! std::is_signed<T>::value && std::is_signed<U>::value,
+    checked_result<R>
+>::type
+SAFE_NUMERIC_CONSTEXPR divide(
+    const T & t,
+    const U & u
+){
+    return
+        (u >= 0) ?
+            checked_result<R>(t / static_cast<std::make_unsigned_t<U>>(u))
+        :
+        (u == -1) ?
+            (u == std::numeric_limits<R>::min()) ?
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "result cannot be represented"
+                )
+            :
+                checked_result<R>(- (t / -u))
+        :
+        // u < -1
+            checked_result<R>(t / u)
+    ;
+}
+
+template<class R, class T, class U>
+typename boost::enable_if_c<
+    std::is_signed<T>::value && ! std::is_signed<U>::value,
+    checked_result<R>
+>::type
+SAFE_NUMERIC_CONSTEXPR divide(
+    const T & t,
+    const U & u
+){
+    return
+        checked_result<R>(t / u);
+    ;
+}
+
+} // detail
+
+template<class R, class T, class U>
+checked_result<R>
+SAFE_NUMERIC_CONSTEXPR divide(
+    const T & t,
+    const U & u
+){
+    const checked_result<R> rt = cast<R>(t);
+    const checked_result<R> ru = cast<R>(u);
+    return
+        (u == 0) ?
             checked_result<R>(
                 exception_type::domain_error,
                 "divide by zero"
             )
         :
+            detail::divide<R>(
+                static_cast<R>(rt),
+                static_cast<R>(ru)
+    ;
+}
+
+
+#if 0
+
+            checked_result<R>(t / u) // > 0
+        :
+        (u == 0) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
+        :
+        // (u < 0)
+            (u > -t) ?
+                checked_result<R>(0)
+            :
+            //(u <= -t) ?
+                checked_result<R>(t / u) // < 0
+        : // u unsigned
+            checked_result<R>(
+                exception_type::static_assertion,
+                "impossible to arrive here"
+            )
+        (u == 0) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
+        : // u > 0
             checked_result<R>(t / u)
+    ;
+}
+template<class R, class T, class U>
+checked_result<R>
+SAFE_NUMERIC_CONSTEXPR divide(
+    const T & t,
+    const U & u
+){
+    static_assert(std::is_integral<T>::value, "only intrinsic integers permitted");
+    static_assert(std::is_integral<U>::value, "only intrinsic integers permitted");
+    return
+    (t >= 0) ?
+        (u > t) ?
+            checked_result<R>(0)
+        :
+        (u > 0) ?
+            checked_result<R>(t / u) // > 0
+        :
+        (u == 0) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
+        :
+        // (u < 0)
+        (std::numeric_limits<U>::is_signed) ?
+            (u > -t) ?
+                checked_result<R>(0)
+            :
+            //(u <= -t) ?
+                checked_result<R>(t / u) // < 0
+        : // u unsigned
+            checked_result<R>(
+                exception_type::static_assertion,
+                "impossible to arrive here"
+            )
+    : (t >= std::numeric_limits<T>::min() / 2) ?
+        (std::numeric_limits<U>::is_signed) ?
+            (u < t) ?
+                checked_result<R>(0)
+            :
+            (u < -1) ?
+                (t == std::numeric_limits<R>::min()) ?
+                    checked_result<R>(
+                        exception_type::domain_error,
+                        "divide by zero"
+                    )
+                :
+                    checked_result<R>(t / u) // > 0
+            :
+            (u == 0) ?
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "divide by zero"
+                )
+            :
+            // (u > 0)
+                checked_result<R>(-(-t / u))
+                checked_result<R>(static_cast<R>(t))
+        :
+        // u not signed
+            (u == 0) ?
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "divide by zero"
+                )
+            :
+            //(u > 0)
+                checked_result<R>(-(-t / u))
+        ;
+}
+
+
+            (u < t) ?
+                checked_result<R>(0)
+            :
+            (u < -1) ?
+                checked_result<R>(t / u) // > 0
+            :
+            // only can happen with twos complement machines
+            (u == -1)
+            && t == std::numeric_limits<R>::min() ?
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "result unrepresentable"
+                )
+            :
+            (u == 0) ?
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "divide by zero"
+                )
+            : // u > 0
+                checked_result<R>(t / u)
+
+template<class R, class T, class U>
+checked_result<R>
+SAFE_NUMERIC_CONSTEXPR ugt0(
+    const T & t,
+    const U & u
+){
+    //typedef print<std::integral_constant<U, u> > p_u;
+    return checked_result<R>(t / u);
+}
+
+template<class R, class T, class U>
+checked_result<R>
+SAFE_NUMERIC_CONSTEXPR divide(
+    const T & t,
+    const U & u
+){
+    static_assert(std::is_integral<T>::value, "only intrinsic integers permitted");
+    static_assert(std::is_integral<U>::value, "only intrinsic integers permitted");
+    return
+    safe_compare::greater_than(t, 0) ? // (t > 0) ?
+        safe_compare::greater_than(u, t) ? // (u > t) ?
+            checked_result<R>(0)
+        :
+        safe_compare::greater_than(u, 0) ? // (u > 0) ?
+            checked_result<R>(t / u) // > 0
+        :
+        safe_compare::equal(u, 0) ? // (u == 0) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
+        :
+        // (u < 0)
+        (std::numeric_limits<R>::is_signed) ?
+            safe_compare::greater_than(u, -t) ? //(u > -t) ?
+                checked_result<R>(0)
+            :
+            //(u <= -t) ?
+                checked_result<R>(t / u) // < 0
+        :
+            checked_result<R>(
+                exception_type::static_assertion,
+                "impossible to arrive here"
+            )
+    : // (t <= 0)
+        (std::numeric_limits<U>::is_signed) ?
+            safe_compare::less_than(u, t) ? // (u < t) ?
+                checked_result<R>(0)
+            :
+            safe_compare::less_than(u, -1) ? // (u < -1) ?
+                checked_result<R>(t / u) // > 0
+            :
+            // only can happen with twos complement machines
+            safe_compare::equal(u, -1)
+            && safe_compare::equal(t, std::numeric_limits<R>::min()) ?
+            //(u == -1 && t == std::numeric_limits<R>::min()) ?
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "result unrepresentable"
+                )
+            :
+            safe_compare::equal(u, 0) ? // (u == 0)
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "divide by zero"
+                )
+            : // u > 0
+                checked_result<R>(checked::cast<R>(t) / u)
+        :
+        // u not signed
+        // (u <= -t) <=> -u >= t
+            safe_compare::greater_than(-u, t) ?
+                checked_result<R>(t / u)
+            :
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "result unrepresentable"
+                )
+        ;
+        //: // u > -t <=> -u < t
+         //   checked_result<R>(0);
+            // not cast so that something like
+            // (signed_char)(-128) doesn't get transformed to +128 which
+            // is not representable by a signed char.  Here it will get
+            // transformed to a type (R)(+128).  At compile time R is
+            // std::intmax_t which will hold +128 no problem.
+            // At runtime - R will be some value.  If R can't hold -t then
+            // we want to invoke a runtime trap so let it fail.
+            //checked_result<R>(static_cast<R>(t) / u)
+            //ugt0<R>(t, u
+}
+
+namespace detail {
+
+template<class R>
+checked_result<R>
+SAFE_NUMERIC_CONSTEXPR divide(
+    const R & t,
+    const R & u
+){
+    return
+    (t > 0) ?
+        (u > t) ?
+            checked_result<R>(0)
+        :
+        (u > 0) ?
+            checked_result<R>(t / u) // > 0
+        :
+        (u == 0) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
+        :
+        (std::numeric_limits<R>::is_signed) ?
+            (u > -t) ?
+                checked_result<R>(0)
+            :
+            //(u <= -t) ?
+                checked_result<R>(t / u) // < 0
+        :
+            checked_result<R>(
+                exception_type::static_assertion,
+                "impossible to arrive here"
+            )
+    : // (t <= 0)
+        (u < t) ?
+            checked_result<R>(0)
+        :
+        (u < -1) ?
+            checked_result<R>(t / u) // > 0
+        :
+        // only can happen with twos complement machines
+        (u == -1 && t == std::numeric_limits<R>::min()) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "result unrepresentable"
+            )
+        :
+        (u == 0) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
+        :
+        // (u <= -t)
+        (-u > t) ?
+            std::numeric_limits<R>::is_signed ?
+                checked_result<R>(t / u) // < 0
+            :
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "result unrepresentable"
+                )
+        :
+        // u > -t
+            checked_result<R>(0)
+    ;
+}
+
+} // detail
+
+template<class R, class T, class U>
+checked_result<R>
+SAFE_NUMERIC_CONSTEXPR divide(
+    const T & t,
+    const U & u
+){
+    const checked_result<R> rt = cast<R>(t);
+    if(! rt.no_exception())
+        return checked_result<R>(rt.m_e, rt.m_msg);
+
+    const checked_result<R> ru = cast<R>(u);
+    if(! ru.no_exception())
+        return checked_result<R>(ru.m_e, ru.m_msg);
+    return
+        detail::divide(
+            static_cast<R>(rt),
+            static_cast<R>(ru)
+        );
+}
+
+template<class R, class T, class U>
+checked_result<R>
+SAFE_NUMERIC_CONSTEXPR divide(
+    const R & minr,
+    const R & maxr,
+    const T & t,
+    const U & u
+){
+    return
+    (t > 0) ?
+        safe_compare::greater_than(u,t) ? // u > t
+            checked_result<R>(0)
+        :
+        safe_compare::greater_than(u,0) ? // u > 0
+            checked_result<R>(t / u) // > 0
+        :
+        safe_compare::equal(u, 0) ? // u == 0
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
+        :
+        safe_compare::less_than_equal(-u, t) // u >= -t ie  -u <= t
+        && (! std::numeric_limits<R>::is_signed) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "result unrepresentable"
+            )
+        :
+        //(u < -t) ?
+            checked_result<R>(0)
+    : // (t <= 0)
+        safe_compare::less_than(u,t) ? // u < t
+            checked_result<R>(0)
+        :
+        safe_compare::less_than(u,-1) ? // u < -1
+            checked_result<R>(t / u) // > 0
+        :
+        safe_compare::equal(u, -1)
+        && safe_compare::equal(t, std::numeric_limits<R>::min()) ?
+        //(u == -1 && t == std::numeric_limits<T>::min()) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "result unrepresentable"
+            )
+        :
+        safe_compare::equal(u,0) ? // u == 0
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
+        :
+        // (u <= -t)
+        safe_compare::greater_than(-u, t) ?
+        // (-u > t) ?
+            std::numeric_limits<R>::is_signed ?
+                checked_result<R>(t / u) // < 0
+            :
+                checked_result<R>(
+                    exception_type::domain_error,
+                    "result unrepresentable"
+                )
+        :
+        // u > -t
+            checked_result<R>(0)
+    ;
+}
+
+namespace detail {
+
+template<class R, class T, class U>
+typename boost::enable_if_c<
+    ! std::is_signed<T>::value || ! std::is_signed<U>::value,
+    checked_result<R>
+>::type
+SAFE_NUMERIC_CONSTEXPR divide(
+    const R & minr,
+    const R & maxr,
+    const T & t,
+    const U & u
+) {
+    return checked_result<R>(t / u);
+}
+
+template<class R, class T, class U>
+typename boost::enable_if_c<
+    std::is_signed<T>::value && std::is_signed<U>::value,
+    checked_result<R>
+>::type
+SAFE_NUMERIC_CONSTEXPR divide(
+    const R & minr,
+    const R & maxr,
+    const T & t,
+    const U & u
+){
+    return
+        (u == -1 && t == minr)  ? // special case - could overflow !!!
+            checked_result<R>(
+                exception_type::domain_error,
+                "result unrepresentable"
+            )
+        :
+            checked_result<R>(t / u);
         ;
 }
 
@@ -505,22 +979,27 @@ SAFE_NUMERIC_CONSTEXPR checked_result<R> divide(
 ) {
     static_assert(std::is_integral<T>::value, "only intrinsic integers permitted");
     static_assert(std::is_integral<U>::value, "only intrinsic integers permitted");
+    // typedef print<std::integral_constant<T, t>> p_t;
+    // typedef print<std::integral_constant<U, u> > p_u;
     return
         cast<R>(t) != exception_type::no_exception ?
             cast<R>(t)
         :
-        cast<R>(u) != exception_type::no_exception ?
-            cast<R>(u)
+        // cast<R>(u) != exception_type::no_exception ?
+        //     cast<R>(u)
+        // :
+        (u == 0) ?
+            checked_result<R>(
+                exception_type::domain_error,
+                "divide by zero"
+            )
         :
-            u == 0 ?
-                checked_result<R>(
-                    exception_type::domain_error,
-                    "divide by zero"
-                )
-            :
-                detail::divide<R>(minr, maxr, t, u)
+            detail::divide(minr, maxr, t, u)
+        ;
     ;
 }
+
+/*
 template<class R, class T, class U>
 SAFE_NUMERIC_CONSTEXPR checked_result<R> divide(
     const T & t,
@@ -535,9 +1014,13 @@ SAFE_NUMERIC_CONSTEXPR checked_result<R> divide(
         )
     ;
 }
+*/
+#endif
 
 ////////////////////////////////
 // safe modulus on unsafe types
+
+/*
 namespace detail {
 
 template<class R>
@@ -618,7 +1101,7 @@ SAFE_NUMERIC_CONSTEXPR checked_result<R> modulus(
         )
     ;
 }
-
+*/
 ///////////////////////////////////
 // shift operations
 
@@ -641,7 +1124,7 @@ SAFE_NUMERIC_CONSTEXPR checked_result<R> check_shift(
     const checked_result<R> ru = cast<R>(u);
     // INT34-C C++ standard paragraph 5.8
     return
-        ( ! ru.is_valid()) ?
+        ( ! ru.no_exception()) ?
             ru
         :
         ( ru < 0) ?
@@ -670,7 +1153,7 @@ SAFE_NUMERIC_CONSTEXPR checked_result<R> left_shift(
 ) {
     const checked_result<R> r = detail::check_shift<R>(t, u);
     return
-        (! r.is_valid()) ?
+        (! r.no_exception()) ?
             r
         :
             checked_result<R>(static_cast<R>(r) << t);
@@ -685,7 +1168,7 @@ SAFE_NUMERIC_CONSTEXPR checked_result<R> right_shift(
 ) {
     const checked_result<R> r = detail::check_shift<R>(t, u);
     return
-        (! r.is_valid()) ?
+        (! r.no_exception()) ?
             r
         :
             checked_result<R>(static_cast<R>(r) >> t);
diff --git a/include/checked_result.hpp b/include/checked_result.hpp
index a818ebc..f6d061f 100644
--- a/include/checked_result.hpp
+++ b/include/checked_result.hpp
@@ -27,14 +27,15 @@ enum class exception_type {
     underflow_error,
     range_error,
     domain_error,
-    uninitialized
+    uninitialized,
+    static_assertion
 };
 
 template<typename R>
 struct checked_result {
 // poor man's variant which supports SAFE_NUMERIC_CONSTEXPR
-    const exception_type m_e;
-    const union {
+    exception_type m_e;
+    union {
         R m_r;
         char const * m_msg;
     };
@@ -56,30 +57,40 @@ struct checked_result {
         m_e(exception_type::uninitialized),
         m_r(0)
     {}
+    template<class T>
+    SAFE_NUMERIC_CONSTEXPR //explicit// checked_result(const checked_result<T> & t) :
+        m_e(t.m_e),
+        m_r(t.m_r)
+    {}
     */
+
     SAFE_NUMERIC_CONSTEXPR /*explicit*/ checked_result(const R & r) :
         m_e(exception_type::no_exception),
         m_r(r)
     {}
+
     SAFE_NUMERIC_CONSTEXPR /*explicit*/ checked_result(
         exception_type e,
-        const char * msg = nullptr
+        const char * msg
     ) :
         m_e(e),
         m_msg(msg)
     {}
+
     // accesors
     SAFE_NUMERIC_CONSTEXPR operator R() const {
        // assert(exception_type::no_exception == m_e);
         return m_r;
     }
+    /*
     SAFE_NUMERIC_CONSTEXPR operator exception_type() const {
         return m_e;
     }
     SAFE_NUMERIC_CONSTEXPR operator const char *() const {
-        assert(exception_type::no_exception != m_e);
+        // assert(exception_type::no_exception != m_e);
         return m_msg;
     }
+    */
 
     template<class T>
     SAFE_NUMERIC_CONSTEXPR boost::logic::tribool operator<(const checked_result<T> & t) const {
@@ -120,7 +131,7 @@ struct checked_result {
     SAFE_NUMERIC_CONSTEXPR bool operator!=(const exception_type & et) const {
         return m_e != et;
     }
-    SAFE_NUMERIC_CONSTEXPR bool is_valid() const {
+    SAFE_NUMERIC_CONSTEXPR bool no_exception() const {
         return m_e == exception_type::no_exception;
     }
 
@@ -195,7 +206,10 @@ SAFE_NUMERIC_CONSTEXPR inline const checked_result<R> min(
 }
 
 template<typename R>
-SAFE_NUMERIC_CONSTEXPR inline const checked_result<R> max(const checked_result<R> & t, const checked_result<R> & u){
+SAFE_NUMERIC_CONSTEXPR inline const checked_result<R> max(
+    const checked_result<R> & t,
+    const checked_result<R> & u
+){
     return
         (t.m_e == exception_type::no_exception
         && u.m_e == exception_type::no_exception) ?
@@ -225,25 +239,52 @@ std::ostream & operator<<(std::ostream & os, const boost::numeric::checked_resul
     if(r == boost::numeric::exception_type::no_exception)
         os << static_cast<R>(r);
     else
-        os << static_cast<const char *>(r);
+        os << r.m_msg; //static_cast<const char *>(r);
     return os;
 }
 
 template<>
 std::ostream & operator<<(std::ostream & os, const boost::numeric::checked_result<std::int8_t> & r){
     if(r == boost::numeric::exception_type::no_exception)
-        os << std::dec << static_cast<int>(r);
+        os << static_cast<std::int16_t>(r);
     else
-        os << static_cast<const char *>(r);
+        os << r.m_msg; //static_cast<const char *>(r);
     return os;
 }
 
+template<>
+std::ostream & operator<<(std::ostream & os, const boost::numeric::checked_result<std::uint8_t> & r){
+    if(r == boost::numeric::exception_type::no_exception)
+        os << static_cast<std::uint16_t>(r);
+    else
+        os << r.m_msg; //static_cast<const char *>(r);
+    return os;
+}
+
+/*
 template<typename R>
 std::istream & operator>>(std::istream & is, const boost::numeric::checked_result<R> & r){
     is >> r.m_r;
     return is;
 }
 
+template<typename R>
+std::istream & operator>>(std::istream & is, const boost::numeric::checked_result<std::int8_t> & r){
+    std::int16_t i;
+    is >> i;
+    r.m_r = i;
+    return is;
+}
+
+template<typename R>
+std::istream & operator>>(std::istream & is, const boost::numeric::checked_result<std::uint8_t> & r){
+    std::uint16_t i;
+    is >> i;
+    r.m_r = i;
+    return is;
+}
+*/
+
 } // std
 
 /////////////////////////////////////////////////////////////////
diff --git a/include/exception_policies.hpp b/include/exception_policies.hpp
index d163f7f..253ad7c 100644
--- a/include/exception_policies.hpp
+++ b/include/exception_policies.hpp
@@ -25,10 +25,10 @@ namespace numeric {
 // this would emulate the normal C/C++ behavior of permitting overflows
 // and the like.
 struct ignore_exception {
-    constexpr static void overflow_error(const char * message) {}
-    constexpr static void underflow_error(const char * message) {}
-    constexpr static void range_error(const char * message) {}
-    constexpr static void domain_error(const char * message) {}
+    static void overflow_error(const char * message) {}
+    static void underflow_error(const char * message) {}
+    static void range_error(const char * message) {}
+    static void domain_error(const char * message) {}
 };
 
 // example - if you want to specify specific behavior for particular exception
diff --git a/include/interval.hpp b/include/interval.hpp
index 23a87b9..6f79c80 100644
--- a/include/interval.hpp
+++ b/include/interval.hpp
@@ -14,9 +14,11 @@
 
 #include <limits>
 #include <cassert>
+#include <type_traits>
 
 #include <boost/logic/tribool.hpp>
 
+
 #include "checked_result.hpp"
 #include "checked.hpp"
 
@@ -25,33 +27,71 @@ namespace numeric {
 
 template<typename R>
 struct interval {
+    static_assert(
+        std::is_literal_type< checked_result<R> >::value,
+        "is literal type"
+    );
+
     const checked_result<R> l;
     const checked_result<R> u;
 
 /*
+    SAFE_NUMERIC_CONSTEXPR checked_result<R> get_l() const {
+        return l;
+    }
+    SAFE_NUMERIC_CONSTEXPR checked_result<R> get_u() const {
+        return u;
+    }
+    template<typename T, typename U>
+    SAFE_NUMERIC_CONSTEXPR interval(const T & lower, const U & upper) :
+        l(checked::cast<R>(lower)),
+        u(checked::cast<R>(upper))
+    {}
+    SAFE_NUMERIC_CONSTEXPR interval(
+        const R & lower,
+        const R & upper
+    ) :
+        l(checked_result<R>(lower)),
+        u(checked_result<R>(upper))
+    {}
+    SAFE_NUMERIC_CONSTEXPR interval(const interval<R> & rhs) :
+        l(rhs.l),
+        u(rhs.u)
+    {}
+    template<class T>
+    SAFE_NUMERIC_CONSTEXPR interval(
+        const T & lower,
+        const T & upper
+    ) :
+        l(checked_result<T>(lower)),
+        u(checked_result<T>(upper))
+    {}
     template<typename T, typename U>
     SAFE_NUMERIC_CONSTEXPR interval(const T & lower, const U & upper) :
         l(checked::cast<R>(lower)),
         u(checked::cast<R>(upper))
     {}
 */
-    SAFE_NUMERIC_CONSTEXPR interval(
-        const checked_result<R> & lower,
-        const checked_result<R> & upper
-    ) :
-        l(checked_result<R>(lower)),
-        u(checked_result<R>(upper))
+    template<typename T>
+    SAFE_NUMERIC_CONSTEXPR interval(const T & lower, const T & upper) :
+        l(checked::cast<R>(lower)),
+        u(checked::cast<R>(upper))
     {}
-    SAFE_NUMERIC_CONSTEXPR interval(const R & lower, const R & upper) :
-        l(checked_result<R>(lower)),
-        u(checked_result<R>(upper))
-    {}
-    /*
-    SAFE_NUMERIC_CONSTEXPR interval(const interval<R> & rhs) :
+    template<class T>
+    SAFE_NUMERIC_CONSTEXPR interval(const interval<T> & rhs) :
         l(rhs.l),
         u(rhs.u)
     {}
-    */
+    template<class T>
+    SAFE_NUMERIC_CONSTEXPR interval(
+        const checked_result<T> & lower,
+        const checked_result<T> & upper
+    ) :
+        //l(checked::cast<R>(lower)),
+        l(lower),
+        //u(checked::cast<R>(upper))
+        u(upper)
+    {}
 
     SAFE_NUMERIC_CONSTEXPR interval() :
         l(std::numeric_limits<R>::min()),
@@ -120,7 +160,10 @@ SAFE_NUMERIC_CONSTEXPR interval<R> operator*(const interval<T> & t, const interv
 }
 
 template<typename R, typename T, typename U>
-SAFE_NUMERIC_CONSTEXPR interval<R> operator/(const interval<T> & t, const interval<U> & u){
+SAFE_NUMERIC_CONSTEXPR inline interval<R> operator/(
+    const interval<T> & t,
+    const interval<U> & u
+){
     // adapted from https://en.wikipedia.org/wiki/Interval_arithmetic
     return
         (u.l <= 0 && u.u >= 0) ?
@@ -255,7 +298,7 @@ namespace std {
 
 template<typename T>
 std::ostream & operator<<(std::ostream & os, const boost::numeric::interval<T> & i){
-    os << "[" << i.l << "," << i.u << "]" << std::endl;
+    os << "[" << i.l << "," << i.u << "]";
     return os;
 }
 
diff --git a/include/safe_base.hpp b/include/safe_base.hpp
index b9cf8df..e922742 100644
--- a/include/safe_base.hpp
+++ b/include/safe_base.hpp
@@ -179,7 +179,6 @@ public:
     SAFE_NUMERIC_CONSTEXPR safe_base(const checked_result<T> & t) :
         m_t(static_cast<Stored>(t))
     {}
-    */
     template<class T>
     SAFE_NUMERIC_CONSTEXPR safe_base(const T & t) :
         m_t(static_cast<Stored>(t))
@@ -188,6 +187,14 @@ public:
             E::range_error("Invalid value");
         }
     }
+    */
+    template<class T>
+    SAFE_NUMERIC_CONSTEXPR safe_base(const T & t) :
+        m_t(t)
+    {
+        if(!validate(t))
+            E::range_error("Invalid value");
+    }
 
     template<class T, T MinT, T MaxT, class PT, class ET>
     SAFE_NUMERIC_CONSTEXPR safe_base(const safe_base<T, MinT, MaxT, PT, ET> & t);
diff --git a/include/safe_base_operations.hpp b/include/safe_base_operations.hpp
index a3154de..292658b 100644
--- a/include/safe_base_operations.hpp
+++ b/include/safe_base_operations.hpp
@@ -485,7 +485,7 @@ typename boost::lazy_enable_if<
     >,
     division_result<T, U>
 >::type
-inline operator/(const T & t, const U & u){
+SAFE_NUMERIC_CONSTEXPR operator/(const T & t, const U & u){
     // argument dependent lookup should guarentee that we only get here
     // only if one of the types is a safe type. Verify this here
     typedef division_result<T, U> dr;
@@ -497,8 +497,11 @@ inline operator/(const T & t, const U & u){
     );
 
     typedef typename base_type<result_type>::type result_base_type;
+    // typedef print<result_base_type> p_result_base_type;
     typedef typename base_type<T>::type t_base_type;
+    // typedef print<t_base_type> p_t_base_type;
     typedef typename base_type<U>::type u_base_type;
+    // typedef print<u_base_type> p_u_base_type;
 
     // filter out case were overflow cannot occur
     SAFE_NUMERIC_CONSTEXPR const interval<t_base_type> t_interval = {
@@ -510,17 +513,25 @@ inline operator/(const T & t, const U & u){
             base_value(std::numeric_limits<U>::max())
         };
 
+    // when we divide the temporary intervals above, we'll get a new interval
+    // with the correct range for the result!
     SAFE_NUMERIC_CONSTEXPR const interval<result_base_type> r_interval
         = operator/<result_base_type>(t_interval, u_interval);
 
-    // if no over/under flow possible
-    if(r_interval.no_exception())
-        return result_type(base_value(t) / base_value(u));
+    // if no over/under flow or domain error possible
+    if(r_interval.no_exception()
+    // and if the denominator cannot contain zero
+    && (u_interval.l <= 0 && u_interval.u >=0 )
+    )
+        // we can just invoke the operation and return - even at compile
+        // time since this is a constexpr !
+        return result_type(
+            static_cast<result_base_type>(base_value(t))
+            / static_cast<result_base_type>(base_value(u))
+        );
 
     // otherwise do the division checking for overflow
-    checked_result<result_base_type>  r = checked::divide(
-        base_value(std::numeric_limits<result_type>::min()),
-        base_value(std::numeric_limits<result_type>::max()),
+    checked_result<result_base_type>  r = checked::divide<result_base_type>(
         base_value(t),
         base_value(u)
     );
@@ -532,6 +543,7 @@ inline operator/(const T & t, const U & u){
 
 /////////////////////////////////////////////////////////////////
 // modulus
+/*
 
 template<class T, class U>
 struct modulus_result {
@@ -595,7 +607,7 @@ inline operator%(const T & t, const U & u){
     r.template dispatch<exception_policy>();
     return result_type(static_cast<result_base_type>(r));
 }
-
+*/
 /////////////////////////////////////////////////////////////////
 // comparison
 
diff --git a/include/safe_range.hpp b/include/safe_range.hpp
index f31d2a6..32c4cc2 100644
--- a/include/safe_range.hpp
+++ b/include/safe_range.hpp
@@ -14,7 +14,6 @@
 
 #include <cstdint> // intmax_t, uintmax_t
 #include <boost/integer.hpp> // (u)int_t<>::least, exact
-#include <boost/mpl/max.hpp>
 
 #include "safe_base.hpp"
 #include "safe_base_operations.hpp"
diff --git a/test/test_automatic.cpp b/test/test_automatic.cpp
new file mode 100644
index 0000000..2b8dcfe
--- /dev/null
+++ b/test/test_automatic.cpp
@@ -0,0 +1,105 @@
+#include <iostream>
+#include <cstdint>
+#include <limits>
+#include <cxxabi.h>
+
+#include "../include/automatic.hpp"
+
+/*
+namespace boost { namespace numeric {
+
+struct automatic {
+    template<typename T, typename U, typename P, typename E>
+    struct division_result {
+        static const T t = '0';
+        static const U u = 31;
+    };
+};
+
+} // numeric
+} // boost
+*/
+
+template<typename T, typename U>
+bool test(){
+    int status;
+    const std::type_info & ti_t = typeid(T);
+    const std::type_info & ti_u = typeid(U);
+    std::cout
+        << "test<"
+        << abi::__cxa_demangle(ti_t.name(),0,0,&status)
+        << ','
+        << abi::__cxa_demangle(ti_u.name(),0,0,&status)
+        << ">\n";
+    using namespace boost::numeric;
+    
+    using division_result_alias = automatic::division_result<
+        T, U, automatic, void
+    >;
+
+    const auto t = division_result_alias::t();
+    const auto u = division_result_alias::u();
+
+    std::cout << "t = " << t << '\n';
+    std::cout << "u = " << u << '\n';
+
+    if(std::numeric_limits<U>::is_signed)
+        std::cout << "r_lower(u()) = " << division_result_alias::r_lower(u) << '\n';
+    std::cout << "r_upper(u()) = " << division_result_alias::r_upper(u) << '\n';
+
+    using max_t = typename division_result_alias::max_t;
+    std::cout << division_result_alias::template r<max_t>(t, u) << '\n';
+    return true;
+}
+
+#include "test.hpp"
+
+#define VALUES (8, ( \
+    std::int8_t,    \
+    std::int16_t,   \
+    std::int32_t,   \
+    std::int64_t,   \
+    std::uint8_t,   \
+    std::uint16_t,  \
+    std::uint32_t,  \
+    std::uint64_t   \
+))
+
+const char *test_result[VALUE_ARRAY_SIZE] = {
+//      01234567
+/* 0*/ "........",
+/* 1*/ "........",
+/* 2*/ "........",
+/* 3*/ "........",
+/* 4*/ "........",
+/* 5*/ "........",
+/* 6*/ "........",
+/* 7*/ "........"
+};
+
+#define TEST_IMPL(v1, v2, result) \
+    rval &= test<v1, v2>();
+/**/
+
+#define TESTX(value_index1, value_index2)          \
+    (std::cout << value_index1 << ',' << value_index2 << ','); \
+    TEST_IMPL(                                     \
+        BOOST_PP_ARRAY_ELEM(value_index1, VALUES), \
+        BOOST_PP_ARRAY_ELEM(value_index2, VALUES), \
+        test_result[value_index1][value_index2]() \
+    )
+/**/
+
+#if 0
+int main(){
+    test<std::int8_t, std::uint8_t>();
+    return 0;
+}
+#else
+int main(){
+    bool rval = true;
+    TEST_EACH_VALUE_PAIR
+    return ! rval ;
+}
+#endif
+
diff --git a/test/test_checked_cast.cpp b/test/test_checked_cast.cpp
index d25453f..a9b1d39 100644
--- a/test/test_checked_cast.cpp
+++ b/test/test_checked_cast.cpp
@@ -24,7 +24,7 @@ bool test_cast(
 
     boost::numeric::checked_result<T2> r2 = boost::numeric::checked::cast<T2>(v1);
 
-    if(expected_result == 'x' && r2.is_valid()){
+    if(expected_result == 'x' && r2.no_exception()){
         std::cout
             << "failed to detect error in construction "
             << t2_name << "<-" << t1_name
@@ -32,7 +32,7 @@ bool test_cast(
         boost::numeric::checked::cast<T2>(v1);
         return false;
     }
-    if(expected_result == '.' && ! r2.is_valid()){
+    if(expected_result == '.' && ! r2.no_exception()){
         std::cout
             << "erroneously emitted error "
             << t2_name << "<-" << t1_name
diff --git a/test/test_checked_divide.cpp b/test/test_checked_divide.cpp
new file mode 100644
index 0000000..9173e97
--- /dev/null
+++ b/test/test_checked_divide.cpp
@@ -0,0 +1,148 @@
+//  Copyright (c) 2012 Robert Ramey
+//
+// 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)
+
+#include <exception>
+#include <cxxabi.h>
+#include <cstdlib>   // EXIT_SUCCESS
+#include <iostream>
+
+#include "../include/checked_result.hpp"
+#include "../include/checked.hpp"
+
+template<class T1, class T2>
+bool test_checked_divide(
+    T1 v1,
+    T2 v2,
+    const char *av1,
+    const char *av2,
+    char expected_result
+){
+    using namespace boost::numeric;
+
+    std::cout
+        << "testing  "
+        << av1 << " / " << av2
+        << std::endl;
+
+    typedef decltype(T1() / T2()) result_type;
+
+    checked_result<result_type> result = checked::divide<result_type>(
+        std::numeric_limits<result_type>::min(),
+        std::numeric_limits<result_type>::max(),
+        v1,
+        v2
+    );
+
+    if(result == exception_type::no_exception
+    && expected_result != '.'){
+        std::cout
+            << "failed to detect error in division "
+            << std::hex << "0x" << result << "(" << std::dec << result << ")"
+            << " != "<< av1 << " / " << av2
+            << std::endl;
+        result = checked::divide<result_type>(
+            std::numeric_limits<result_type>::min(),
+            std::numeric_limits<result_type>::max(),
+            v1,
+            v2
+        );
+        return false;
+    }
+    else
+    if(result != exception_type::no_exception
+    && expected_result != 'x'){
+        std::cout
+            << "erroneously detected error "
+            << std::hex << result <<  av1 << " / " << av2 << std::dec << std::endl;
+        result = checked::divide<result_type>(
+            std::numeric_limits<result_type>::min(),
+            std::numeric_limits<result_type>::max(),
+            v1,
+            v2
+        );
+        return false;
+    }
+    return true; // correct result
+}
+
+#include "test.hpp"
+#include "test_values.hpp"
+
+// note: same test matrix as used in test_divide.  Here we test all combinations
+// safe and unsafe integers.  in test_checked we test all combinations of
+// integer primitives
+
+const char *test_division_result[VALUE_ARRAY_SIZE] = {
+//      0       0       0       0
+//      01234567012345670123456701234567
+//      01234567890123456789012345678901
+/* 0*/ "................................",
+/* 1*/ "................................",
+/* 2*/ "........................xxxxxxxx",
+/* 3*/ "........................xxxxxxxx",
+/* 4*/ ".................................",
+/* 5*/ "................................",
+/* 6*/ "........................xxxxxxxx",
+/* 7*/ "........................xxxxxxxx",
+
+/* 8*/ "................................",
+/* 9*/ "................................",
+/*10*/ "...x...x...x............xxxxxxxx",
+/*11*/ "........................xxxxxxxx",
+/*12*/ "................................",
+/*13*/ "................................",
+/*14*/ "...x...x...x...x............xxxx",
+/*15*/ "............................xxxx",
+
+//      0       0       0       0
+//      01234567012345670123456701234567
+//      01234567890123456789012345678901
+/*16*/ "................................",
+/*17*/ "................................",
+/*18*/ "................................",
+/*19*/ "................................",
+/*20*/ "................................",
+/*21*/ "................................",
+/*22*/ "................................",
+/*23*/ "................................",
+
+/*24*/ "..xx..xx..xx....................",
+/*25*/ "..xx..xx..xx....................",
+/*26*/ "..xx..xx..xx....................",
+/*27*/ "..xx..xx..xx....................",
+/*28*/ "..xx..xx..xx..xx................",
+/*29*/ "..xx..xx..xx..xx................",
+/*30*/ "..xx..xx..xx..xx................",
+/*31*/ "..xx..xx..xx..xx................"
+};
+
+#define TEST_IMPL(v1, v2, result) \
+    rval &= test_checked_divide(     \
+        v1,                       \
+        v2,                       \
+        BOOST_PP_STRINGIZE(v1),   \
+        BOOST_PP_STRINGIZE(v2),   \
+        result                    \
+    );
+/**/
+
+#define TESTX(value_index1, value_index2)          \
+    (std::cout << value_index1 << ',' << value_index2 << ','); \
+    TEST_IMPL(                                     \
+        BOOST_PP_ARRAY_ELEM(value_index1, VALUES), \
+        BOOST_PP_ARRAY_ELEM(value_index2, VALUES), \
+        test_division_result[value_index1][value_index2] \
+    )
+/**/
+
+int main(int argc, char *argv[]){
+    bool rval = true;
+
+    TEST_EACH_VALUE_PAIR
+    return ! rval ;
+}
+
+
diff --git a/test/test_checked_result.cpp b/test/test_checked_result.cpp
index e3c4373..37e3c0b 100644
--- a/test/test_checked_result.cpp
+++ b/test/test_checked_result.cpp
@@ -23,7 +23,7 @@ bool test2(){
     checked_result<int> x1(0);
     assert(0 == x1);
     checked_result<int> x2(exception_type::overflow_error);
-    assert(! x2.is_valid());
+    assert(! x2.no_exception());
     return true;
 }
 
diff --git a/test/test_divide.cpp b/test/test_divide.cpp
index a3ab4fd..ab0a63f 100644
--- a/test/test_divide.cpp
+++ b/test/test_divide.cpp
@@ -6,9 +6,13 @@
 
 #include <iostream>
 #include <exception>
+#include <cxxabi.h>
 
 #include "../include/safe_integer.hpp"
 
+template <class T>
+using safe_t = boost::numeric::safe<T>;
+
 template<class T1, class T2>
 bool test_divide(
     T1 v1,
@@ -17,127 +21,159 @@ bool test_divide(
     const char *av2,
     char expected_result
 ){
-    std::cout
-        << "testing  "
-        << av1 << " / " << av2
-        << std::endl;
+    using namespace boost::numeric;
+    auto unsafe_result = v1 / v2;
     {
-        boost::numeric::safe<T1> t1 = v1;
-        // presuming native policy
-        boost::numeric::safe<decltype(v1 / v2)> result;
+        std::cout << "testing  safe<" << av1 << "> / " << av2 << " -> ";
+        static_assert(is_safe<safe_t<T1> >::value, "safe_t not safe!");
+
+        safe_t<T1> t1 = v1;
+
+        using result_type = decltype(t1 / v2);
+        result_type result;
+
+        static_assert(
+            is_safe<result_type>::value,
+            "Expression failed to return safe type"
+        );
 
         try{
             result = t1 / v2;
-            static_assert(
-                boost::numeric::is_safe<decltype(t1 + v2)>::value,
-                "Expression failed to return safe type"
-            );
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
             if(expected_result == 'x'){
+                const std::type_info & ti = typeid(result);
+                int status;
                 std::cout
-                    << "failed to detect error in division "
-                    << std::hex << result << "(" << std::dec << result << ")"
-                    << " ! = "<< av1 << " / " << av2
+                    << "*** failed to detect error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
                     << std::endl;
                 try{
                     t1 / v2;
                 }
                 catch(std::exception){}
+                assert(result != unsafe_result);
                 return false;
             }
         }
         catch(std::exception){
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
             if(expected_result == '.'){
+                const std::type_info & ti = typeid(result);
+                int status;
                 std::cout
-                    << "erroneously detected error in division "
-                    << std::hex << result << "(" << std::dec << result << ")"
-                    << " == "<< av1 << " / " << av2
+                    << "*** erroneously detected error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
                     << std::endl;
                 try{
                     t1 / v2;
                 }
                 catch(std::exception){}
+                assert(result == unsafe_result);
                 return false;
             }
         }
     }
     {
-        boost::numeric::safe<T2> t2 = v2;
-        // presuming native policy
-        boost::numeric::safe<decltype(v1 / v2)> result;
+        std::cout << "testing  " << av1 << " * " << "safe<"<< av2 << "> -> ";
+        static_assert(is_safe<safe_t<T2> >::value, "safe_t not safe!");
+
+        safe_t<T2> t2 = v2;
+
+        using result_type = decltype(v1 / t2);
+        result_type result;
+
+        static_assert(
+            is_safe<result_type>::value,
+            "Expression failed to return safe type"
+        );
 
         try{
             result = v1 / t2;
-            static_assert(
-                boost::numeric::is_safe<decltype(v1 / t2)>::value,
-                "Expression failed to return safe type"
-            );
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
             if(expected_result == 'x'){
+                const std::type_info & ti = typeid(result);
+                int status;
                 std::cout
-                    << "failed to detect error in division "
-                    << std::hex << result << "(" << std::dec << result << ")"
-                    << " ! = "<< av1 << " / " << av2
+                    << "*** failed to detect error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
                     << std::endl;
                 try{
                     v1 / t2;
                 }
                 catch(std::exception){}
+                assert(result != unsafe_result);
                 return false;
             }
         }
         catch(std::exception){
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
             if(expected_result == '.'){
+                const std::type_info & ti = typeid(result);
+                int status;
                 std::cout
-                    << "erroneously detected error in division "
-                    << std::hex << result << "(" << std::dec << result << ")"
-                    << " == "<< av1 << " / " << av2
+                    << "*** erroneously detected error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
                     << std::endl;
                 try{
                     v1 / t2;
                 }
                 catch(std::exception){}
+                assert(result == unsafe_result);
                 return false;
             }
         }
     }
     {
-        boost::numeric::safe<T1> t1 = v1;
-        boost::numeric::safe<T2> t2 = v2;
+        std::cout << "testing  safe<" << av1 << "> * safe<" << av2 << "> -> ";
+        safe_t<T1> t1 = v1;
+        safe_t<T2> t2 = v2;
 
-        // presuming native policy
-        boost::numeric::safe<decltype(v1 + v2)> result;
+        using result_type = decltype(t1 / t2);
+        result_type result;
+
+        static_assert(
+            is_safe<result_type>::value,
+            "Expression failed to return safe type"
+        );
 
         try{
             result = t1 / t2;
-
-            static_assert(
-                boost::numeric::is_safe<decltype(t1 + t2)>::value,
-                "Expression failed to return safe type"
-            );
-
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
             if(expected_result == 'x'){
+                const std::type_info & ti = typeid(result);
+                int status;
                 std::cout
-                    << "failed to detect error in division "
-                    << std::hex << result << "(" << std::dec << result << ")"
-                    << " ! = "<< av1 << " / " << av2
+                    << "*** failed to detect error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
                     << std::endl;
                 try{
                     t1 / t2;
                 }
                 catch(std::exception){}
+                // assert(result != unsafe_result);
                 return false;
             }
         }
         catch(std::exception){
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
             if(expected_result == '.'){
+                const std::type_info & ti = typeid(result);
+                int status;
                 std::cout
-                    << "erroneously detected error in division "
-                    << std::hex << result << "(" << std::dec << result << ")"
-                    << " == "<< av1 << " / " << av2
+                    << "*** erroneously detected error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
                     << std::endl;
                 try{
                     t1 / t2;
                 }
                 catch(std::exception){}
+                // assert(result == unsafe_result);
                 return false;
             }
         }
@@ -167,11 +203,11 @@ const char *test_division_result[VALUE_ARRAY_SIZE] = {
 
 /* 8*/ "................................",
 /* 9*/ "................................",
-/*10*/ "..xx..xx..xx............xxxxxxxx",
+/*10*/ "...x...x...x............xxxxxxxx",
 /*11*/ "........................xxxxxxxx",
 /*12*/ "................................",
 /*13*/ "................................",
-/*14*/ "..xx..xx..xx..xx............xxxx",
+/*14*/ "...x...x...x...x...........xxxxx",
 /*15*/ "............................xxxx",
 
 //      0       0       0       0
@@ -207,7 +243,7 @@ const char *test_division_result[VALUE_ARRAY_SIZE] = {
 /**/
 
 #define TESTX(value_index1, value_index2)          \
-    (std::cout << value_index1 << ',' << value_index2 << ','); \
+    (std::cout << value_index1 << ',' << value_index2 << '\n'); \
     TEST_IMPL(                                     \
         BOOST_PP_ARRAY_ELEM(value_index1, VALUES), \
         BOOST_PP_ARRAY_ELEM(value_index2, VALUES), \
diff --git a/test/test_divide_auto.cpp b/test/test_divide_auto.cpp
new file mode 100644
index 0000000..dabd745
--- /dev/null
+++ b/test/test_divide_auto.cpp
@@ -0,0 +1,262 @@
+//  Copyright (c) 2012 Robert Ramey
+//
+// 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)
+
+#include <iostream>
+#include <exception>
+#include <cxxabi.h>
+
+#include "../include/safe_integer.hpp"
+#include "../include/automatic.hpp"
+
+template <class T>
+using safe_t = boost::numeric::safe<
+    T,
+    boost::numeric::automatic
+>;
+
+template<class T1, class T2>
+bool test_divide_auto(
+    T1 v1,
+    T2 v2,
+    const char *av1,
+    const char *av2,
+    char expected_result
+){
+    using namespace boost::numeric;
+    auto unsafe_result = v1 / v2;
+    {
+        std::cout << "testing  safe<" << av1 << "> / " << av2 << " -> ";
+        static_assert(is_safe<safe_t<T1> >::value, "safe_t not safe!");
+
+        safe_t<T1> t1 = v1;
+
+        using result_type = decltype(t1 / v2);
+        result_type result;
+
+        static_assert(
+            is_safe<result_type>::value,
+            "Expression failed to return safe type"
+        );
+
+        try{
+            result = t1 / v2;
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
+            if(expected_result == 'x'){
+                const std::type_info & ti = typeid(result);
+                int status;
+                std::cout
+                    << "*** failed to detect error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
+                    << std::endl;
+                try{
+                    t1 / v2;
+                }
+                catch(std::exception){}
+                assert(result != unsafe_result);
+                return false;
+            }
+        }
+        catch(std::exception){
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
+            if(expected_result == '.'){
+                const std::type_info & ti = typeid(result);
+                int status;
+                std::cout
+                    << "*** erroneously detected error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
+                    << std::endl;
+                try{
+                    t1 / v2;
+                }
+                catch(std::exception){}
+                assert(result == unsafe_result);
+                return false;
+            }
+        }
+    }
+    {
+        std::cout << "testing  " << av1 << " * " << "safe<"<< av2 << "> -> ";
+        static_assert(is_safe<safe_t<T2> >::value, "safe_t not safe!");
+
+        safe_t<T2> t2 = v2;
+
+        using result_type = decltype(v1 / t2);
+        result_type result;
+
+        static_assert(
+            is_safe<result_type>::value,
+            "Expression failed to return safe type"
+        );
+
+        try{
+            result = v1 / t2;
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
+            if(expected_result == 'x'){
+                const std::type_info & ti = typeid(result);
+                int status;
+                std::cout
+                    << "*** failed to detect error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
+                    << std::endl;
+                try{
+                    v1 / t2;
+                }
+                catch(std::exception){}
+                assert(result != unsafe_result);
+                return false;
+            }
+        }
+        catch(std::exception){
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
+            if(expected_result == '.'){
+                const std::type_info & ti = typeid(result);
+                int status;
+                std::cout
+                    << "*** erroneously detected error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
+                    << std::endl;
+                try{
+                    v1 / t2;
+                }
+                catch(std::exception){}
+                assert(result == unsafe_result);
+                return false;
+            }
+        }
+    }
+    {
+        std::cout << "testing  safe<" << av1 << "> * safe<" << av2 << "> -> ";
+        safe_t<T1> t1 = v1;
+        safe_t<T2> t2 = v2;
+
+        using result_type = decltype(t1 / t2);
+        result_type result;
+
+        static_assert(
+            is_safe<result_type>::value,
+            "Expression failed to return safe type"
+        );
+
+        try{
+            result = t1 / t2;
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
+            if(expected_result == 'x'){
+                const std::type_info & ti = typeid(result);
+                int status;
+                std::cout
+                    << "*** failed to detect error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
+                    << std::endl;
+                try{
+                    t1 / t2;
+                }
+                catch(std::exception){}
+                assert(result != unsafe_result);
+                return false;
+            }
+        }
+        catch(std::exception){
+            std::cout << std::hex << result << "(" << std::dec << result << ")"
+                << std::endl;
+            if(expected_result == '.'){
+                const std::type_info & ti = typeid(result);
+                int status;
+                std::cout
+                    << "*** erroneously detected error in division "
+                    << abi::__cxa_demangle(ti.name(),0,0,&status) << '\n'
+                    << std::endl;
+                try{
+                    t1 / t2;
+                }
+                catch(std::exception){}
+                assert(result == unsafe_result);
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+#include "test.hpp"
+#include "test_values.hpp"
+
+// note: These tables presume that the the size of an int is 32 bits.
+// This should be changed for a different architecture or better yet
+// be dynamically adjusted depending on the indicated architecture
+
+const char *test_division_result[VALUE_ARRAY_SIZE] = {
+//      0       0       0       0
+//      01234567012345670123456701234567
+//      01234567890123456789012345678901
+/* 0*/ "................................",
+/* 1*/ "................................",
+/* 2*/ "................................",
+/* 3*/ ".........................xxxxxxx",
+/* 4*/ ".................................",
+/* 5*/ "................................",
+/* 6*/ "........................xxxxxxxx",
+/* 7*/ "........................xxxxxxxx",
+
+/* 8*/ "................................",
+/* 9*/ "................................",
+/*10*/ "..xx..xx..xx............xxxxxxxx",
+/*11*/ "........................xxxxxxxx",
+/*12*/ "................................",
+/*13*/ "................................",
+/*14*/ "..xx..xx..xx..xx............xxxx",
+/*15*/ "............................xxxx",
+
+//      0       0       0       0
+//      01234567012345670123456701234567
+//      01234567890123456789012345678901
+/*16*/ "................................",
+/*17*/ "................................",
+/*18*/ "................................",
+/*19*/ "................................",
+/*20*/ "................................",
+/*21*/ "................................",
+/*22*/ "................................",
+/*23*/ "................................",
+
+/*24*/ "..xx..xx..xx....................",
+/*25*/ "..xx..xx..xx....................",
+/*26*/ "..xx..xx..xx....................",
+/*27*/ "..xx..xx..xx....................",
+/*28*/ "..xx..xx..xx..xx................",
+/*29*/ "..xx..xx..xx..xx................",
+/*30*/ "..xx..xx..xx..xx................",
+/*31*/ "..xx..xx..xx..xx................"
+};
+
+#define TEST_IMPL(v1, v2, result) \
+    rval &= test_divide_auto(     \
+        v1,                       \
+        v2,                       \
+        BOOST_PP_STRINGIZE(v1),   \
+        BOOST_PP_STRINGIZE(v2),   \
+        result                    \
+    );
+/**/
+
+#define TESTX(value_index1, value_index2)          \
+    (std::cout << value_index1 << ',' << value_index2 << ','); \
+    TEST_IMPL(                                     \
+        BOOST_PP_ARRAY_ELEM(value_index1, VALUES), \
+        BOOST_PP_ARRAY_ELEM(value_index2, VALUES), \
+        test_division_result[value_index1][value_index2] \
+    )
+/**/
+
+int main(int argc, char * argv[]){
+    bool rval = true;
+    TEST_EACH_VALUE_PAIR
+    return ! rval ;
+}
diff --git a/test/test_interval.cpp b/test/test_interval.cpp
index 97d39c2..9dba173 100644
--- a/test/test_interval.cpp
+++ b/test/test_interval.cpp
@@ -1,12 +1,15 @@
 #include <cassert>
 #include <iostream>
 #include <ostream>
+#include <cstdint>
+#include <cxxabi.h>
 
 #include "../include/interval.hpp"
 #include <boost/logic/tribool_io.hpp>
 
 bool test1(){
     using namespace boost::numeric;
+    std::cout << "test1" << std::endl;
     interval<std::int16_t> x = {-64, 63};
     std::cout << "x = " << x;
     interval<std::int16_t> y(-128, 126);
@@ -19,6 +22,7 @@ bool test1(){
 
 bool test2(){
     using namespace boost::numeric;
+    std::cout << "test2" << std::endl;
     boost::numeric::interval<std::int16_t> x = {-64, 63};
     std::cout << "x = " << x;
     std::cout << std::boolalpha << "(x == x) = " << (x == x) << std::endl;
@@ -27,6 +31,7 @@ bool test2(){
 
 bool test3(){
     using namespace boost::numeric;
+    std::cout << "test3" << std::endl;
     interval<std::int8_t> t;
     std::cout << "t = " << t;
     interval<std::uint64_t> u;
@@ -37,11 +42,143 @@ bool test3(){
     return true;
 }
 
+#include <limits>
+
+namespace test4 {
+    using namespace boost::numeric;
+    using max_t = std::intmax_t;
+    // typedef typename print<max_t>::type p_max_t;
+
+    template<typename Tx>
+    SAFE_NUMERIC_CONSTEXPR static const interval<Tx> r_upper(const interval<Tx> & t){
+        static_assert(
+            std::is_literal_type< interval<Tx> >::value,
+            "interval<Tx> is not literal type"
+        );
+        return interval<Tx>(
+            max(checked_result<Tx>(1), t.l),
+            t.u
+        );
+    }
+    template<typename Tx>
+    SAFE_NUMERIC_CONSTEXPR static const interval<Tx> r_lower(const interval<Tx> & t){
+        static_assert(
+            std::is_literal_type< interval<Tx> >::value,
+            "interval<Tx> is not literal type"
+        );
+        return interval<Tx>(
+            t.l,
+            min(checked_result<Tx>(-1), t.u)
+        );
+    }
+
+    template<typename Tx, typename Ux>
+    SAFE_NUMERIC_CONSTEXPR static const interval<max_t> r(
+        const interval<Tx> & t,
+        const interval<Ux> & u
+    ){
+        if(std::numeric_limits<Ux>::is_signed){
+            if(u.l > 0 || u.u < 0){
+                auto retval = operator/<max_t>(t, u);
+                // typedef print<decltype(retval)> p_retval;
+                return retval;
+                //return operator/<max_t>(t, u);
+            }
+            else{
+                auto lower = operator/<max_t>(t,r_lower(u));
+                // typedef print<decltype(lower)> p_lower;
+                auto upper = operator/<max_t>(t,r_upper(u));
+                // typedef print<decltype(upper)> p_lower;
+                return
+                    interval< max_t>(
+                        min(lower.l, upper.l),
+                        max(lower.u, upper.u)
+                    );
+                /*
+                */
+                // return t;
+            }
+        }
+        else{ // u is unsigned
+            if(u.l > 0)
+                return operator/<max_t>(t, u);
+            else
+                return operator/<max_t>(t, r_upper(u)) ;
+        };
+    };
+
+    bool test1(){
+        using namespace boost::numeric;
+        int status;
+        std::cout << "test4::test1" << std::endl;
+        const interval<std::int8_t> t;
+        std::cout
+            << abi::__cxa_demangle(typeid(t).name(),0,0,&status)
+            << " t = "
+            << t;
+        const interval<std::int8_t> u;
+        std::cout
+            << abi::__cxa_demangle(typeid(u).name(),0,0,&status)
+            << " u = "
+            << u;
+        const interval<max_t> rx = r(t, u);
+        std::cout
+            << abi::__cxa_demangle(typeid(rx).name(),0,0,&status)
+            << " rx = "
+            << rx;
+        return true;
+    }
+    bool test2(){
+        using namespace boost::numeric;
+        int status;
+        std::cout << "test4::test2" << std::endl;
+        const interval<std::int8_t> t;
+        std::cout
+            << abi::__cxa_demangle(typeid(t).name(),0,0,&status)
+            << " t = "
+            << t;
+        const interval<std::int64_t> u;
+        std::cout
+            << abi::__cxa_demangle(typeid(u).name(),0,0,&status)
+            << " u = "
+            << u;
+        const interval<max_t> rx = r(t, u);
+        std::cout
+            << abi::__cxa_demangle(typeid(rx).name(),0,0,&status)
+            << " rx = "
+            << rx;
+        return true;
+    }
+    bool test3(){
+        using namespace boost::numeric;
+        int status;
+        std::cout << "test4::test2" << std::endl;
+        const interval<std::int8_t> t;
+        std::cout
+            << abi::__cxa_demangle(typeid(t).name(),0,0,&status)
+            << " t = "
+            << t;
+        const interval<std::uint64_t> u;
+        std::cout
+            << abi::__cxa_demangle(typeid(u).name(),0,0,&status)
+            << " u = "
+            << u;
+        const interval<max_t> rx = r(t, u);
+        std::cout
+            << abi::__cxa_demangle(typeid(rx).name(),0,0,&status)
+            << " rx = "
+            << rx;
+        return true;
+    }
+};
 
 int main(){
     return (
         test1() &&
         test2() &&
-        test3()
+        test3() &&
+        test4::test1() &&
+        test4::test2() &&
+        test4::test3()
     ) ? EXIT_SUCCESS : EXIT_FAILURE;
 }
\ No newline at end of file
diff --git a/test/test_multiply_auto.cpp b/test/test_multiply_auto.cpp
index c7b1453..3cd1cd1 100644
--- a/test/test_multiply_auto.cpp
+++ b/test/test_multiply_auto.cpp
@@ -26,9 +26,9 @@ bool test_multiply_auto(
     char expected_result
 ){
     using namespace boost::numeric;
-    auto unsafe_result = v1 + v2;
+    auto unsafe_result = v1 * v2;
     {
-        std::cout << "testing  safe<" << av1 << "> * " << av2 << " -> ";
+        std::cout << "testing safe<" << av1 << "> * " << av2 << " -> ";
         static_assert(is_safe<safe_t<T1> >::value, "safe_t not safe!");
 
         safe_t<T1> t1 = v1;
diff --git a/test/test_z.cpp b/test/test_z.cpp
index d4a1bea..889298a 100644
--- a/test/test_z.cpp
+++ b/test/test_z.cpp
@@ -1,24 +1,120 @@
+#if 0
+
+#include <iostream>
+#include <cstdint>
+
+template<typename T>
+struct division_result {
+    static const T t = '0';
+};
+
+template<class T>
+int test(){
+    std::cout << "t = " << division_result<T>::t << std::endl;
+    return 0;
+}
+int main(){
+    test<std::int8_t>();
+    return 0;
+}
+
+#endif
+
+#include <iostream>
+#include <cstdint>
+#include <type_traits>
 
 #include "../include/safe_integer.hpp"
-#include "../include/native.hpp"
+#include "../include/automatic.hpp"
+
+template <class T>
+using safe_t = boost::numeric::safe<
+    T,
+    boost::numeric::automatic
+>;
 
 int main(){
     using namespace boost::numeric;
-/*
-
-    safe<uint16_t> x = 0xffff;
-    uint16_t y = 0xffff;
-
-    typedef boost::numeric::native::multiplication_result<
-        decltype(x),
-        decltype(y),
-        native,
-        void
-    >::type result_type;
-    print<result_type> p_rt;
-    print<decltype(y + y)> p_yy;
-
-    x * y;
-*/
+    {
+        const safe_t<std::uint8_t> t = 10;
+        const std::uint8_t u = 2;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    {
+        const safe_t<std::uint32_t> t = std::numeric_limits<safe_t<std::uint8_t>>::max();
+        const std::int8_t u = -128;
+        try {
+            auto z = t / u;
+            std::cout << z << std::endl;
+        }
+        catch(const std::exception & e){}
+    }
+    {
+        const safe_t<std::uint8_t> t = std::numeric_limits<safe_t<std::uint8_t>>::max();
+        const std::uint8_t u = 0;
+        try {
+            auto z = t / u;
+            std::cout << z << std::endl;
+        }
+        catch(const std::exception & e){}
+    }
+    {
+        const safe_t<std::uint8_t> t = 10;
+        const std::uint8_t u = 2;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    {
+        const safe_t<std::uint8_t> t = 10;
+        const std::int8_t u = -1;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    {
+        const safe_t<std::int8_t> t = -10;
+        const std::uint8_t u = 2;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    {
+        const safe_t<std::int8_t> t = 10;
+        const std::int8_t u = -1;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    {
+        const safe_t<std::int64_t> t = 10;
+        const std::int8_t u = -1;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    {
+        const safe_t<std::int32_t> t = 10;
+        const std::int8_t u = -1;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    {
+        safe_t<std::int8_t> t = 1;
+        std::int32_t u = 0x7fffffff;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    {
+        const safe_t<std::int8_t> t = 10;
+        const std::int64_t u = 2;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
+    /*
+    */
+    {
+        const safe_t<std::int8_t> t = 10;
+        const std::uint64_t u = 2;
+        auto z = t / u;
+        std::cout << z << std::endl;
+    }
     return 0;
 }
+