diff --git a/include/boost/histogram/detail/axes.hpp b/include/boost/histogram/detail/axes.hpp
index e591ac7f..ff37df58 100644
--- a/include/boost/histogram/detail/axes.hpp
+++ b/include/boost/histogram/detail/axes.hpp
@@ -133,12 +133,12 @@ void axes_assign(dynamic_axes<Ts...>& t, const dynamic_axes<Us...>& u) {
 }
 
 template <typename... Ts>
-constexpr unsigned axes_size(const static_axes<Ts...>&) {
+constexpr std::size_t axes_size(const static_axes<Ts...>&) {
   return sizeof...(Ts);
 }
 
 template <typename... Ts>
-unsigned axes_size(const dynamic_axes<Ts...>& axes) {
+std::size_t axes_size(const dynamic_axes<Ts...>& axes) {
   return axes.size();
 }
 
@@ -264,19 +264,25 @@ struct shape_collector {
 };
 
 namespace {
+
 template <typename LN, typename T>
 struct sub_axes_impl {};
 
 template <typename LN, typename... Ts>
 struct sub_axes_impl<LN, static_axes<Ts...>> {
+  static_assert(mp11::mp_is_set<LN>::value,
+                "integer arguments must be strictly ascending");
+  static_assert(mp_last<LN>::value < sizeof...(Ts), "index out of range");
   template <typename I>
   using at = mp11::mp_at<mp11::mp_list<Ts...>, I>;
-  using L = mp11::mp_rename<unique_sorted<LN>, static_axes>;
+  using L = mp11::mp_rename<LN, static_axes>;
   using type = mp11::mp_transform<at, L>;
 };
 
 template <typename LN, typename... Ts>
 struct sub_axes_impl<LN, dynamic_axes<Ts...>> {
+  static_assert(mp11::mp_is_set<LN>::value,
+                "integer arguments must be strictly ascending");
   using type = dynamic_axes<Ts...>;
 };
 }
@@ -301,7 +307,7 @@ sub_axes<static_axes<Ts...>, Ns...> make_sub_axes(const static_axes<Ts...>& t, N
   using T = static_axes<Ts...>;
   using U = sub_axes<static_axes<Ts...>, Ns...>;
   U u;
-  using N1 = unique_sorted<mp11::mp_list<Ns...>>;
+  using N1 = mp11::mp_list<Ns...>;
   using N2 = mp11::mp_iota<mp11::mp_size<N1>>;
   using N3 = mp11::mp_transform<std::pair, N2, N1>;
   mp11::mp_for_each<N3>(sub_static_assign_impl<T, U>{t, u});
@@ -323,9 +329,9 @@ struct sub_dynamic_assign_impl {
 template <typename... Ts, typename... Ns>
 sub_axes<dynamic_axes<Ts...>, Ns...> make_sub_axes(const dynamic_axes<Ts...>& t, Ns...) {
   using T = dynamic_axes<Ts...>;
-  T u;
+  T u(t.get_allocator());
   u.reserve(sizeof...(Ns));
-  using N = unique_sorted<mp11::mp_list<Ns...>>;
+  using N = mp11::mp_list<Ns...>;
   mp11::mp_for_each<N>(sub_dynamic_assign_impl<T>{t, u});
   return u;
 }
@@ -415,7 +421,7 @@ void args_to_index(optional_index& idx, const static_axes<Ts...>& axes, const U&
                    const Us&... us) {
   const auto a_size = std::get<D>(axes).size();
   const auto a_shape = std::get<D>(axes).shape();
-  const int j = std::get<D>(axes).index(u);
+  const auto j = std::get<D>(axes).index(u);
   linearize(idx, a_size, a_shape, j);
   args_to_index<(D + 1)>(idx, axes, us...);
 }
@@ -431,7 +437,7 @@ void args_to_index_iter(mp11::mp_size_t<N>, optional_index& idx,
   const auto& a = axis_get<D>(axes);
   const auto a_size = a.size();
   const auto a_shape = a.shape();
-  const int j = a.index(*iter);
+  const auto j = a.index(*iter);
   linearize(idx, a_size, a_shape, j);
   args_to_index_iter(mp11::mp_size_t<(N - 1)>(), idx, axes, ++iter);
 }
@@ -446,7 +452,7 @@ void args_to_index_get(mp11::mp_size_t<N>, optional_index& idx,
   constexpr std::size_t D = mp_size<T>::value - N;
   const auto a_size = std::get<D>(axes).size();
   const auto a_shape = std::get<D>(axes).shape();
-  const int j = std::get<D>(axes).index(std::get<D>(t));
+  const auto j = std::get<D>(axes).index(std::get<D>(t));
   linearize(idx, a_size, a_shape, j);
   args_to_index_get(mp11::mp_size_t<(N - 1)>(), idx, axes, t);
 }
diff --git a/include/boost/histogram/detail/meta.hpp b/include/boost/histogram/detail/meta.hpp
index 5ecd5d0d..6d5ccffe 100644
--- a/include/boost/histogram/detail/meta.hpp
+++ b/include/boost/histogram/detail/meta.hpp
@@ -116,12 +116,12 @@ using copy_qualifiers = mp11::mp_if<
 template <typename S, typename L>
 using mp_set_union = mp11::mp_apply_q<mp11::mp_bind_front<mp11::mp_set_push_back, S>, L>;
 
-template <typename Ns>
-using unique_sorted = mp11::mp_unique<mp11::mp_sort<Ns, mp11::mp_less>>;
-
 template <unsigned N, typename T>
 using arg_type = mp11::mp_at_c<callable_traits::args_t<T>, N>;
 
+template <typename L>
+using mp_last = mp11::mp_at_c<L, (mp11::mp_size<L>::value - 1)>;
+
 } // namespace detail
 } // namespace histogram
 } // namespace boost
diff --git a/include/boost/histogram/histogram.hpp b/include/boost/histogram/histogram.hpp
index 37827b62..9f614ceb 100644
--- a/include/boost/histogram/histogram.hpp
+++ b/include/boost/histogram/histogram.hpp
@@ -97,12 +97,14 @@ public:
   }
 
   histogram& operator/=(const scale_type rhs) {
+    static_assert(std::is_floating_point<scale_type>::value,
+                  "division requires a floating point type");
     storage_ *= scale_type(1) / rhs;
     return *this;
   }
 
   /// Number of axes (dimensions) of histogram
-  unsigned dim() const noexcept { return detail::axes_size(axes_); }
+  std::size_t dim() const noexcept { return detail::axes_size(axes_); }
 
   /// Total number of bins in the histogram (including underflow/overflow)
   std::size_t size() const noexcept { return storage_.size(); }
@@ -111,34 +113,36 @@ public:
   void reset() { storage_.reset(storage_.size()); }
 
   /// Get N-th axis (const version)
-  template <int N>
-  auto axis(mp11::mp_int<N>) const -> const detail::axis_at<N, axes_type>& {
+  template <std::size_t N>
+  auto axis(mp11::mp_size_t<N>) const -> const detail::axis_at<N, axes_type>& {
     detail::range_check<N>(axes_);
     return detail::axis_get<N>(axes_);
   }
 
   /// Get N-th axis
-  template <int N>
-  auto axis(mp11::mp_int<N>) -> detail::axis_at<N, axes_type>& {
+  template <std::size_t N>
+  auto axis(mp11::mp_size_t<N>) -> detail::axis_at<N, axes_type>& {
     detail::range_check<N>(axes_);
     return detail::axis_get<N>(axes_);
   }
 
   /// Get first axis (convenience for 1-d histograms, const version)
-  const detail::axis_at<0, axes_type>& axis() const { return axis(mp11::mp_int<0>()); }
+  const detail::axis_at<0, axes_type>& axis() const { return axis(mp11::mp_size_t<0>()); }
 
   /// Get first axis (convenience for 1-d histograms)
-  detail::axis_at<0, axes_type>& axis() { return axis(mp11::mp_int<0>()); }
+  detail::axis_at<0, axes_type>& axis() { return axis(mp11::mp_size_t<0>()); }
 
   /// Get N-th axis with runtime index (const version)
   template <typename U = axes_type, typename = detail::requires_dynamic_axes<U>>
-  const detail::axis_at<0, U>& axis(int i) const {
+  const detail::axis_at<0, U>& axis(std::size_t i) const {
+    BOOST_ASSERT_MSG(i < axes_.size(), "index out of range");
     return axes_[i];
   }
 
   /// Get N-th axis with runtime index
   template <typename U = axes_type, typename = detail::requires_dynamic_axes<U>>
-  detail::axis_at<0, U>& axis(int i) {
+  detail::axis_at<0, U>& axis(std::size_t i) {
+    BOOST_ASSERT_MSG(i < axes_.size(), "index out of range");
     return axes_[i];
   }
 
@@ -200,14 +204,18 @@ public:
   }
 
   /// Returns a lower-dimensional histogram
-  template <int N, typename... Ns>
-  auto reduce_to(mp11::mp_int<N>, Ns...) const
-      -> histogram<detail::sub_axes<axes_type, mp11::mp_int<N>, Ns...>, storage_type> {
-    using sub_axes_type = detail::sub_axes<axes_type, mp11::mp_int<N>, Ns...>;
+  // precondition: argument sequence must be strictly ascending axis indices
+  template <std::size_t I, typename... Ns>
+  auto reduce_to(mp11::mp_size_t<I>, Ns...) const
+      -> histogram<detail::sub_axes<axes_type, mp11::mp_size_t<I>, Ns...>, storage_type> {
+    using N = mp11::mp_size_t<I>;
+    using LN = mp11::mp_list<N, Ns...>;
+    detail::range_check<detail::mp_last<LN>::value>(axes_);
+    using sub_axes_type = detail::sub_axes<axes_type, N, Ns...>;
     using HR = histogram<sub_axes_type, storage_type>;
-    auto sub_axes = detail::make_sub_axes(axes_, mp11::mp_int<N>(), Ns()...);
+    auto sub_axes = detail::make_sub_axes(axes_, N(), Ns()...);
     auto hr = HR(std::move(sub_axes), storage_type(storage_.get_allocator()));
-    const auto b = detail::bool_mask<mp11::mp_int<N>, Ns...>(dim(), true);
+    const auto b = detail::bool_mask<N, Ns...>(dim(), true);
     std::vector<unsigned> shape(dim());
     for_each_axis(detail::shape_collector(shape.begin()));
     detail::index_mapper m(shape, b);
@@ -215,7 +223,8 @@ public:
     return hr;
   }
 
-  // precondition: range represents sequence of strictly ascending axis indices
+  /// Returns a lower-dimensional histogram
+  // precondition: sequence must be strictly ascending axis indices
   template <typename Iterator, typename U = axes_type,
             typename = detail::requires_dynamic_axes<U>,
             typename = detail::requires_iterator<Iterator>>
@@ -315,6 +324,7 @@ make_dynamic_histogram(Iterator begin, Iterator end) {
   return histogram_type(std::move(axes));
 }
 
+/// dynamic type factory from axis iterators with custom storage type
 template <typename Storage, typename Iterator,
           typename = detail::requires_iterator<Iterator>>
 histogram<mp11::mp_rename<
diff --git a/include/boost/histogram/iterator.hpp b/include/boost/histogram/iterator.hpp
index c7cf2e3e..4572111d 100644
--- a/include/boost/histogram/iterator.hpp
+++ b/include/boost/histogram/iterator.hpp
@@ -31,26 +31,26 @@ public:
     cache_.reset();
   }
 
-  unsigned dim() const noexcept { return histogram_.dim(); }
+  std::size_t dim() const noexcept { return histogram_.dim(); }
 
-  int idx(unsigned dim = 0) const noexcept {
+  int idx(std::size_t dim = 0) const noexcept {
     if (!cache_) { cache_.set(histogram_); }
     cache_.set_idx(idx_);
     return cache_.get(dim);
   }
 
-  auto bin() const -> decltype(std::declval<Histogram&>().axis(mp11::mp_int<0>())[0]) {
-    return histogram_.axis(mp11::mp_int<0>())[idx(0)];
+  auto bin() const -> decltype(std::declval<Histogram&>().axis()[0]) {
+    return histogram_.axis()[idx()];
   }
 
-  template <int D>
-  auto bin(mp11::mp_int<D>) const
-      -> decltype(std::declval<Histogram&>().axis(mp11::mp_int<D>())[0]) {
-    return histogram_.axis(mp11::mp_int<D>())[idx(D)];
+  template <std::size_t I>
+  auto bin(mp11::mp_size_t<I>) const
+      -> decltype(std::declval<Histogram&>().axis(mp11::mp_size_t<I>())[0]) {
+    return histogram_.axis(mp11::mp_size_t<I>())[idx(I)];
   }
 
   template <typename T = Histogram> // use SFINAE for this method
-  auto bin(unsigned dim) const -> decltype(std::declval<T&>().axis(dim)[0]) {
+  auto bin(std::size_t dim) const -> decltype(std::declval<T&>().axis(dim)[0]) {
     return histogram_.axis(dim)[idx(dim)];
   }
 
diff --git a/include/boost/histogram/literals.hpp b/include/boost/histogram/literals.hpp
index a9cb2d8e..bd71907b 100644
--- a/include/boost/histogram/literals.hpp
+++ b/include/boost/histogram/literals.hpp
@@ -8,6 +8,7 @@
 #define _BOOST_HISTOGRAM_LITERALS_HPP_
 
 #include <boost/mp11.hpp>
+#include <cstddef>
 
 namespace boost {
 namespace histogram {
@@ -17,59 +18,59 @@ template <char C>
 struct char2int;
 template <>
 struct char2int<'0'> {
-  static constexpr int value = 0;
+  static constexpr std::size_t value = 0;
 };
 template <>
 struct char2int<'1'> {
-  static constexpr int value = 1;
+  static constexpr std::size_t value = 1;
 };
 template <>
 struct char2int<'2'> {
-  static constexpr int value = 2;
+  static constexpr std::size_t value = 2;
 };
 template <>
 struct char2int<'3'> {
-  static constexpr int value = 3;
+  static constexpr std::size_t value = 3;
 };
 template <>
 struct char2int<'4'> {
-  static constexpr int value = 4;
+  static constexpr std::size_t value = 4;
 };
 template <>
 struct char2int<'5'> {
-  static constexpr int value = 5;
+  static constexpr std::size_t value = 5;
 };
 template <>
 struct char2int<'6'> {
-  static constexpr int value = 6;
+  static constexpr std::size_t value = 6;
 };
 template <>
 struct char2int<'7'> {
-  static constexpr int value = 7;
+  static constexpr std::size_t value = 7;
 };
 template <>
 struct char2int<'8'> {
-  static constexpr int value = 8;
+  static constexpr std::size_t value = 8;
 };
 template <>
 struct char2int<'9'> {
-  static constexpr int value = 9;
+  static constexpr std::size_t value = 9;
 };
 
-template <int N>
-constexpr int parse() {
+template <std::size_t N>
+constexpr std::size_t parse() {
   return N;
 }
 
-template <int N, char First, char... Rest>
-constexpr int parse() {
+template <std::size_t N, char First, char... Rest>
+constexpr std::size_t parse() {
   return parse<N * 10 + char2int<First>::value, Rest...>();
 }
 } // namespace detail
 
 template <char... Digits>
-auto operator"" _c() -> ::boost::mp11::mp_int<detail::parse<0, Digits...>()> {
-  return ::boost::mp11::mp_int<detail::parse<0, Digits...>()>();
+auto operator"" _c() -> ::boost::mp11::mp_size_t<detail::parse<0, Digits...>()> {
+  return ::boost::mp11::mp_size_t<detail::parse<0, Digits...>()>();
 }
 
 } // namespace literals
diff --git a/src/python/histogram.cpp b/src/python/histogram.cpp
index 573588f7..5588349e 100644
--- a/src/python/histogram.cpp
+++ b/src/python/histogram.cpp
@@ -98,7 +98,7 @@ public:
     bp::list strides;
     auto& b = self.storage_.buffer_;
     d["typestr"] = bh::detail::apply(dtype_visitor(), b, shapes, strides);
-    for (unsigned i = 0; i < self.dim(); ++i) {
+    for (std::size_t i = 0; i < self.dim(); ++i) {
       if (i > 0) strides.append(strides[-1] * shapes[-1]);
       shapes.append(self.axis(i).shape());
     }
@@ -204,7 +204,7 @@ struct fetcher {
 template <typename T>
 struct span {
   T* data;
-  unsigned size;
+  std::size_t size;
   const T* begin() const { return data; }
   const T* end() const { return data + size; }
 };
@@ -297,7 +297,7 @@ bp::object histogram_getitem(const pyhistogram& self, bp::object args) {
   }
 
   int idx[BOOST_HISTOGRAM_AXIS_LIMIT];
-  for (unsigned i = 0; i < dim; ++i) idx[i] = bp::extract<int>(args[i]);
+  for (std::size_t i = 0; i < dim; ++i) idx[i] = bp::extract<int>(args[i]);
 
   return bp::object(self.at(span<int>{idx, self.dim()}));
 }
diff --git a/test/axis_test.cpp b/test/axis_test.cpp
index 67cc0815..42dbd316 100644
--- a/test/axis_test.cpp
+++ b/test/axis_test.cpp
@@ -51,8 +51,7 @@ int main() {
   {
     axis::regular<> a{4, -2, 2};
     BOOST_TEST_EQ(a[-1].lower(), -std::numeric_limits<double>::infinity());
-    BOOST_TEST_EQ(a[a.size()].upper(),
-                  std::numeric_limits<double>::infinity());
+    BOOST_TEST_EQ(a[a.size()].upper(), std::numeric_limits<double>::infinity());
     axis::regular<> b;
     BOOST_TEST_NOT(a == b);
     b = a;
@@ -150,8 +149,7 @@ int main() {
   {
     axis::variable<> a{-1, 0, 1};
     BOOST_TEST_EQ(a[-1].lower(), -std::numeric_limits<double>::infinity());
-    BOOST_TEST_EQ(a[a.size()].upper(),
-                  std::numeric_limits<double>::infinity());
+    BOOST_TEST_EQ(a[a.size()].upper(), std::numeric_limits<double>::infinity());
     axis::variable<> b;
     BOOST_TEST_NOT(a == b);
     b = a;
@@ -235,10 +233,8 @@ int main() {
   // iterators
   {
     enum { A, B, C };
-    test_axis_iterator(axis::regular<>(5, 0, 1, "", axis::uoflow_type::off),
-                       0, 5);
-    test_axis_iterator(axis::regular<>(5, 0, 1, "", axis::uoflow_type::on), 0,
-                       5);
+    test_axis_iterator(axis::regular<>(5, 0, 1, "", axis::uoflow_type::off), 0, 5);
+    test_axis_iterator(axis::regular<>(5, 0, 1, "", axis::uoflow_type::on), 0, 5);
     test_axis_iterator(axis::circular<>(5, 0, 1, ""), 0, 5);
     test_axis_iterator(axis::variable<>({1, 2, 3}, ""), 0, 2);
     test_axis_iterator(axis::integer<>(0, 4, ""), 0, 4);
@@ -264,8 +260,7 @@ int main() {
     a6 = a1;
     BOOST_TEST_EQ(a6, a1);
     axis::any<axis::regular<>, axis::integer<>> a7(axis::integer<>(0, 2));
-    BOOST_TEST_THROWS(axis::any<axis::regular<>> a8(a7),
-                      std::invalid_argument);
+    BOOST_TEST_THROWS(axis::any<axis::regular<>> a8(a7), std::invalid_argument);
     BOOST_TEST_THROWS(a4 = a7, std::invalid_argument);
   }
 
@@ -288,15 +283,14 @@ int main() {
     std::string b = "B";
     std::vector<axis::any_std> axes;
     axes.push_back(axis::regular<>{2, -1, 1, "regular1"});
-    axes.push_back(axis::regular<axis::transform::log>(
-        2, 1, 10, "regular2", axis::uoflow_type::off));
-    axes.push_back(axis::regular<axis::transform::pow>(
-        2, 1, 10, "regular3", axis::uoflow_type::on, 0.5));
-    axes.push_back(axis::regular<axis::transform::pow>(
-        2, 1, 10, "regular4", axis::uoflow_type::off, -0.5));
+    axes.push_back(axis::regular<axis::transform::log>(2, 1, 10, "regular2",
+                                                       axis::uoflow_type::off));
+    axes.push_back(axis::regular<axis::transform::pow>(2, 1, 10, "regular3",
+                                                       axis::uoflow_type::on, 0.5));
+    axes.push_back(axis::regular<axis::transform::pow>(2, 1, 10, "regular4",
+                                                       axis::uoflow_type::off, -0.5));
     axes.push_back(axis::circular<>(4, 0.1, 1.0, "polar"));
-    axes.push_back(
-        axis::variable<>({-1, 0, 1}, "variable", axis::uoflow_type::off));
+    axes.push_back(axis::variable<>({-1, 0, 1}, "variable", axis::uoflow_type::off));
     axes.push_back(axis::category<>({A, B, C}, "category"));
     axes.push_back(axis::category<std::string>({a, b}, "category2"));
     axes.push_back(axis::integer<>(-1, 1, "integer", axis::uoflow_type::off));
@@ -322,8 +316,8 @@ int main() {
     enum { A, B, C };
     std::vector<axis::any_std> axes;
     axes.push_back(axis::regular<>{2, -1, 1});
-    axes.push_back(axis::regular<axis::transform::pow>(
-        2, 1, 4, "", axis::uoflow_type::on, 0.5));
+    axes.push_back(
+        axis::regular<axis::transform::pow>(2, 1, 4, "", axis::uoflow_type::on, 0.5));
     axes.push_back(axis::circular<>{4});
     axes.push_back(axis::variable<>{-1, 0, 1});
     axes.push_back(axis::category<>{A, B, C});
@@ -348,13 +342,12 @@ int main() {
   // sequence equality
   {
     enum { A, B, C };
-    std::vector<axis::any<axis::regular<>, axis::variable<>, axis::category<>,
-                          axis::integer<>>>
+    std::vector<
+        axis::any<axis::regular<>, axis::variable<>, axis::category<>, axis::integer<>>>
         std_vector1 = {axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
                        axis::category<>{A, B, C}};
 
-    std::vector<
-        axis::any<axis::regular<>, axis::variable<>, axis::category<>>>
+    std::vector<axis::any<axis::regular<>, axis::variable<>, axis::category<>>>
         std_vector2 = {axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
                        axis::category<>{{A, B, C}}};
 
@@ -368,16 +361,13 @@ int main() {
     BOOST_TEST_NOT(detail::axes_equal(std_vector2, std_vector3));
     BOOST_TEST_NOT(detail::axes_equal(std_vector3, std_vector4));
 
-    auto tuple1 =
-        std::make_tuple(axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
-                        axis::category<>{{A, B, C}});
+    auto tuple1 = std::make_tuple(axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
+                                  axis::category<>{{A, B, C}});
 
-    auto tuple2 =
-        std::make_tuple(axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
-                        axis::category<>{{A, B}});
+    auto tuple2 = std::make_tuple(axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
+                                  axis::category<>{{A, B}});
 
-    auto tuple3 = std::make_tuple(axis::regular<>{2, -1, 1},
-                                  axis::variable<>{-1, 0, 1});
+    auto tuple3 = std::make_tuple(axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1});
 
     BOOST_TEST(detail::axes_equal(std_vector1, tuple1));
     BOOST_TEST(detail::axes_equal(tuple1, std_vector1));
@@ -389,22 +379,20 @@ int main() {
   // sequence assign
   {
     enum { A, B, C, D };
-    std::vector<axis::any<axis::regular<>, axis::variable<>, axis::category<>,
-                          axis::integer<>>>
+    std::vector<
+        axis::any<axis::regular<>, axis::variable<>, axis::category<>, axis::integer<>>>
         std_vector1 = {axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
                        axis::category<>{A, B, C}};
 
-    std::vector<
-        axis::any<axis::regular<>, axis::variable<>, axis::category<>>>
+    std::vector<axis::any<axis::regular<>, axis::variable<>, axis::category<>>>
         std_vector2 = {axis::regular<>{2, -2, 2}, axis::variable<>{-2, 0, 2},
                        axis::category<>{A, B}};
 
     detail::axes_assign(std_vector2, std_vector1);
     BOOST_TEST(detail::axes_equal(std_vector2, std_vector1));
 
-    auto tuple1 =
-        std::make_tuple(axis::regular<>{2, -3, 3}, axis::variable<>{-3, 0, 3},
-                        axis::category<>{A, B, C, D});
+    auto tuple1 = std::make_tuple(axis::regular<>{2, -3, 3}, axis::variable<>{-3, 0, 3},
+                                  axis::category<>{A, B, C, D});
 
     detail::axes_assign(tuple1, std_vector1);
     BOOST_TEST(detail::axes_equal(tuple1, std_vector1));
@@ -414,9 +402,8 @@ int main() {
     detail::axes_assign(std_vector3, tuple1);
     BOOST_TEST(detail::axes_equal(std_vector3, tuple1));
 
-    auto tuple2 =
-        std::make_tuple(axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
-                        axis::category<>{A, B});
+    auto tuple2 = std::make_tuple(axis::regular<>{2, -1, 1}, axis::variable<>{-1, 0, 1},
+                                  axis::category<>{A, B});
 
     detail::axes_assign(tuple2, tuple1);
     BOOST_TEST(detail::axes_equal(tuple2, tuple1));
@@ -428,26 +415,17 @@ int main() {
     using ia = axis::integer<>;
     using ca = axis::category<>;
     using T = static_axes<ra, ia, ca>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<detail::sub_axes<T, i0>, static_axes<ra>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<detail::sub_axes<T, i1>, static_axes<ia>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<detail::sub_axes<T, i2>, static_axes<ca>>));
     BOOST_TEST_TRAIT_TRUE(
-        (std::is_same<detail::sub_axes<T, i0>, static_axes<ra>>));
-    BOOST_TEST_TRAIT_TRUE(
-        (std::is_same<detail::sub_axes<T, i1>, static_axes<ia>>));
-    BOOST_TEST_TRAIT_TRUE(
-        (std::is_same<detail::sub_axes<T, i2>, static_axes<ca>>));
-    BOOST_TEST_TRAIT_TRUE((std::is_same<detail::sub_axes<T, i0, i1, i2>,
-                                        static_axes<ra, ia, ca>>));
-    BOOST_TEST_TRAIT_TRUE((std::is_same<detail::sub_axes<T, i2, i0, i1>,
-                                        static_axes<ra, ia, ca>>));
+        (std::is_same<detail::sub_axes<T, i0, i1, i2>, static_axes<ra, ia, ca>>));
     BOOST_TEST_TRAIT_TRUE(
         (std::is_same<detail::sub_axes<T, i0, i1>, static_axes<ra, ia>>));
     BOOST_TEST_TRAIT_TRUE(
         (std::is_same<detail::sub_axes<T, i0, i2>, static_axes<ra, ca>>));
     BOOST_TEST_TRAIT_TRUE(
-        (std::is_same<detail::sub_axes<T, i1, i0>, static_axes<ra, ia>>));
-    BOOST_TEST_TRAIT_TRUE(
-        (std::is_same<detail::sub_axes<T, i2, i1>, static_axes<ia, ca>>));
-    BOOST_TEST_TRAIT_TRUE((std::is_same<detail::sub_axes<T, i1, i2, i2, i1>,
-                                        static_axes<ia, ca>>));
+        (std::is_same<detail::sub_axes<T, i1, i2>, static_axes<ia, ca>>));
   }
 
   // make_sub_tuple
@@ -457,10 +435,9 @@ int main() {
     auto axes = T(ia(0, 1), ia(1, 2), ia(2, 3));
     BOOST_TEST_EQ(detail::make_sub_axes(axes, i1(), i2()),
                   (static_axes<ia, ia>(ia(1, 2), ia(2, 3))));
-    BOOST_TEST_EQ(detail::make_sub_axes(axes, i1(), i0()),
+    BOOST_TEST_EQ(detail::make_sub_axes(axes, i0(), i1()),
                   (static_axes<ia, ia>(ia(0, 1), ia(1, 2))));
-    BOOST_TEST_EQ(detail::make_sub_axes(axes, i1(), i1()),
-                  (static_axes<ia>(ia(1, 2))));
+    BOOST_TEST_EQ(detail::make_sub_axes(axes, i1()), (static_axes<ia>(ia(1, 2))));
     BOOST_TEST_EQ(detail::make_sub_axes(axes, i0(), i1(), i2()), axes);
   }
 
diff --git a/test/fail_histogram_add_dynamic_test.cpp b/test/fail_histogram_dynamic_add_test.cpp
similarity index 51%
rename from test/fail_histogram_add_dynamic_test.cpp
rename to test/fail_histogram_dynamic_add_test.cpp
index 070666ba..741e6647 100644
--- a/test/fail_histogram_add_dynamic_test.cpp
+++ b/test/fail_histogram_dynamic_add_test.cpp
@@ -1,3 +1,9 @@
+// Copyright 2018 Hans Dembinski
+//
+// 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 <boost/histogram.hpp>
 
 using namespace boost::histogram;
diff --git a/test/fail_histogram_dynamic_at_tuple_wrong_dimension_test.cpp b/test/fail_histogram_dynamic_at_tuple_wrong_dimension_test.cpp
index c5389157..0ed96e26 100644
--- a/test/fail_histogram_dynamic_at_tuple_wrong_dimension_test.cpp
+++ b/test/fail_histogram_dynamic_at_tuple_wrong_dimension_test.cpp
@@ -1,3 +1,9 @@
+// Copyright 2018 Hans Dembinski
+//
+// 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 <boost/histogram.hpp>
 #include <utility>
 
diff --git a/test/fail_histogram_dynamic_at_vector_wrong_dimension_test.cpp b/test/fail_histogram_dynamic_at_vector_wrong_dimension_test.cpp
index bb5eb0bc..9c551867 100644
--- a/test/fail_histogram_dynamic_at_vector_wrong_dimension_test.cpp
+++ b/test/fail_histogram_dynamic_at_vector_wrong_dimension_test.cpp
@@ -1,3 +1,9 @@
+// Copyright 2018 Hans Dembinski
+//
+// 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 <boost/histogram.hpp>
 #include <vector>
 
diff --git a/test/fail_histogram_dynamic_at_wrong_dimension_test.cpp b/test/fail_histogram_dynamic_at_wrong_dimension_test.cpp
index c183aacb..49bd9902 100644
--- a/test/fail_histogram_dynamic_at_wrong_dimension_test.cpp
+++ b/test/fail_histogram_dynamic_at_wrong_dimension_test.cpp
@@ -1,3 +1,9 @@
+// Copyright 2018 Hans Dembinski
+//
+// 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 <boost/histogram.hpp>
 
 using namespace boost::histogram;
diff --git a/test/fail_histogram_dynamic_reduce_wrong_order_test.cpp b/test/fail_histogram_dynamic_reduce_wrong_order_test.cpp
new file mode 100644
index 00000000..201f5ccf
--- /dev/null
+++ b/test/fail_histogram_dynamic_reduce_wrong_order_test.cpp
@@ -0,0 +1,14 @@
+// Copyright 2018 Hans Dembinski
+//
+// 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 <boost/histogram.hpp>
+
+using namespace boost::histogram;
+int main() {
+  auto h = make_dynamic_histogram(axis::integer<>(0, 1), axis::integer<>(1, 2));
+  auto v = {0, 0};
+  h.reduce_to(v.begin(), v.end());
+}
diff --git a/test/fail_histogram_add_static_test.cpp b/test/fail_histogram_static_add_test.cpp
similarity index 51%
rename from test/fail_histogram_add_static_test.cpp
rename to test/fail_histogram_static_add_test.cpp
index cff1ed26..7e73c286 100644
--- a/test/fail_histogram_add_static_test.cpp
+++ b/test/fail_histogram_static_add_test.cpp
@@ -1,3 +1,9 @@
+// Copyright 2018 Hans Dembinski
+//
+// 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 <boost/histogram.hpp>
 
 using namespace boost::histogram;
diff --git a/test/fail_histogram_static_at_vector_wrong_dimension_test.cpp b/test/fail_histogram_static_at_vector_wrong_dimension_test.cpp
index 276d1b2a..c425e536 100644
--- a/test/fail_histogram_static_at_vector_wrong_dimension_test.cpp
+++ b/test/fail_histogram_static_at_vector_wrong_dimension_test.cpp
@@ -1,3 +1,9 @@
+// Copyright 2018 Hans Dembinski
+//
+// 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 <boost/histogram.hpp>
 
 using namespace boost::histogram;
diff --git a/test/meta_test.cpp b/test/meta_test.cpp
index 7edce2ea..41e8abd0 100644
--- a/test/meta_test.cpp
+++ b/test/meta_test.cpp
@@ -109,17 +109,21 @@ int main() {
   // rm_cv_ref
   {
     using T1 = int;
-    using T2 = const int;
-    using T3 = const int&;
-    using T4 = volatile int;
-    using T5 = volatile const int;
-    using T6 = volatile const int&;
+    using T2 = int&&;
+    using T3 = const int;
+    using T4 = const int&;
+    using T5 = volatile int;
+    using T6 = volatile int&&;
+    using T7 = volatile const int;
+    using T8 = volatile const int&;
     BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T1>, int>));
     BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T2>, int>));
     BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T3>, int>));
     BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T4>, int>));
     BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T5>, int>));
     BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T6>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T7>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<rm_cv_ref<T8>, int>));
   }
 
   // mp_size
@@ -152,14 +156,5 @@ int main() {
     BOOST_TEST_TRAIT_TRUE((std::is_same<result, expected>));
   }
 
-  // unique_sorted
-  {
-    using input = mp11::mp_list_c<int, 3, 3, 1, 2, 1, 2>;
-    using result = unique_sorted<input>;
-    using expected = mp11::mp_list_c<int, 1, 2, 3>;
-
-    BOOST_TEST_TRAIT_TRUE((std::is_same<result, expected>));
-  }
-
   return boost::report_errors();
 }
diff --git a/test/pass_on_fail.py b/test/pass_on_fail.py
index 80f492f0..41a95cf0 100644
--- a/test/pass_on_fail.py
+++ b/test/pass_on_fail.py
@@ -1,3 +1,11 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2018 Hans Dembinski
+#
+# 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)
+
 import subprocess as subp
 import sys
 import os
diff --git a/test/speed_numpy.py b/test/speed_numpy.py
index 745fc955..65215039 100644
--- a/test/speed_numpy.py
+++ b/test/speed_numpy.py
@@ -1,9 +1,10 @@
-##
-## Copyright 2015-2016 Hans Dembinski
-##
-## 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)
+# -*- coding: utf-8 -*-
+#
+# Copyright 2015-2016 Hans Dembinski
+#
+# 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)
 
 import numpy as np
 from timeit import default_timer as timer
diff --git a/test/utility.hpp b/test/utility.hpp
index 98051ef1..7a8fd9db 100644
--- a/test/utility.hpp
+++ b/test/utility.hpp
@@ -1,4 +1,4 @@
-// Copyright 2015-2017 Hans Dembinski
+// Copyright 2018 Hans Dembinski
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt
@@ -15,10 +15,10 @@
 #include <tuple>
 #include <vector>
 
-using i0 = boost::mp11::mp_int<0>;
-using i1 = boost::mp11::mp_int<1>;
-using i2 = boost::mp11::mp_int<2>;
-using i3 = boost::mp11::mp_int<3>;
+using i0 = boost::mp11::mp_size_t<0>;
+using i1 = boost::mp11::mp_size_t<1>;
+using i2 = boost::mp11::mp_size_t<2>;
+using i3 = boost::mp11::mp_size_t<3>;
 
 namespace std { // never add to std, we only do it to get ADL working
 template <typename T>
diff --git a/test/utility_test.cpp b/test/utility_test.cpp
index 1f5e5115..c36b6fe2 100644
--- a/test/utility_test.cpp
+++ b/test/utility_test.cpp
@@ -1,4 +1,4 @@
-// Copyright 2015-2017 Hans Dembinski
+// Copyright 2018 Hans Dembinski
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt